fdroidserver/common.py

   1 # -*- coding: utf-8 -*-
   2 #
   3 # common.py - part of the FDroid server tools
   4 # Copyright (C) 2010-13, Ciaran Gultnieks, ciaran@ciarang.com
   5 # Copyright (C) 2013-2014 Daniel Martí <mvdan@mvdan.cc>
   6 #
   7 # This program is free software: you can redistribute it and/or modify
   8 # it under the terms of the GNU Affero General Public License as published by
   9 # the Free Software Foundation, either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU Affero General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU Affero General Public License
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 # common.py is imported by all modules, so do not import third-party
  21 # libraries here as they will become a requirement for all commands.
  22
  23 import os
  24 import sys
  25 import re
  26 import shutil
  27 import glob
  28 import stat
  29 import subprocess
  30 import time
  31 import operator
  32 import Queue
  33 import logging
  34 import hashlib
  35 import socket
  36 import xml.etree.ElementTree as XMLElementTree
  37
  38 from distutils.version import LooseVersion
  39 from zipfile import ZipFile
  40
  41 import metadata
  42 from fdroidserver.asynchronousfilereader import AsynchronousFileReader
  43
  44
  45 XMLElementTree.register_namespace('android', 'http://schemas.android.com/apk/res/android')
  46
  47 config = None
  48 options = None
  49 env = None
  50 orig_path = None
  51
  52
  53 default_config = {
  54     'sdk_path': "$ANDROID_HOME",
  55     'ndk_paths': {
  56         'r9b': None,
  57         'r10e': "$ANDROID_NDK",
  58     },
  59     'build_tools': "23.0.1",
  60     'ant': "ant",
  61     'mvn3': "mvn",
  62     'gradle': 'gradle',
  63     'accepted_formats': ['txt', 'yaml'],
  64     'sync_from_local_copy_dir': False,
  65     'per_app_repos': False,
  66     'make_current_version_link': True,
  67     'current_version_name_source': 'Name',
  68     'update_stats': False,
  69     'stats_ignore': [],
  70     'stats_server': None,
  71     'stats_user': None,
  72     'stats_to_carbon': False,
  73     'repo_maxage': 0,
  74     'build_server_always': False,
  75     'keystore': 'keystore.jks',
  76     'smartcardoptions': [],
  77     'char_limits': {
  78         'Summary': 80,
  79         'Description': 4000,
  80     },
  81     'keyaliases': {},
  82     'repo_url': "https://MyFirstFDroidRepo.org/fdroid/repo",
  83     'repo_name': "My First FDroid Repo Demo",
  84     'repo_icon': "fdroid-icon.png",
  85     'repo_description': '''
  86         This is a repository of apps to be used with FDroid. Applications in this
  87         repository are either official binaries built by the original application
  88         developers, or are binaries built from source by the admin of f-droid.org
  89         using the tools on https://gitlab.com/u/fdroid.
  90         ''',
  91     'archive_older': 0,
  92 }
  93
  94
  95 def setup_global_opts(parser):
  96     parser.add_argument("-v", "--verbose", action="store_true", default=False,
  97                         help="Spew out even more information than normal")
  98     parser.add_argument("-q", "--quiet", action="store_true", default=False,
  99                         help="Restrict output to warnings and errors")
 100
 101
 102 def fill_config_defaults(thisconfig):
 103     for k, v in default_config.items():
 104         if k not in thisconfig:
 105             thisconfig[k] = v
 106
 107     # Expand paths (~users and $vars)
 108     def expand_path(path):
 109         if path is None:
 110             return None
 111         orig = path
 112         path = os.path.expanduser(path)
 113         path = os.path.expandvars(path)
 114         if orig == path:
 115             return None
 116         return path
 117
 118     for k in ['sdk_path', 'ant', 'mvn3', 'gradle', 'keystore', 'repo_icon']:
 119         v = thisconfig[k]
 120         exp = expand_path(v)
 121         if exp is not None:
 122             thisconfig[k] = exp
 123             thisconfig[k + '_orig'] = v
 124
 125     for k in ['ndk_paths']:
 126         d = thisconfig[k]
 127         for k2 in d.copy():
 128             v = d[k2]
 129             exp = expand_path(v)
 130             if exp is not None:
 131                 thisconfig[k][k2] = exp
 132                 thisconfig[k][k2 + '_orig'] = v
 133
 134
 135 def regsub_file(pattern, repl, path):
 136     with open(path, 'r') as f:
 137         text = f.read()
 138     text = re.sub(pattern, repl, text)
 139     with open(path, 'w') as f:
 140         f.write(text)
 141
 142
 143 def read_config(opts, config_file='config.py'):
 144     """Read the repository config
 145
 146     The config is read from config_file, which is in the current directory when
 147     any of the repo management commands are used.
 148     """
 149     global config, options, env, orig_path
 150
 151     if config is not None:
 152         return config
 153     if not os.path.isfile(config_file):
 154         logging.critical("Missing config file - is this a repo directory?")
 155         sys.exit(2)
 156
 157     options = opts
 158
 159     config = {}
 160
 161     logging.debug("Reading %s" % config_file)
 162     execfile(config_file, config)
 163
 164     # smartcardoptions must be a list since its command line args for Popen
 165     if 'smartcardoptions' in config:
 166         config['smartcardoptions'] = config['smartcardoptions'].split(' ')
 167     elif 'keystore' in config and config['keystore'] == 'NONE':
 168         # keystore='NONE' means use smartcard, these are required defaults
 169         config['smartcardoptions'] = ['-storetype', 'PKCS11', '-providerName',
 170                                       'SunPKCS11-OpenSC', '-providerClass',
 171                                       'sun.security.pkcs11.SunPKCS11',
 172                                       '-providerArg', 'opensc-fdroid.cfg']
 173
 174     if any(k in config for k in ["keystore", "keystorepass", "keypass"]):
 175         st = os.stat(config_file)
 176         if st.st_mode & stat.S_IRWXG or st.st_mode & stat.S_IRWXO:
 177             logging.warn("unsafe permissions on {0} (should be 0600)!".format(config_file))
 178
 179     fill_config_defaults(config)
 180
 181     # There is no standard, so just set up the most common environment
 182     # variables
 183     env = os.environ
 184     orig_path = env['PATH']
 185     for n in ['ANDROID_HOME', 'ANDROID_SDK']:
 186         env[n] = config['sdk_path']
 187
 188     for k in ["keystorepass", "keypass"]:
 189         if k in config:
 190             write_password_file(k)
 191
 192     for k in ["repo_description", "archive_description"]:
 193         if k in config:
 194             config[k] = clean_description(config[k])
 195
 196     if 'serverwebroot' in config:
 197         if isinstance(config['serverwebroot'], basestring):
 198             roots = [config['serverwebroot']]
 199         elif all(isinstance(item, basestring) for item in config['serverwebroot']):
 200             roots = config['serverwebroot']
 201         else:
 202             raise TypeError('only accepts strings, lists, and tuples')
 203         rootlist = []
 204         for rootstr in roots:
 205             # since this is used with rsync, where trailing slashes have
 206             # meaning, ensure there is always a trailing slash
 207             if rootstr[-1] != '/':
 208                 rootstr += '/'
 209             rootlist.append(rootstr.replace('//', '/'))
 210         config['serverwebroot'] = rootlist
 211
 212     return config
 213
 214
 215 def get_ndk_path(version):
 216     if version is None:
 217         version = 'r10e'  # falls back to latest
 218     paths = config['ndk_paths']
 219     if version not in paths:
 220         return ''
 221     return paths[version] or ''
 222
 223
 224 def find_sdk_tools_cmd(cmd):
 225     '''find a working path to a tool from the Android SDK'''
 226
 227     tooldirs = []
 228     if config is not None and 'sdk_path' in config and os.path.exists(config['sdk_path']):
 229         # try to find a working path to this command, in all the recent possible paths
 230         if 'build_tools' in config:
 231             build_tools = os.path.join(config['sdk_path'], 'build-tools')
 232             # if 'build_tools' was manually set and exists, check only that one
 233             configed_build_tools = os.path.join(build_tools, config['build_tools'])
 234             if os.path.exists(configed_build_tools):
 235                 tooldirs.append(configed_build_tools)
 236             else:
 237                 # no configed version, so hunt known paths for it
 238                 for f in sorted(os.listdir(build_tools), reverse=True):
 239                     if os.path.isdir(os.path.join(build_tools, f)):
 240                         tooldirs.append(os.path.join(build_tools, f))
 241                 tooldirs.append(build_tools)
 242         sdk_tools = os.path.join(config['sdk_path'], 'tools')
 243         if os.path.exists(sdk_tools):
 244             tooldirs.append(sdk_tools)
 245         sdk_platform_tools = os.path.join(config['sdk_path'], 'platform-tools')
 246         if os.path.exists(sdk_platform_tools):
 247             tooldirs.append(sdk_platform_tools)
 248     tooldirs.append('/usr/bin')
 249     for d in tooldirs:
 250         if os.path.isfile(os.path.join(d, cmd)):
 251             return os.path.join(d, cmd)
 252     # did not find the command, exit with error message
 253     ensure_build_tools_exists(config)
 254
 255
 256 def test_sdk_exists(thisconfig):
 257     if 'sdk_path' not in thisconfig:
 258         if 'aapt' in thisconfig and os.path.isfile(thisconfig['aapt']):
 259             return True
 260         else:
 261             logging.error("'sdk_path' not set in config.py!")
 262             return False
 263     if thisconfig['sdk_path'] == default_config['sdk_path']:
 264         logging.error('No Android SDK found!')
 265         logging.error('You can use ANDROID_HOME to set the path to your SDK, i.e.:')
 266         logging.error('\texport ANDROID_HOME=/opt/android-sdk')
 267         return False
 268     if not os.path.exists(thisconfig['sdk_path']):
 269         logging.critical('Android SDK path "' + thisconfig['sdk_path'] + '" does not exist!')
 270         return False
 271     if not os.path.isdir(thisconfig['sdk_path']):
 272         logging.critical('Android SDK path "' + thisconfig['sdk_path'] + '" is not a directory!')
 273         return False
 274     for d in ['build-tools', 'platform-tools', 'tools']:
 275         if not os.path.isdir(os.path.join(thisconfig['sdk_path'], d)):
 276             logging.critical('Android SDK path "%s" does not contain "%s/"!' % (
 277                 thisconfig['sdk_path'], d))
 278             return False
 279     return True
 280
 281
 282 def ensure_build_tools_exists(thisconfig):
 283     if not test_sdk_exists(thisconfig):
 284         sys.exit(3)
 285     build_tools = os.path.join(thisconfig['sdk_path'], 'build-tools')
 286     versioned_build_tools = os.path.join(build_tools, thisconfig['build_tools'])
 287     if not os.path.isdir(versioned_build_tools):
 288         logging.critical('Android Build Tools path "'
 289                          + versioned_build_tools + '" does not exist!')
 290         sys.exit(3)
 291
 292
 293 def write_password_file(pwtype, password=None):
 294     '''
 295     writes out passwords to a protected file instead of passing passwords as
 296     command line argments
 297     '''
 298     filename = '.fdroid.' + pwtype + '.txt'
 299     fd = os.open(filename, os.O_CREAT | os.O_TRUNC | os.O_WRONLY, 0600)
 300     if password is None:
 301         os.write(fd, config[pwtype])
 302     else:
 303         os.write(fd, password)
 304     os.close(fd)
 305     config[pwtype + 'file'] = filename
 306
 307
 308 # Given the arguments in the form of multiple appid:[vc] strings, this returns
 309 # a dictionary with the set of vercodes specified for each package.
 310 def read_pkg_args(args, allow_vercodes=False):
 311
 312     vercodes = {}
 313     if not args:
 314         return vercodes
 315
 316     for p in args:
 317         if allow_vercodes and ':' in p:
 318             package, vercode = p.split(':')
 319         else:
 320             package, vercode = p, None
 321         if package not in vercodes:
 322             vercodes[package] = [vercode] if vercode else []
 323             continue
 324         elif vercode and vercode not in vercodes[package]:
 325             vercodes[package] += [vercode] if vercode else []
 326
 327     return vercodes
 328
 329
 330 # On top of what read_pkg_args does, this returns the whole app metadata, but
 331 # limiting the builds list to the builds matching the vercodes specified.
 332 def read_app_args(args, allapps, allow_vercodes=False):
 333
 334     vercodes = read_pkg_args(args, allow_vercodes)
 335
 336     if not vercodes:
 337         return allapps
 338
 339     apps = {}
 340     for appid, app in allapps.iteritems():
 341         if appid in vercodes:
 342             apps[appid] = app
 343
 344     if len(apps) != len(vercodes):
 345         for p in vercodes:
 346             if p not in allapps:
 347                 logging.critical("No such package: %s" % p)
 348         raise FDroidException("Found invalid app ids in arguments")
 349     if not apps:
 350         raise FDroidException("No packages specified")
 351
 352     error = False
 353     for appid, app in apps.iteritems():
 354         vc = vercodes[appid]
 355         if not vc:
 356             continue
 357         app['builds'] = [b for b in app['builds'] if b['vercode'] in vc]
 358         if len(app['builds']) != len(vercodes[appid]):
 359             error = True
 360             allvcs = [b['vercode'] for b in app['builds']]
 361             for v in vercodes[appid]:
 362                 if v not in allvcs:
 363                     logging.critical("No such vercode %s for app %s" % (v, appid))
 364
 365     if error:
 366         raise FDroidException("Found invalid vercodes for some apps")
 367
 368     return apps
 369
 370
 371 def get_extension(filename):
 372     base, ext = os.path.splitext(filename)
 373     if not ext:
 374         return base, ''
 375     return base, ext.lower()[1:]
 376
 377
 378 def has_extension(filename, ext):
 379     _, f_ext = get_extension(filename)
 380     return ext == f_ext
 381
 382
 383 apk_regex = None
 384
 385
 386 def clean_description(description):
 387     'Remove unneeded newlines and spaces from a block of description text'
 388     returnstring = ''
 389     # this is split up by paragraph to make removing the newlines easier
 390     for paragraph in re.split(r'\n\n', description):
 391         paragraph = re.sub('\r', '', paragraph)
 392         paragraph = re.sub('\n', ' ', paragraph)
 393         paragraph = re.sub(' {2,}', ' ', paragraph)
 394         paragraph = re.sub('^\s*(\w)', r'\1', paragraph)
 395         returnstring += paragraph + '\n\n'
 396     return returnstring.rstrip('\n')
 397
 398
 399 def apknameinfo(filename):
 400     global apk_regex
 401     filename = os.path.basename(filename)
 402     if apk_regex is None:
 403         apk_regex = re.compile(r"^(.+)_([0-9]+)\.apk$")
 404     m = apk_regex.match(filename)
 405     try:
 406         result = (m.group(1), m.group(2))
 407     except AttributeError:
 408         raise FDroidException("Invalid apk name: %s" % filename)
 409     return result
 410
 411
 412 def getapkname(app, build):
 413     return "%s_%s.apk" % (app['id'], build['vercode'])
 414
 415
 416 def getsrcname(app, build):
 417     return "%s_%s_src.tar.gz" % (app['id'], build['vercode'])
 418
 419
 420 def getappname(app):
 421     if app['Name']:
 422         return app['Name']
 423     if app['Auto Name']:
 424         return app['Auto Name']
 425     return app['id']
 426
 427
 428 def getcvname(app):
 429     return '%s (%s)' % (app['Current Version'], app['Current Version Code'])
 430
 431
 432 def getvcs(vcstype, remote, local):
 433     if vcstype == 'git':
 434         return vcs_git(remote, local)
 435     if vcstype == 'git-svn':
 436         return vcs_gitsvn(remote, local)
 437     if vcstype == 'hg':
 438         return vcs_hg(remote, local)
 439     if vcstype == 'bzr':
 440         return vcs_bzr(remote, local)
 441     if vcstype == 'srclib':
 442         if local != os.path.join('build', 'srclib', remote):
 443             raise VCSException("Error: srclib paths are hard-coded!")
 444         return getsrclib(remote, os.path.join('build', 'srclib'), raw=True)
 445     if vcstype == 'svn':
 446         raise VCSException("Deprecated vcs type 'svn' - please use 'git-svn' instead")
 447     raise VCSException("Invalid vcs type " + vcstype)
 448
 449
 450 def getsrclibvcs(name):
 451     if name not in metadata.srclibs:
 452         raise VCSException("Missing srclib " + name)
 453     return metadata.srclibs[name]['Repo Type']
 454
 455
 456 class vcs:
 457
 458     def __init__(self, remote, local):
 459
 460         # svn, git-svn and bzr may require auth
 461         self.username = None
 462         if self.repotype() in ('git-svn', 'bzr'):
 463             if '@' in remote:
 464                 if self.repotype == 'git-svn':
 465                     raise VCSException("Authentication is not supported for git-svn")
 466                 self.username, remote = remote.split('@')
 467                 if ':' not in self.username:
 468                     raise VCSException("Password required with username")
 469                 self.username, self.password = self.username.split(':')
 470
 471         self.remote = remote
 472         self.local = local
 473         self.clone_failed = False
 474         self.refreshed = False
 475         self.srclib = None
 476
 477     def repotype(self):
 478         return None
 479
 480     # Take the local repository to a clean version of the given revision, which
 481     # is specificed in the VCS's native format. Beforehand, the repository can
 482     # be dirty, or even non-existent. If the repository does already exist
 483     # locally, it will be updated from the origin, but only once in the
 484     # lifetime of the vcs object.
 485     # None is acceptable for 'rev' if you know you are cloning a clean copy of
 486     # the repo - otherwise it must specify a valid revision.
 487     def gotorevision(self, rev, refresh=True):
 488
 489         if self.clone_failed:
 490             raise VCSException("Downloading the repository already failed once, not trying again.")
 491
 492         # The .fdroidvcs-id file for a repo tells us what VCS type
 493         # and remote that directory was created from, allowing us to drop it
 494         # automatically if either of those things changes.
 495         fdpath = os.path.join(self.local, '..',
 496                               '.fdroidvcs-' + os.path.basename(self.local))
 497         cdata = self.repotype() + ' ' + self.remote
 498         writeback = True
 499         deleterepo = False
 500         if os.path.exists(self.local):
 501             if os.path.exists(fdpath):
 502                 with open(fdpath, 'r') as f:
 503                     fsdata = f.read().strip()
 504                 if fsdata == cdata:
 505                     writeback = False
 506                 else:
 507                     deleterepo = True
 508                     logging.info("Repository details for %s changed - deleting" % (
 509                         self.local))
 510             else:
 511                 deleterepo = True
 512                 logging.info("Repository details for %s missing - deleting" % (
 513                     self.local))
 514         if deleterepo:
 515             shutil.rmtree(self.local)
 516
 517         exc = None
 518         if not refresh:
 519             self.refreshed = True
 520
 521         try:
 522             self.gotorevisionx(rev)
 523         except FDroidException, e:
 524             exc = e
 525
 526         # If necessary, write the .fdroidvcs file.
 527         if writeback and not self.clone_failed:
 528             with open(fdpath, 'w') as f:
 529                 f.write(cdata)
 530
 531         if exc is not None:
 532             raise exc
 533
 534     # Derived classes need to implement this. It's called once basic checking
 535     # has been performend.
 536     def gotorevisionx(self, rev):
 537         raise VCSException("This VCS type doesn't define gotorevisionx")
 538
 539     # Initialise and update submodules
 540     def initsubmodules(self):
 541         raise VCSException('Submodules not supported for this vcs type')
 542
 543     # Get a list of all known tags
 544     def gettags(self):
 545         if not self._gettags:
 546             raise VCSException('gettags not supported for this vcs type')
 547         rtags = []
 548         for tag in self._gettags():
 549             if re.match('[-A-Za-z0-9_. /]+$', tag):
 550                 rtags.append(tag)
 551         return rtags
 552
 553     def latesttags(self, tags, number):
 554         """Get the most recent tags in a given list.
 555
 556         :param tags: a list of tags
 557         :param number: the number to return
 558         :returns: A list containing the most recent tags in the provided
 559                   list, up to the maximum number given.
 560         """
 561         raise VCSException('latesttags not supported for this vcs type')
 562
 563     # Get current commit reference (hash, revision, etc)
 564     def getref(self):
 565         raise VCSException('getref not supported for this vcs type')
 566
 567     # Returns the srclib (name, path) used in setting up the current
 568     # revision, or None.
 569     def getsrclib(self):
 570         return self.srclib
 571
 572
 573 class vcs_git(vcs):
 574
 575     def repotype(self):
 576         return 'git'
 577
 578     # If the local directory exists, but is somehow not a git repository, git
 579     # will traverse up the directory tree until it finds one that is (i.e.
 580     # fdroidserver) and then we'll proceed to destroy it! This is called as
 581     # a safety check.
 582     def checkrepo(self):
 583         p = FDroidPopen(['git', 'rev-parse', '--show-toplevel'], cwd=self.local, output=False)
 584         result = p.output.rstrip()
 585         if not result.endswith(self.local):
 586             raise VCSException('Repository mismatch')
 587
 588     def gotorevisionx(self, rev):
 589         if not os.path.exists(self.local):
 590             # Brand new checkout
 591             p = FDroidPopen(['git', 'clone', self.remote, self.local])
 592             if p.returncode != 0:
 593                 self.clone_failed = True
 594                 raise VCSException("Git clone failed", p.output)
 595             self.checkrepo()
 596         else:
 597             self.checkrepo()
 598             # Discard any working tree changes
 599             p = FDroidPopen(['git', 'submodule', 'foreach', '--recursive',
 600                              'git', 'reset', '--hard'], cwd=self.local, output=False)
 601             if p.returncode != 0:
 602                 raise VCSException("Git reset failed", p.output)
 603             # Remove untracked files now, in case they're tracked in the target
 604             # revision (it happens!)
 605             p = FDroidPopen(['git', 'submodule', 'foreach', '--recursive',
 606                              'git', 'clean', '-dffx'], cwd=self.local, output=False)
 607             if p.returncode != 0:
 608                 raise VCSException("Git clean failed", p.output)
 609             if not self.refreshed:
 610                 # Get latest commits and tags from remote
 611                 p = FDroidPopen(['git', 'fetch', 'origin'], cwd=self.local)
 612                 if p.returncode != 0:
 613                     raise VCSException("Git fetch failed", p.output)
 614                 p = FDroidPopen(['git', 'fetch', '--prune', '--tags', 'origin'], cwd=self.local, output=False)
 615                 if p.returncode != 0:
 616                     raise VCSException("Git fetch failed", p.output)
 617                 # Recreate origin/HEAD as git clone would do it, in case it disappeared
 618                 p = FDroidPopen(['git', 'remote', 'set-head', 'origin', '--auto'], cwd=self.local, output=False)
 619                 if p.returncode != 0:
 620                     lines = p.output.splitlines()
 621                     if 'Multiple remote HEAD branches' not in lines[0]:
 622                         raise VCSException("Git remote set-head failed", p.output)
 623                     branch = lines[1].split(' ')[-1]
 624                     p2 = FDroidPopen(['git', 'remote', 'set-head', 'origin', branch], cwd=self.local, output=False)
 625                     if p2.returncode != 0:
 626                         raise VCSException("Git remote set-head failed", p.output + '\n' + p2.output)
 627                 self.refreshed = True
 628         # origin/HEAD is the HEAD of the remote, e.g. the "default branch" on
 629         # a github repo. Most of the time this is the same as origin/master.
 630         rev = rev or 'origin/HEAD'
 631         p = FDroidPopen(['git', 'checkout', '-f', rev], cwd=self.local, output=False)
 632         if p.returncode != 0:
 633             raise VCSException("Git checkout of '%s' failed" % rev, p.output)
 634         # Get rid of any uncontrolled files left behind
 635         p = FDroidPopen(['git', 'clean', '-dffx'], cwd=self.local, output=False)
 636         if p.returncode != 0:
 637             raise VCSException("Git clean failed", p.output)
 638
 639     def initsubmodules(self):
 640         self.checkrepo()
 641         submfile = os.path.join(self.local, '.gitmodules')
 642         if not os.path.isfile(submfile):
 643             raise VCSException("No git submodules available")
 644
 645         # fix submodules not accessible without an account and public key auth
 646         with open(submfile, 'r') as f:
 647             lines = f.readlines()
 648         with open(submfile, 'w') as f:
 649             for line in lines:
 650                 if 'git@github.com' in line:
 651                     line = line.replace('git@github.com:', 'https://github.com/')
 652                 if 'git@gitlab.com' in line:
 653                     line = line.replace('git@gitlab.com:', 'https://gitlab.com/')
 654                 f.write(line)
 655
 656         p = FDroidPopen(['git', 'submodule', 'sync'], cwd=self.local, output=False)
 657         if p.returncode != 0:
 658             raise VCSException("Git submodule sync failed", p.output)
 659         p = FDroidPopen(['git', 'submodule', 'update', '--init', '--force', '--recursive'], cwd=self.local)
 660         if p.returncode != 0:
 661             raise VCSException("Git submodule update failed", p.output)
 662
 663     def _gettags(self):
 664         self.checkrepo()
 665         p = FDroidPopen(['git', 'tag'], cwd=self.local, output=False)
 666         return p.output.splitlines()
 667
 668     def latesttags(self, tags, number):
 669         self.checkrepo()
 670         tl = []
 671         for tag in tags:
 672             p = FDroidPopen(
 673                 ['git', 'show', '--format=format:%ct', '-s', tag],
 674                 cwd=self.local, output=False)
 675             # Timestamp is on the last line. For a normal tag, it's the only
 676             # line, but for annotated tags, the rest of the info precedes it.
 677             ts = int(p.output.splitlines()[-1])
 678             tl.append((ts, tag))
 679         latest = []
 680         for _, t in sorted(tl)[-number:]:
 681             latest.append(t)
 682         return latest
 683
 684
 685 class vcs_gitsvn(vcs):
 686
 687     def repotype(self):
 688         return 'git-svn'
 689
 690     # If the local directory exists, but is somehow not a git repository, git
 691     # will traverse up the directory tree until it finds one that is (i.e.
 692     # fdroidserver) and then we'll proceed to destory it! This is called as
 693     # a safety check.
 694     def checkrepo(self):
 695         p = FDroidPopen(['git', 'rev-parse', '--show-toplevel'], cwd=self.local, output=False)
 696         result = p.output.rstrip()
 697         if not result.endswith(self.local):
 698             raise VCSException('Repository mismatch')
 699
 700     def gotorevisionx(self, rev):
 701         if not os.path.exists(self.local):
 702             # Brand new checkout
 703             gitsvn_args = ['git', 'svn', 'clone']
 704             if ';' in self.remote:
 705                 remote_split = self.remote.split(';')
 706                 for i in remote_split[1:]:
 707                     if i.startswith('trunk='):
 708                         gitsvn_args.extend(['-T', i[6:]])
 709                     elif i.startswith('tags='):
 710                         gitsvn_args.extend(['-t', i[5:]])
 711                     elif i.startswith('branches='):
 712                         gitsvn_args.extend(['-b', i[9:]])
 713                 gitsvn_args.extend([remote_split[0], self.local])
 714                 p = FDroidPopen(gitsvn_args, output=False)
 715                 if p.returncode != 0:
 716                     self.clone_failed = True
 717                     raise VCSException("Git svn clone failed", p.output)
 718             else:
 719                 gitsvn_args.extend([self.remote, self.local])
 720                 p = FDroidPopen(gitsvn_args, output=False)
 721                 if p.returncode != 0:
 722                     self.clone_failed = True
 723                     raise VCSException("Git svn clone failed", p.output)
 724             self.checkrepo()
 725         else:
 726             self.checkrepo()
 727             # Discard any working tree changes
 728             p = FDroidPopen(['git', 'reset', '--hard'], cwd=self.local, output=False)
 729             if p.returncode != 0:
 730                 raise VCSException("Git reset failed", p.output)
 731             # Remove untracked files now, in case they're tracked in the target
 732             # revision (it happens!)
 733             p = FDroidPopen(['git', 'clean', '-dffx'], cwd=self.local, output=False)
 734             if p.returncode != 0:
 735                 raise VCSException("Git clean failed", p.output)
 736             if not self.refreshed:
 737                 # Get new commits, branches and tags from repo
 738                 p = FDroidPopen(['git', 'svn', 'fetch'], cwd=self.local, output=False)
 739                 if p.returncode != 0:
 740                     raise VCSException("Git svn fetch failed")
 741                 p = FDroidPopen(['git', 'svn', 'rebase'], cwd=self.local, output=False)
 742                 if p.returncode != 0:
 743                     raise VCSException("Git svn rebase failed", p.output)
 744                 self.refreshed = True
 745
 746         rev = rev or 'master'
 747         if rev:
 748             nospaces_rev = rev.replace(' ', '%20')
 749             # Try finding a svn tag
 750             for treeish in ['origin/', '']:
 751                 p = FDroidPopen(['git', 'checkout', treeish + 'tags/' + nospaces_rev], cwd=self.local, output=False)
 752                 if p.returncode == 0:
 753                     break
 754             if p.returncode != 0:
 755                 # No tag found, normal svn rev translation
 756                 # Translate svn rev into git format
 757                 rev_split = rev.split('/')
 758
 759                 p = None
 760                 for treeish in ['origin/', '']:
 761                     if len(rev_split) > 1:
 762                         treeish += rev_split[0]
 763                         svn_rev = rev_split[1]
 764
 765                     else:
 766                         # if no branch is specified, then assume trunk (i.e. 'master' branch):
 767                         treeish += 'master'
 768                         svn_rev = rev
 769
 770                     svn_rev = svn_rev if svn_rev[0] == 'r' else 'r' + svn_rev
 771
 772                     p = FDroidPopen(['git', 'svn', 'find-rev', '--before', svn_rev, treeish], cwd=self.local, output=False)
 773                     git_rev = p.output.rstrip()
 774
 775                     if p.returncode == 0 and git_rev:
 776                         break
 777
 778                 if p.returncode != 0 or not git_rev:
 779                     # Try a plain git checkout as a last resort
 780                     p = FDroidPopen(['git', 'checkout', rev], cwd=self.local, output=False)
 781                     if p.returncode != 0:
 782                         raise VCSException("No git treeish found and direct git checkout of '%s' failed" % rev, p.output)
 783                 else:
 784                     # Check out the git rev equivalent to the svn rev
 785                     p = FDroidPopen(['git', 'checkout', git_rev], cwd=self.local, output=False)
 786                     if p.returncode != 0:
 787                         raise VCSException("Git checkout of '%s' failed" % rev, p.output)
 788
 789         # Get rid of any uncontrolled files left behind
 790         p = FDroidPopen(['git', 'clean', '-dffx'], cwd=self.local, output=False)
 791         if p.returncode != 0:
 792             raise VCSException("Git clean failed", p.output)
 793
 794     def _gettags(self):
 795         self.checkrepo()
 796         for treeish in ['origin/', '']:
 797             d = os.path.join(self.local, '.git', 'svn', 'refs', 'remotes', treeish, 'tags')
 798             if os.path.isdir(d):
 799                 return os.listdir(d)
 800
 801     def getref(self):
 802         self.checkrepo()
 803         p = FDroidPopen(['git', 'svn', 'find-rev', 'HEAD'], cwd=self.local, output=False)
 804         if p.returncode != 0:
 805             return None
 806         return p.output.strip()
 807
 808
 809 class vcs_hg(vcs):
 810
 811     def repotype(self):
 812         return 'hg'
 813
 814     def gotorevisionx(self, rev):
 815         if not os.path.exists(self.local):
 816             p = FDroidPopen(['hg', 'clone', self.remote, self.local], output=False)
 817             if p.returncode != 0:
 818                 self.clone_failed = True
 819                 raise VCSException("Hg clone failed", p.output)
 820         else:
 821             p = FDroidPopen(['hg', 'status', '-uS'], cwd=self.local, output=False)
 822             if p.returncode != 0:
 823                 raise VCSException("Hg status failed", p.output)
 824             for line in p.output.splitlines():
 825                 if not line.startswith('? '):
 826                     raise VCSException("Unexpected output from hg status -uS: " + line)
 827                 FDroidPopen(['rm', '-rf', line[2:]], cwd=self.local, output=False)
 828             if not self.refreshed:
 829                 p = FDroidPopen(['hg', 'pull'], cwd=self.local, output=False)
 830                 if p.returncode != 0:
 831                     raise VCSException("Hg pull failed", p.output)
 832                 self.refreshed = True
 833
 834         rev = rev or 'default'
 835         if not rev:
 836             return
 837         p = FDroidPopen(['hg', 'update', '-C', rev], cwd=self.local, output=False)
 838         if p.returncode != 0:
 839             raise VCSException("Hg checkout of '%s' failed" % rev, p.output)
 840         p = FDroidPopen(['hg', 'purge', '--all'], cwd=self.local, output=False)
 841         # Also delete untracked files, we have to enable purge extension for that:
 842         if "'purge' is provided by the following extension" in p.output:
 843             with open(os.path.join(self.local, '.hg', 'hgrc'), "a") as myfile:
 844                 myfile.write("\n[extensions]\nhgext.purge=\n")
 845             p = FDroidPopen(['hg', 'purge', '--all'], cwd=self.local, output=False)
 846             if p.returncode != 0:
 847                 raise VCSException("HG purge failed", p.output)
 848         elif p.returncode != 0:
 849             raise VCSException("HG purge failed", p.output)
 850
 851     def _gettags(self):
 852         p = FDroidPopen(['hg', 'tags', '-q'], cwd=self.local, output=False)
 853         return p.output.splitlines()[1:]
 854
 855
 856 class vcs_bzr(vcs):
 857
 858     def repotype(self):
 859         return 'bzr'
 860
 861     def gotorevisionx(self, rev):
 862         if not os.path.exists(self.local):
 863             p = FDroidPopen(['bzr', 'branch', self.remote, self.local], output=False)
 864             if p.returncode != 0:
 865                 self.clone_failed = True
 866                 raise VCSException("Bzr branch failed", p.output)
 867         else:
 868             p = FDroidPopen(['bzr', 'clean-tree', '--force', '--unknown', '--ignored'], cwd=self.local, output=False)
 869             if p.returncode != 0:
 870                 raise VCSException("Bzr revert failed", p.output)
 871             if not self.refreshed:
 872                 p = FDroidPopen(['bzr', 'pull'], cwd=self.local, output=False)
 873                 if p.returncode != 0:
 874                     raise VCSException("Bzr update failed", p.output)
 875                 self.refreshed = True
 876
 877         revargs = list(['-r', rev] if rev else [])
 878         p = FDroidPopen(['bzr', 'revert'] + revargs, cwd=self.local, output=False)
 879         if p.returncode != 0:
 880             raise VCSException("Bzr revert of '%s' failed" % rev, p.output)
 881
 882     def _gettags(self):
 883         p = FDroidPopen(['bzr', 'tags'], cwd=self.local, output=False)
 884         return [tag.split('   ')[0].strip() for tag in
 885                 p.output.splitlines()]
 886
 887
 888 def unescape_string(string):
 889     if len(string) < 2:
 890         return string
 891     if string[0] == '"' and string[-1] == '"':
 892         return string[1:-1]
 893
 894     return string.replace("\\'", "'")
 895
 896
 897 def retrieve_string(app_dir, string, xmlfiles=None):
 898
 899     if not string.startswith('@string/'):
 900         return unescape_string(string)
 901
 902     if xmlfiles is None:
 903         xmlfiles = []
 904         for res_dir in [
 905             os.path.join(app_dir, 'res'),
 906             os.path.join(app_dir, 'src', 'main', 'res'),
 907         ]:
 908             for r, d, f in os.walk(res_dir):
 909                 if os.path.basename(r) == 'values':
 910                     xmlfiles += [os.path.join(r, x) for x in f if x.endswith('.xml')]
 911
 912     name = string[len('@string/'):]
 913
 914     def element_content(element):
 915         if element.text is None:
 916             return ""
 917         s = XMLElementTree.tostring(element, encoding='utf-8', method='text')
 918         return s.strip()
 919
 920     for path in xmlfiles:
 921         if not os.path.isfile(path):
 922             continue
 923         xml = parse_xml(path)
 924         element = xml.find('string[@name="' + name + '"]')
 925         if element is not None:
 926             content = element_content(element)
 927             return retrieve_string(app_dir, content, xmlfiles)
 928
 929     return ''
 930
 931
 932 def retrieve_string_singleline(app_dir, string, xmlfiles=None):
 933     return retrieve_string(app_dir, string, xmlfiles).replace('\n', ' ').strip()
 934
 935
 936 # Return list of existing files that will be used to find the highest vercode
 937 def manifest_paths(app_dir, flavours):
 938
 939     possible_manifests = \
 940         [os.path.join(app_dir, 'AndroidManifest.xml'),
 941          os.path.join(app_dir, 'src', 'main', 'AndroidManifest.xml'),
 942          os.path.join(app_dir, 'src', 'AndroidManifest.xml'),
 943          os.path.join(app_dir, 'build.gradle')]
 944
 945     for flavour in flavours:
 946         if flavour == 'yes':
 947             continue
 948         possible_manifests.append(
 949             os.path.join(app_dir, 'src', flavour, 'AndroidManifest.xml'))
 950
 951     return [path for path in possible_manifests if os.path.isfile(path)]
 952
 953
 954 # Retrieve the package name. Returns the name, or None if not found.
 955 def fetch_real_name(app_dir, flavours):
 956     for path in manifest_paths(app_dir, flavours):
 957         if not has_extension(path, 'xml') or not os.path.isfile(path):
 958             continue
 959         logging.debug("fetch_real_name: Checking manifest at " + path)
 960         xml = parse_xml(path)
 961         app = xml.find('application')
 962         if "{http://schemas.android.com/apk/res/android}label" not in app.attrib:
 963             continue
 964         label = app.attrib["{http://schemas.android.com/apk/res/android}label"].encode('utf-8')
 965         result = retrieve_string_singleline(app_dir, label)
 966         if result:
 967             result = result.strip()
 968         return result
 969     return None
 970
 971
 972 def get_library_references(root_dir):
 973     libraries = []
 974     proppath = os.path.join(root_dir, 'project.properties')
 975     if not os.path.isfile(proppath):
 976         return libraries
 977     for line in file(proppath):
 978         if not line.startswith('android.library.reference.'):
 979             continue
 980         path = line.split('=')[1].strip()
 981         relpath = os.path.join(root_dir, path)
 982         if not os.path.isdir(relpath):
 983             continue
 984         logging.debug("Found subproject at %s" % path)
 985         libraries.append(path)
 986     return libraries
 987
 988
 989 def ant_subprojects(root_dir):
 990     subprojects = get_library_references(root_dir)
 991     for subpath in subprojects:
 992         subrelpath = os.path.join(root_dir, subpath)
 993         for p in get_library_references(subrelpath):
 994             relp = os.path.normpath(os.path.join(subpath, p))
 995             if relp not in subprojects:
 996                 subprojects.insert(0, relp)
 997     return subprojects
 998
 999
1000 def remove_debuggable_flags(root_dir):
1001     # Remove forced debuggable flags
1002     logging.debug("Removing debuggable flags from %s" % root_dir)
1003     for root, dirs, files in os.walk(root_dir):
1004         if 'AndroidManifest.xml' in files:
1005             regsub_file(r'android:debuggable="[^"]*"',
1006                         '',
1007                         os.path.join(root, 'AndroidManifest.xml'))
1008
1009
1010 vcsearch_g = re.compile(r'.*versionCode *=* *["\']*([0-9]+)["\']*').search
1011 vnsearch_g = re.compile(r'.*versionName *=* *(["\'])((?:(?=(\\?))\3.)*?)\1.*').search
1012 psearch_g = re.compile(r'.*(packageName|applicationId) *=* *["\']([^"]+)["\'].*').search
1013
1014
1015 # Extract some information from the AndroidManifest.xml at the given path.
1016 # Returns (version, vercode, package), any or all of which might be None.
1017 # All values returned are strings.
1018 def parse_androidmanifests(paths, ignoreversions=None):
1019
1020     ignoresearch = re.compile(ignoreversions).search if ignoreversions else None
1021
1022     if not paths:
1023         return (None, None, None)
1024
1025     max_version = None
1026     max_vercode = None
1027     max_package = None
1028
1029     for path in paths:
1030
1031         if not os.path.isfile(path):
1032             continue
1033
1034         logging.debug("Parsing manifest at {0}".format(path))
1035         gradle = has_extension(path, 'gradle')
1036         version = None
1037         vercode = None
1038         package = None
1039
1040         if gradle:
1041             for line in file(path):
1042                 if gradle_comment.match(line):
1043                     continue
1044                 # Grab first occurence of each to avoid running into
1045                 # alternative flavours and builds.
1046                 if not package:
1047                     matches = psearch_g(line)
1048                     if matches:
1049                         package = matches.group(2)
1050                 if not version:
1051                     matches = vnsearch_g(line)
1052                     if matches:
1053                         version = matches.group(2)
1054                 if not vercode:
1055                     matches = vcsearch_g(line)
1056                     if matches:
1057                         vercode = matches.group(1)
1058         else:
1059             xml = parse_xml(path)
1060             if "package" in xml.attrib:
1061                 package = xml.attrib["package"].encode('utf-8')
1062             if "{http://schemas.android.com/apk/res/android}versionName" in xml.attrib:
1063                 version = xml.attrib["{http://schemas.android.com/apk/res/android}versionName"].encode('utf-8')
1064                 base_dir = os.path.dirname(path)
1065                 version = retrieve_string_singleline(base_dir, version)
1066             if "{http://schemas.android.com/apk/res/android}versionCode" in xml.attrib:
1067                 a = xml.attrib["{http://schemas.android.com/apk/res/android}versionCode"].encode('utf-8')
1068                 if string_is_integer(a):
1069                     vercode = a
1070
1071         # Remember package name, may be defined separately from version+vercode
1072         if package is None:
1073             package = max_package
1074
1075         logging.debug("..got package={0}, version={1}, vercode={2}"
1076                       .format(package, version, vercode))
1077
1078         # Always grab the package name and version name in case they are not
1079         # together with the highest version code
1080         if max_package is None and package is not None:
1081             max_package = package
1082         if max_version is None and version is not None:
1083             max_version = version
1084
1085         if max_vercode is None or (vercode is not None and vercode > max_vercode):
1086             if not ignoresearch or not ignoresearch(version):
1087                 if version is not None:
1088                     max_version = version
1089                 if vercode is not None:
1090                     max_vercode = vercode
1091                 if package is not None:
1092                     max_package = package
1093             else:
1094                 max_version = "Ignore"
1095
1096     if max_version is None:
1097         max_version = "Unknown"
1098
1099     if max_package and not is_valid_package_name(max_package):
1100         raise FDroidException("Invalid package name {0}".format(max_package))
1101
1102     return (max_version, max_vercode, max_package)
1103
1104
1105 def is_valid_package_name(name):
1106     return re.match("[A-Za-z_][A-Za-z_0-9.]+$", name)
1107
1108
1109 class FDroidException(Exception):
1110
1111     def __init__(self, value, detail=None):
1112         self.value = value
1113         self.detail = detail
1114
1115     def shortened_detail(self):
1116         if len(self.detail) < 16000:
1117             return self.detail
1118         return '[...]\n' + self.detail[-16000:]
1119
1120     def get_wikitext(self):
1121         ret = repr(self.value) + "\n"
1122         if self.detail:
1123             ret += "=detail=\n"
1124             ret += "<pre>\n" + self.shortened_detail() + "</pre>\n"
1125         return ret
1126
1127     def __str__(self):
1128         ret = self.value
1129         if self.detail:
1130             ret += "\n==== detail begin ====\n%s\n==== detail end ====" % self.detail.strip()
1131         return ret
1132
1133
1134 class VCSException(FDroidException):
1135     pass
1136
1137
1138 class BuildException(FDroidException):
1139     pass
1140
1141
1142 # Get the specified source library.
1143 # Returns the path to it. Normally this is the path to be used when referencing
1144 # it, which may be a subdirectory of the actual project. If you want the base
1145 # directory of the project, pass 'basepath=True'.
1146 def getsrclib(spec, srclib_dir, subdir=None, basepath=False,
1147               raw=False, prepare=True, preponly=False, refresh=True):
1148
1149     number = None
1150     subdir = None
1151     if raw:
1152         name = spec
1153         ref = None
1154     else:
1155         name, ref = spec.split('@')
1156         if ':' in name:
1157             number, name = name.split(':', 1)
1158         if '/' in name:
1159             name, subdir = name.split('/', 1)
1160
1161     if name not in metadata.srclibs:
1162         raise VCSException('srclib ' + name + ' not found.')
1163
1164     srclib = metadata.srclibs[name]
1165
1166     sdir = os.path.join(srclib_dir, name)
1167
1168     if not preponly:
1169         vcs = getvcs(srclib["Repo Type"], srclib["Repo"], sdir)
1170         vcs.srclib = (name, number, sdir)
1171         if ref:
1172             vcs.gotorevision(ref, refresh)
1173
1174         if raw:
1175             return vcs
1176
1177     libdir = None
1178     if subdir:
1179         libdir = os.path.join(sdir, subdir)
1180     elif srclib["Subdir"]:
1181         for subdir in srclib["Subdir"]:
1182             libdir_candidate = os.path.join(sdir, subdir)
1183             if os.path.exists(libdir_candidate):
1184                 libdir = libdir_candidate
1185                 break
1186
1187     if libdir is None:
1188         libdir = sdir
1189
1190     remove_signing_keys(sdir)
1191     remove_debuggable_flags(sdir)
1192
1193     if prepare:
1194
1195         if srclib["Prepare"]:
1196             cmd = replace_config_vars(srclib["Prepare"], None)
1197
1198             p = FDroidPopen(['bash', '-x', '-c', cmd], cwd=libdir)
1199             if p.returncode != 0:
1200                 raise BuildException("Error running prepare command for srclib %s"
1201                                      % name, p.output)
1202
1203     if basepath:
1204         libdir = sdir
1205
1206     return (name, number, libdir)
1207
1208 gradle_version_regex = re.compile(r"[^/]*'com\.android\.tools\.build:gradle:([^\.]+\.[^\.]+).*'.*")
1209
1210
1211 # Prepare the source code for a particular build
1212 #  'vcs'         - the appropriate vcs object for the application
1213 #  'app'         - the application details from the metadata
1214 #  'build'       - the build details from the metadata
1215 #  'build_dir'   - the path to the build directory, usually
1216 #                   'build/app.id'
1217 #  'srclib_dir'  - the path to the source libraries directory, usually
1218 #                   'build/srclib'
1219 #  'extlib_dir'  - the path to the external libraries directory, usually
1220 #                   'build/extlib'
1221 # Returns the (root, srclibpaths) where:
1222 #   'root' is the root directory, which may be the same as 'build_dir' or may
1223 #          be a subdirectory of it.
1224 #   'srclibpaths' is information on the srclibs being used
1225 def prepare_source(vcs, app, build, build_dir, srclib_dir, extlib_dir, onserver=False, refresh=True):
1226
1227     # Optionally, the actual app source can be in a subdirectory
1228     if build['subdir']:
1229         root_dir = os.path.join(build_dir, build['subdir'])
1230     else:
1231         root_dir = build_dir
1232
1233     # Get a working copy of the right revision
1234     logging.info("Getting source for revision " + build['commit'])
1235     vcs.gotorevision(build['commit'], refresh)
1236
1237     # Initialise submodules if required
1238     if build['submodules']:
1239         logging.info("Initialising submodules")
1240         vcs.initsubmodules()
1241
1242     # Check that a subdir (if we're using one) exists. This has to happen
1243     # after the checkout, since it might not exist elsewhere
1244     if not os.path.exists(root_dir):
1245         raise BuildException('Missing subdir ' + root_dir)
1246
1247     # Run an init command if one is required
1248     if build['init']:
1249         cmd = replace_config_vars(build['init'], build)
1250         logging.info("Running 'init' commands in %s" % root_dir)
1251
1252         p = FDroidPopen(['bash', '-x', '-c', cmd], cwd=root_dir)
1253         if p.returncode != 0:
1254             raise BuildException("Error running init command for %s:%s" %
1255                                  (app['id'], build['version']), p.output)
1256
1257     # Apply patches if any
1258     if build['patch']:
1259         logging.info("Applying patches")
1260         for patch in build['patch']:
1261             patch = patch.strip()
1262             logging.info("Applying " + patch)
1263             patch_path = os.path.join('metadata', app['id'], patch)
1264             p = FDroidPopen(['patch', '-p1', '-i', os.path.abspath(patch_path)], cwd=build_dir)
1265             if p.returncode != 0:
1266                 raise BuildException("Failed to apply patch %s" % patch_path)
1267
1268     # Get required source libraries
1269     srclibpaths = []
1270     if build['srclibs']:
1271         logging.info("Collecting source libraries")
1272         for lib in build['srclibs']:
1273             srclibpaths.append(getsrclib(lib, srclib_dir, build, preponly=onserver, refresh=refresh))
1274
1275     for name, number, libpath in srclibpaths:
1276         place_srclib(root_dir, int(number) if number else None, libpath)
1277
1278     basesrclib = vcs.getsrclib()
1279     # If one was used for the main source, add that too.
1280     if basesrclib:
1281         srclibpaths.append(basesrclib)
1282
1283     # Update the local.properties file
1284     localprops = [os.path.join(build_dir, 'local.properties')]
1285     if build['subdir']:
1286         parts = build['subdir'].split(os.sep)
1287         cur = build_dir
1288         for d in parts:
1289             cur = os.path.join(cur, d)
1290             localprops += [os.path.join(cur, 'local.properties')]
1291     for path in localprops:
1292         props = ""
1293         if os.path.isfile(path):
1294             logging.info("Updating local.properties file at %s" % path)
1295             with open(path, 'r') as f:
1296                 props += f.read()
1297             props += '\n'
1298         else:
1299             logging.info("Creating local.properties file at %s" % path)
1300         # Fix old-fashioned 'sdk-location' by copying
1301         # from sdk.dir, if necessary
1302         if build['oldsdkloc']:
1303             sdkloc = re.match(r".*^sdk.dir=(\S+)$.*", props,
1304                               re.S | re.M).group(1)
1305             props += "sdk-location=%s\n" % sdkloc
1306         else:
1307             props += "sdk.dir=%s\n" % config['sdk_path']
1308             props += "sdk-location=%s\n" % config['sdk_path']
1309         if build['ndk_path']:
1310             # Add ndk location
1311             props += "ndk.dir=%s\n" % build['ndk_path']
1312             props += "ndk-location=%s\n" % build['ndk_path']
1313         # Add java.encoding if necessary
1314         if build['encoding']:
1315             props += "java.encoding=%s\n" % build['encoding']
1316         with open(path, 'w') as f:
1317             f.write(props)
1318
1319     flavours = []
1320     if build['type'] == 'gradle':
1321         flavours = build['gradle']
1322
1323         gradlepluginver = None
1324
1325         gradle_dirs = [root_dir]
1326
1327         # Parent dir build.gradle
1328         parent_dir = os.path.normpath(os.path.join(root_dir, '..'))
1329         if parent_dir.startswith(build_dir):
1330             gradle_dirs.append(parent_dir)
1331
1332         for dir_path in gradle_dirs:
1333             if gradlepluginver:
1334                 break
1335             if not os.path.isdir(dir_path):
1336                 continue
1337             for filename in os.listdir(dir_path):
1338                 if not filename.endswith('.gradle'):
1339                     continue
1340                 path = os.path.join(dir_path, filename)
1341                 if not os.path.isfile(path):
1342                     continue
1343                 for line in file(path):
1344                     match = gradle_version_regex.match(line)
1345                     if match:
1346                         gradlepluginver = match.group(1)
1347                         break
1348
1349         if gradlepluginver:
1350             build['gradlepluginver'] = LooseVersion(gradlepluginver)
1351         else:
1352             logging.warn("Could not fetch the gradle plugin version, defaulting to 0.11")
1353             build['gradlepluginver'] = LooseVersion('0.11')
1354
1355         if build['target']:
1356             n = build["target"].split('-')[1]
1357             regsub_file(r'compileSdkVersion[ =]+[0-9]+',
1358                         r'compileSdkVersion %s' % n,
1359                         os.path.join(root_dir, 'build.gradle'))
1360
1361     # Remove forced debuggable flags
1362     remove_debuggable_flags(root_dir)
1363
1364     # Insert version code and number into the manifest if necessary
1365     if build['forceversion']:
1366         logging.info("Changing the version name")
1367         for path in manifest_paths(root_dir, flavours):
1368             if not os.path.isfile(path):
1369                 continue
1370             if has_extension(path, 'xml'):
1371                 regsub_file(r'android:versionName="[^"]*"',
1372                             r'android:versionName="%s"' % build['version'],
1373                             path)
1374             elif has_extension(path, 'gradle'):
1375                 regsub_file(r"""(\s*)versionName[\s'"=]+.*""",
1376                             r"""\1versionName '%s'""" % build['version'],
1377                             path)
1378
1379     if build['forcevercode']:
1380         logging.info("Changing the version code")
1381         for path in manifest_paths(root_dir, flavours):
1382             if not os.path.isfile(path):
1383                 continue
1384             if has_extension(path, 'xml'):
1385                 regsub_file(r'android:versionCode="[^"]*"',
1386                             r'android:versionCode="%s"' % build['vercode'],
1387                             path)
1388             elif has_extension(path, 'gradle'):
1389                 regsub_file(r'versionCode[ =]+[0-9]+',
1390                             r'versionCode %s' % build['vercode'],
1391                             path)
1392
1393     # Delete unwanted files
1394     if build['rm']:
1395         logging.info("Removing specified files")
1396         for part in getpaths(build_dir, build['rm']):
1397             dest = os.path.join(build_dir, part)
1398             logging.info("Removing {0}".format(part))
1399             if os.path.lexists(dest):
1400                 if os.path.islink(dest):
1401                     FDroidPopen(['unlink', dest], output=False)
1402                 else:
1403                     FDroidPopen(['rm', '-rf', dest], output=False)
1404             else:
1405                 logging.info("...but it didn't exist")
1406
1407     remove_signing_keys(build_dir)
1408
1409     # Add required external libraries
1410     if build['extlibs']:
1411         logging.info("Collecting prebuilt libraries")
1412         libsdir = os.path.join(root_dir, 'libs')
1413         if not os.path.exists(libsdir):
1414             os.mkdir(libsdir)
1415         for lib in build['extlibs']:
1416             lib = lib.strip()
1417             logging.info("...installing extlib {0}".format(lib))
1418             libf = os.path.basename(lib)
1419             libsrc = os.path.join(extlib_dir, lib)
1420             if not os.path.exists(libsrc):
1421                 raise BuildException("Missing extlib file {0}".format(libsrc))
1422             shutil.copyfile(libsrc, os.path.join(libsdir, libf))
1423
1424     # Run a pre-build command if one is required
1425     if build['prebuild']:
1426         logging.info("Running 'prebuild' commands in %s" % root_dir)
1427
1428         cmd = replace_config_vars(build['prebuild'], build)
1429
1430         # Substitute source library paths into prebuild commands
1431         for name, number, libpath in srclibpaths:
1432             libpath = os.path.relpath(libpath, root_dir)
1433             cmd = cmd.replace('$$' + name + '$$', libpath)
1434
1435         p = FDroidPopen(['bash', '-x', '-c', cmd], cwd=root_dir)
1436         if p.returncode != 0:
1437             raise BuildException("Error running prebuild command for %s:%s" %
1438                                  (app['id'], build['version']), p.output)
1439
1440     # Generate (or update) the ant build file, build.xml...
1441     if build['update'] and build['update'] != ['no'] and build['type'] == 'ant':
1442         parms = ['android', 'update', 'lib-project']
1443         lparms = ['android', 'update', 'project']
1444
1445         if build['target']:
1446             parms += ['-t', build['target']]
1447             lparms += ['-t', build['target']]
1448         if build['update'] == ['auto']:
1449             update_dirs = ant_subprojects(root_dir) + ['.']
1450         else:
1451             update_dirs = build['update']
1452
1453         for d in update_dirs:
1454             subdir = os.path.join(root_dir, d)
1455             if d == '.':
1456                 logging.debug("Updating main project")
1457                 cmd = parms + ['-p', d]
1458             else:
1459                 logging.debug("Updating subproject %s" % d)
1460                 cmd = lparms + ['-p', d]
1461             p = SdkToolsPopen(cmd, cwd=root_dir)
1462             # Check to see whether an error was returned without a proper exit
1463             # code (this is the case for the 'no target set or target invalid'
1464             # error)
1465             if p.returncode != 0 or p.output.startswith("Error: "):
1466                 raise BuildException("Failed to update project at %s" % d, p.output)
1467             # Clean update dirs via ant
1468             if d != '.':
1469                 logging.info("Cleaning subproject %s" % d)
1470                 p = FDroidPopen(['ant', 'clean'], cwd=subdir)
1471
1472     return (root_dir, srclibpaths)
1473
1474
1475 # Extend via globbing the paths from a field and return them as a map from
1476 # original path to resulting paths
1477 def getpaths_map(build_dir, globpaths):
1478     paths = dict()
1479     for p in globpaths:
1480         p = p.strip()
1481         full_path = os.path.join(build_dir, p)
1482         full_path = os.path.normpath(full_path)
1483         paths[p] = [r[len(build_dir) + 1:] for r in glob.glob(full_path)]
1484     return paths
1485
1486
1487 # Extend via globbing the paths from a field and return them as a set
1488 def getpaths(build_dir, globpaths):
1489     paths_map = getpaths_map(build_dir, globpaths)
1490     paths = set()
1491     for k, v in paths_map.iteritems():
1492         for p in v:
1493             paths.add(p)
1494     return paths
1495
1496
1497 def natural_key(s):
1498     return [int(sp) if sp.isdigit() else sp for sp in re.split(r'(\d+)', s)]
1499
1500
1501 class KnownApks:
1502
1503     def __init__(self):
1504         self.path = os.path.join('stats', 'known_apks.txt')
1505         self.apks = {}
1506         if os.path.isfile(self.path):
1507             for line in file(self.path):
1508                 t = line.rstrip().split(' ')
1509                 if len(t) == 2:
1510                     self.apks[t[0]] = (t[1], None)
1511                 else:
1512                     self.apks[t[0]] = (t[1], time.strptime(t[2], '%Y-%m-%d'))
1513         self.changed = False
1514
1515     def writeifchanged(self):
1516         if not self.changed:
1517             return
1518
1519         if not os.path.exists('stats'):
1520             os.mkdir('stats')
1521
1522         lst = []
1523         for apk, app in self.apks.iteritems():
1524             appid, added = app
1525             line = apk + ' ' + appid
1526             if added:
1527                 line += ' ' + time.strftime('%Y-%m-%d', added)
1528             lst.append(line)
1529
1530         with open(self.path, 'w') as f:
1531             for line in sorted(lst, key=natural_key):
1532                 f.write(line + '\n')
1533
1534     # Record an apk (if it's new, otherwise does nothing)
1535     # Returns the date it was added.
1536     def recordapk(self, apk, app):
1537         if apk not in self.apks:
1538             self.apks[apk] = (app, time.gmtime(time.time()))
1539             self.changed = True
1540         _, added = self.apks[apk]
1541         return added
1542
1543     # Look up information - given the 'apkname', returns (app id, date added/None).
1544     # Or returns None for an unknown apk.
1545     def getapp(self, apkname):
1546         if apkname in self.apks:
1547             return self.apks[apkname]
1548         return None
1549
1550     # Get the most recent 'num' apps added to the repo, as a list of package ids
1551     # with the most recent first.
1552     def getlatest(self, num):
1553         apps = {}
1554         for apk, app in self.apks.iteritems():
1555             appid, added = app
1556             if added:
1557                 if appid in apps:
1558                     if apps[appid] > added:
1559                         apps[appid] = added
1560                 else:
1561                     apps[appid] = added
1562         sortedapps = sorted(apps.iteritems(), key=operator.itemgetter(1))[-num:]
1563         lst = [app for app, _ in sortedapps]
1564         lst.reverse()
1565         return lst
1566
1567
1568 def isApkDebuggable(apkfile, config):
1569     """Returns True if the given apk file is debuggable
1570
1571     :param apkfile: full path to the apk to check"""
1572
1573     p = SdkToolsPopen(['aapt', 'dump', 'xmltree', apkfile, 'AndroidManifest.xml'],
1574                       output=False)
1575     if p.returncode != 0:
1576         logging.critical("Failed to get apk manifest information")
1577         sys.exit(1)
1578     for line in p.output.splitlines():
1579         if 'android:debuggable' in line and not line.endswith('0x0'):
1580             return True
1581     return False
1582
1583
1584 class PopenResult:
1585     returncode = None
1586     output = ''
1587
1588
1589 def SdkToolsPopen(commands, cwd=None, output=True):
1590     cmd = commands[0]
1591     if cmd not in config:
1592         config[cmd] = find_sdk_tools_cmd(commands[0])
1593     abscmd = config[cmd]
1594     if abscmd is None:
1595         logging.critical("Could not find '%s' on your system" % cmd)
1596         sys.exit(1)
1597     return FDroidPopen([abscmd] + commands[1:],
1598                        cwd=cwd, output=output)
1599
1600
1601 def FDroidPopen(commands, cwd=None, output=True):
1602     """
1603     Run a command and capture the possibly huge output.
1604
1605     :param commands: command and argument list like in subprocess.Popen
1606     :param cwd: optionally specifies a working directory
1607     :returns: A PopenResult.
1608     """
1609
1610     global env
1611
1612     if cwd:
1613         cwd = os.path.normpath(cwd)
1614         logging.debug("Directory: %s" % cwd)
1615     logging.debug("> %s" % ' '.join(commands))
1616
1617     result = PopenResult()
1618     p = None
1619     try:
1620         p = subprocess.Popen(commands, cwd=cwd, shell=False, env=env,
1621                              stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
1622     except OSError, e:
1623         raise BuildException("OSError while trying to execute " +
1624                              ' '.join(commands) + ': ' + str(e))
1625
1626     stdout_queue = Queue.Queue()
1627     stdout_reader = AsynchronousFileReader(p.stdout, stdout_queue)
1628
1629     # Check the queue for output (until there is no more to get)
1630     while not stdout_reader.eof():
1631         while not stdout_queue.empty():
1632             line = stdout_queue.get()
1633             if output and options.verbose:
1634                 # Output directly to console
1635                 sys.stderr.write(line)
1636                 sys.stderr.flush()
1637             result.output += line
1638
1639         time.sleep(0.1)
1640
1641     result.returncode = p.wait()
1642     return result
1643
1644
1645 gradle_comment = re.compile(r'[ ]*//')
1646 gradle_signing_configs = re.compile(r'^[\t ]*signingConfigs[ \t]*{[ \t]*$')
1647 gradle_line_matches = [
1648     re.compile(r'^[\t ]*signingConfig [^ ]*$'),
1649     re.compile(r'.*android\.signingConfigs\.[^{]*$'),
1650     re.compile(r'.*variant\.outputFile = .*'),
1651     re.compile(r'.*output\.outputFile = .*'),
1652     re.compile(r'.*\.readLine\(.*'),
1653 ]
1654
1655
1656 def remove_signing_keys(build_dir):
1657     for root, dirs, files in os.walk(build_dir):
1658         if 'build.gradle' in files:
1659             path = os.path.join(root, 'build.gradle')
1660
1661             with open(path, "r") as o:
1662                 lines = o.readlines()
1663
1664             changed = False
1665
1666             opened = 0
1667             i = 0
1668             with open(path, "w") as o:
1669                 while i < len(lines):
1670                     line = lines[i]
1671                     i += 1
1672                     while line.endswith('\\\n'):
1673                         line = line.rstrip('\\\n') + lines[i]
1674                         i += 1
1675
1676                     if gradle_comment.match(line):
1677                         o.write(line)
1678                         continue
1679
1680                     if opened > 0:
1681                         opened += line.count('{')
1682                         opened -= line.count('}')
1683                         continue
1684
1685                     if gradle_signing_configs.match(line):
1686                         changed = True
1687                         opened += 1
1688                         continue
1689
1690                     if any(s.match(line) for s in gradle_line_matches):
1691                         changed = True
1692                         continue
1693
1694                     if opened == 0:
1695                         o.write(line)
1696
1697             if changed:
1698                 logging.info("Cleaned build.gradle of keysigning configs at %s" % path)
1699
1700         for propfile in [
1701                 'project.properties',
1702                 'build.properties',
1703                 'default.properties',
1704                 'ant.properties', ]:
1705             if propfile in files:
1706                 path = os.path.join(root, propfile)
1707
1708                 with open(path, "r") as o:
1709                     lines = o.readlines()
1710
1711                 changed = False
1712
1713                 with open(path, "w") as o:
1714                     for line in lines:
1715                         if any(line.startswith(s) for s in ('key.store', 'key.alias')):
1716                             changed = True
1717                             continue
1718
1719                         o.write(line)
1720
1721                 if changed:
1722                     logging.info("Cleaned %s of keysigning configs at %s" % (propfile, path))
1723
1724
1725 def reset_env_path():
1726     global env, orig_path
1727     env['PATH'] = orig_path
1728
1729
1730 def add_to_env_path(path):
1731     global env
1732     paths = env['PATH'].split(os.pathsep)
1733     if path in paths:
1734         return
1735     paths.append(path)
1736     env['PATH'] = os.pathsep.join(paths)
1737
1738
1739 def replace_config_vars(cmd, build):
1740     global env
1741     cmd = cmd.replace('$$SDK$$', config['sdk_path'])
1742     # env['ANDROID_NDK'] is set in build_local right before prepare_source
1743     cmd = cmd.replace('$$NDK$$', env['ANDROID_NDK'])
1744     cmd = cmd.replace('$$MVN3$$', config['mvn3'])
1745     if build is not None:
1746         cmd = cmd.replace('$$COMMIT$$', build['commit'])
1747         cmd = cmd.replace('$$VERSION$$', build['version'])
1748         cmd = cmd.replace('$$VERCODE$$', build['vercode'])
1749     return cmd
1750
1751
1752 def place_srclib(root_dir, number, libpath):
1753     if not number:
1754         return
1755     relpath = os.path.relpath(libpath, root_dir)
1756     proppath = os.path.join(root_dir, 'project.properties')
1757
1758     lines = []
1759     if os.path.isfile(proppath):
1760         with open(proppath, "r") as o:
1761             lines = o.readlines()
1762
1763     with open(proppath, "w") as o:
1764         placed = False
1765         for line in lines:
1766             if line.startswith('android.library.reference.%d=' % number):
1767                 o.write('android.library.reference.%d=%s\n' % (number, relpath))
1768                 placed = True
1769             else:
1770                 o.write(line)
1771         if not placed:
1772             o.write('android.library.reference.%d=%s\n' % (number, relpath))
1773
1774 apk_sigfile = re.compile(r'META-INF/[0-9A-Za-z]+\.(SF|RSA)')
1775
1776
1777 def verify_apks(signed_apk, unsigned_apk, tmp_dir):
1778     """Verify that two apks are the same
1779
1780     One of the inputs is signed, the other is unsigned. The signature metadata
1781     is transferred from the signed to the unsigned apk, and then jarsigner is
1782     used to verify that the signature from the signed apk is also varlid for
1783     the unsigned one.
1784     :param signed_apk: Path to a signed apk file
1785     :param unsigned_apk: Path to an unsigned apk file expected to match it
1786     :param tmp_dir: Path to directory for temporary files
1787     :returns: None if the verification is successful, otherwise a string
1788               describing what went wrong.
1789     """
1790     with ZipFile(signed_apk) as signed_apk_as_zip:
1791         meta_inf_files = ['META-INF/MANIFEST.MF']
1792         for f in signed_apk_as_zip.namelist():
1793             if apk_sigfile.match(f):
1794                 meta_inf_files.append(f)
1795         if len(meta_inf_files) < 3:
1796             return "Signature files missing from {0}".format(signed_apk)
1797         signed_apk_as_zip.extractall(tmp_dir, meta_inf_files)
1798     with ZipFile(unsigned_apk, mode='a') as unsigned_apk_as_zip:
1799         for meta_inf_file in meta_inf_files:
1800             unsigned_apk_as_zip.write(os.path.join(tmp_dir, meta_inf_file), arcname=meta_inf_file)
1801
1802     if subprocess.call(['jarsigner', '-verify', unsigned_apk]) != 0:
1803         logging.info("...NOT verified - {0}".format(signed_apk))
1804         return compare_apks(signed_apk, unsigned_apk, tmp_dir)
1805     logging.info("...successfully verified")
1806     return None
1807
1808 apk_badchars = re.compile('''[/ :;'"]''')
1809
1810
1811 def compare_apks(apk1, apk2, tmp_dir):
1812     """Compare two apks
1813
1814     Returns None if the apk content is the same (apart from the signing key),
1815     otherwise a string describing what's different, or what went wrong when
1816     trying to do the comparison.
1817     """
1818
1819     apk1dir = os.path.join(tmp_dir, apk_badchars.sub('_', apk1[0:-4]))  # trim .apk
1820     apk2dir = os.path.join(tmp_dir, apk_badchars.sub('_', apk2[0:-4]))  # trim .apk
1821     for d in [apk1dir, apk2dir]:
1822         if os.path.exists(d):
1823             shutil.rmtree(d)
1824         os.mkdir(d)
1825         os.mkdir(os.path.join(d, 'jar-xf'))
1826
1827     if subprocess.call(['jar', 'xf',
1828                         os.path.abspath(apk1)],
1829                        cwd=os.path.join(apk1dir, 'jar-xf')) != 0:
1830         return("Failed to unpack " + apk1)
1831     if subprocess.call(['jar', 'xf',
1832                         os.path.abspath(apk2)],
1833                        cwd=os.path.join(apk2dir, 'jar-xf')) != 0:
1834         return("Failed to unpack " + apk2)
1835
1836     # try to find apktool in the path, if it hasn't been manually configed
1837     if 'apktool' not in config:
1838         tmp = find_command('apktool')
1839         if tmp is not None:
1840             config['apktool'] = tmp
1841     if 'apktool' in config:
1842         if subprocess.call([config['apktool'], 'd', os.path.abspath(apk1), '--output', 'apktool'],
1843                            cwd=apk1dir) != 0:
1844             return("Failed to unpack " + apk1)
1845         if subprocess.call([config['apktool'], 'd', os.path.abspath(apk2), '--output', 'apktool'],
1846                            cwd=apk2dir) != 0:
1847             return("Failed to unpack " + apk2)
1848
1849     p = FDroidPopen(['diff', '-r', apk1dir, apk2dir], output=False)
1850     lines = p.output.splitlines()
1851     if len(lines) != 1 or 'META-INF' not in lines[0]:
1852         meld = find_command('meld')
1853         if meld is not None:
1854             p = FDroidPopen(['meld', apk1dir, apk2dir], output=False)
1855         return("Unexpected diff output - " + p.output)
1856
1857     # since everything verifies, delete the comparison to keep cruft down
1858     shutil.rmtree(apk1dir)
1859     shutil.rmtree(apk2dir)
1860
1861     # If we get here, it seems like they're the same!
1862     return None
1863
1864
1865 def find_command(command):
1866     '''find the full path of a command, or None if it can't be found in the PATH'''
1867
1868     def is_exe(fpath):
1869         return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
1870
1871     fpath, fname = os.path.split(command)
1872     if fpath:
1873         if is_exe(command):
1874             return command
1875     else:
1876         for path in os.environ["PATH"].split(os.pathsep):
1877             path = path.strip('"')
1878             exe_file = os.path.join(path, command)
1879             if is_exe(exe_file):
1880                 return exe_file
1881
1882     return None
1883
1884
1885 def genpassword():
1886     '''generate a random password for when generating keys'''
1887     h = hashlib.sha256()
1888     h.update(os.urandom(16))  # salt
1889     h.update(bytes(socket.getfqdn()))
1890     return h.digest().encode('base64').strip()
1891
1892
1893 def genkeystore(localconfig):
1894     '''Generate a new key with random passwords and add it to new keystore'''
1895     logging.info('Generating a new key in "' + localconfig['keystore'] + '"...')
1896     keystoredir = os.path.dirname(localconfig['keystore'])
1897     if keystoredir is None or keystoredir == '':
1898         keystoredir = os.path.join(os.getcwd(), keystoredir)
1899     if not os.path.exists(keystoredir):
1900         os.makedirs(keystoredir, mode=0o700)
1901
1902     write_password_file("keystorepass", localconfig['keystorepass'])
1903     write_password_file("keypass", localconfig['keypass'])
1904     p = FDroidPopen(['keytool', '-genkey',
1905                      '-keystore', localconfig['keystore'],
1906                      '-alias', localconfig['repo_keyalias'],
1907                      '-keyalg', 'RSA', '-keysize', '4096',
1908                      '-sigalg', 'SHA256withRSA',
1909                      '-validity', '10000',
1910                      '-storepass:file', config['keystorepassfile'],
1911                      '-keypass:file', config['keypassfile'],
1912                      '-dname', localconfig['keydname']])
1913     # TODO keypass should be sent via stdin
1914     if p.returncode != 0:
1915         raise BuildException("Failed to generate key", p.output)
1916     os.chmod(localconfig['keystore'], 0o0600)
1917     # now show the lovely key that was just generated
1918     p = FDroidPopen(['keytool', '-list', '-v',
1919                      '-keystore', localconfig['keystore'],
1920                      '-alias', localconfig['repo_keyalias'],
1921                      '-storepass:file', config['keystorepassfile']])
1922     logging.info(p.output.strip() + '\n\n')
1923
1924
1925 def write_to_config(thisconfig, key, value=None):
1926     '''write a key/value to the local config.py'''
1927     if value is None:
1928         origkey = key + '_orig'
1929         value = thisconfig[origkey] if origkey in thisconfig else thisconfig[key]
1930     with open('config.py', 'r') as f:
1931         data = f.read()
1932     pattern = '\n[\s#]*' + key + '\s*=\s*"[^"]*"'
1933     repl = '\n' + key + ' = "' + value + '"'
1934     data = re.sub(pattern, repl, data)
1935     # if this key is not in the file, append it
1936     if not re.match('\s*' + key + '\s*=\s*"', data):
1937         data += repl
1938     # make sure the file ends with a carraige return
1939     if not re.match('\n$', data):
1940         data += '\n'
1941     with open('config.py', 'w') as f:
1942         f.writelines(data)
1943
1944
1945 def parse_xml(path):
1946     return XMLElementTree.parse(path).getroot()
1947
1948
1949 def string_is_integer(string):
1950     try:
1951         int(string)
1952         return True
1953     except ValueError:
1954         return False
1955
1956
1957 def get_per_app_repos():
1958     '''per-app repos are dirs named with the packageName of a single app'''
1959
1960     # Android packageNames are Java packages, they may contain uppercase or
1961     # lowercase letters ('A' through 'Z'), numbers, and underscores
1962     # ('_'). However, individual package name parts may only start with
1963     # letters. https://developer.android.com/guide/topics/manifest/manifest-element.html#package
1964     p = re.compile('^([a-zA-Z][a-zA-Z0-9_]*(\\.[a-zA-Z][a-zA-Z0-9_]*)*)?$')
1965
1966     repos = []
1967     for root, dirs, files in os.walk(os.getcwd()):
1968         for d in dirs:
1969             print 'checking', root, 'for', d
1970             if d in ('archive', 'metadata', 'repo', 'srclibs', 'tmp'):
1971                 # standard parts of an fdroid repo, so never packageNames
1972                 continue
1973             elif p.match(d) \
1974                     and os.path.exists(os.path.join(d, 'fdroid', 'repo', 'index.jar')):
1975                 repos.append(d)
1976         break
1977     return repos