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         localprops += [os.path.join(root_dir, 'local.properties')]
1287     for path in localprops:
1288         props = ""
1289         if os.path.isfile(path):
1290             logging.info("Updating local.properties file at %s" % path)
1291             with open(path, 'r') as f:
1292                 props += f.read()
1293             props += '\n'
1294         else:
1295             logging.info("Creating local.properties file at %s" % path)
1296         # Fix old-fashioned 'sdk-location' by copying
1297         # from sdk.dir, if necessary
1298         if build['oldsdkloc']:
1299             sdkloc = re.match(r".*^sdk.dir=(\S+)$.*", props,
1300                               re.S | re.M).group(1)
1301             props += "sdk-location=%s\n" % sdkloc
1302         else:
1303             props += "sdk.dir=%s\n" % config['sdk_path']
1304             props += "sdk-location=%s\n" % config['sdk_path']
1305         if build['ndk_path']:
1306             # Add ndk location
1307             props += "ndk.dir=%s\n" % build['ndk_path']
1308             props += "ndk-location=%s\n" % build['ndk_path']
1309         # Add java.encoding if necessary
1310         if build['encoding']:
1311             props += "java.encoding=%s\n" % build['encoding']
1312         with open(path, 'w') as f:
1313             f.write(props)
1314
1315     flavours = []
1316     if build['type'] == 'gradle':
1317         flavours = build['gradle']
1318
1319         gradlepluginver = None
1320
1321         gradle_dirs = [root_dir]
1322
1323         # Parent dir build.gradle
1324         parent_dir = os.path.normpath(os.path.join(root_dir, '..'))
1325         if parent_dir.startswith(build_dir):
1326             gradle_dirs.append(parent_dir)
1327
1328         for dir_path in gradle_dirs:
1329             if gradlepluginver:
1330                 break
1331             if not os.path.isdir(dir_path):
1332                 continue
1333             for filename in os.listdir(dir_path):
1334                 if not filename.endswith('.gradle'):
1335                     continue
1336                 path = os.path.join(dir_path, filename)
1337                 if not os.path.isfile(path):
1338                     continue
1339                 for line in file(path):
1340                     match = gradle_version_regex.match(line)
1341                     if match:
1342                         gradlepluginver = match.group(1)
1343                         break
1344
1345         if gradlepluginver:
1346             build['gradlepluginver'] = LooseVersion(gradlepluginver)
1347         else:
1348             logging.warn("Could not fetch the gradle plugin version, defaulting to 0.11")
1349             build['gradlepluginver'] = LooseVersion('0.11')
1350
1351         if build['target']:
1352             n = build["target"].split('-')[1]
1353             regsub_file(r'compileSdkVersion[ =]+[0-9]+',
1354                         r'compileSdkVersion %s' % n,
1355                         os.path.join(root_dir, 'build.gradle'))
1356
1357     # Remove forced debuggable flags
1358     remove_debuggable_flags(root_dir)
1359
1360     # Insert version code and number into the manifest if necessary
1361     if build['forceversion']:
1362         logging.info("Changing the version name")
1363         for path in manifest_paths(root_dir, flavours):
1364             if not os.path.isfile(path):
1365                 continue
1366             if has_extension(path, 'xml'):
1367                 regsub_file(r'android:versionName="[^"]*"',
1368                             r'android:versionName="%s"' % build['version'],
1369                             path)
1370             elif has_extension(path, 'gradle'):
1371                 regsub_file(r"""(\s*)versionName[\s'"=]+.*""",
1372                             r"""\1versionName '%s'""" % build['version'],
1373                             path)
1374
1375     if build['forcevercode']:
1376         logging.info("Changing the version code")
1377         for path in manifest_paths(root_dir, flavours):
1378             if not os.path.isfile(path):
1379                 continue
1380             if has_extension(path, 'xml'):
1381                 regsub_file(r'android:versionCode="[^"]*"',
1382                             r'android:versionCode="%s"' % build['vercode'],
1383                             path)
1384             elif has_extension(path, 'gradle'):
1385                 regsub_file(r'versionCode[ =]+[0-9]+',
1386                             r'versionCode %s' % build['vercode'],
1387                             path)
1388
1389     # Delete unwanted files
1390     if build['rm']:
1391         logging.info("Removing specified files")
1392         for part in getpaths(build_dir, build['rm']):
1393             dest = os.path.join(build_dir, part)
1394             logging.info("Removing {0}".format(part))
1395             if os.path.lexists(dest):
1396                 if os.path.islink(dest):
1397                     FDroidPopen(['unlink', dest], output=False)
1398                 else:
1399                     FDroidPopen(['rm', '-rf', dest], output=False)
1400             else:
1401                 logging.info("...but it didn't exist")
1402
1403     remove_signing_keys(build_dir)
1404
1405     # Add required external libraries
1406     if build['extlibs']:
1407         logging.info("Collecting prebuilt libraries")
1408         libsdir = os.path.join(root_dir, 'libs')
1409         if not os.path.exists(libsdir):
1410             os.mkdir(libsdir)
1411         for lib in build['extlibs']:
1412             lib = lib.strip()
1413             logging.info("...installing extlib {0}".format(lib))
1414             libf = os.path.basename(lib)
1415             libsrc = os.path.join(extlib_dir, lib)
1416             if not os.path.exists(libsrc):
1417                 raise BuildException("Missing extlib file {0}".format(libsrc))
1418             shutil.copyfile(libsrc, os.path.join(libsdir, libf))
1419
1420     # Run a pre-build command if one is required
1421     if build['prebuild']:
1422         logging.info("Running 'prebuild' commands in %s" % root_dir)
1423
1424         cmd = replace_config_vars(build['prebuild'], build)
1425
1426         # Substitute source library paths into prebuild commands
1427         for name, number, libpath in srclibpaths:
1428             libpath = os.path.relpath(libpath, root_dir)
1429             cmd = cmd.replace('$$' + name + '$$', libpath)
1430
1431         p = FDroidPopen(['bash', '-x', '-c', cmd], cwd=root_dir)
1432         if p.returncode != 0:
1433             raise BuildException("Error running prebuild command for %s:%s" %
1434                                  (app['id'], build['version']), p.output)
1435
1436     # Generate (or update) the ant build file, build.xml...
1437     if build['update'] and build['update'] != ['no'] and build['type'] == 'ant':
1438         parms = ['android', 'update', 'lib-project']
1439         lparms = ['android', 'update', 'project']
1440
1441         if build['target']:
1442             parms += ['-t', build['target']]
1443             lparms += ['-t', build['target']]
1444         if build['update'] == ['auto']:
1445             update_dirs = ant_subprojects(root_dir) + ['.']
1446         else:
1447             update_dirs = build['update']
1448
1449         for d in update_dirs:
1450             subdir = os.path.join(root_dir, d)
1451             if d == '.':
1452                 logging.debug("Updating main project")
1453                 cmd = parms + ['-p', d]
1454             else:
1455                 logging.debug("Updating subproject %s" % d)
1456                 cmd = lparms + ['-p', d]
1457             p = SdkToolsPopen(cmd, cwd=root_dir)
1458             # Check to see whether an error was returned without a proper exit
1459             # code (this is the case for the 'no target set or target invalid'
1460             # error)
1461             if p.returncode != 0 or p.output.startswith("Error: "):
1462                 raise BuildException("Failed to update project at %s" % d, p.output)
1463             # Clean update dirs via ant
1464             if d != '.':
1465                 logging.info("Cleaning subproject %s" % d)
1466                 p = FDroidPopen(['ant', 'clean'], cwd=subdir)
1467
1468     return (root_dir, srclibpaths)
1469
1470
1471 # Extend via globbing the paths from a field and return them as a map from
1472 # original path to resulting paths
1473 def getpaths_map(build_dir, globpaths):
1474     paths = dict()
1475     for p in globpaths:
1476         p = p.strip()
1477         full_path = os.path.join(build_dir, p)
1478         full_path = os.path.normpath(full_path)
1479         paths[p] = [r[len(build_dir) + 1:] for r in glob.glob(full_path)]
1480     return paths
1481
1482
1483 # Extend via globbing the paths from a field and return them as a set
1484 def getpaths(build_dir, globpaths):
1485     paths_map = getpaths_map(build_dir, globpaths)
1486     paths = set()
1487     for k, v in paths_map.iteritems():
1488         for p in v:
1489             paths.add(p)
1490     return paths
1491
1492
1493 def natural_key(s):
1494     return [int(sp) if sp.isdigit() else sp for sp in re.split(r'(\d+)', s)]
1495
1496
1497 class KnownApks:
1498
1499     def __init__(self):
1500         self.path = os.path.join('stats', 'known_apks.txt')
1501         self.apks = {}
1502         if os.path.isfile(self.path):
1503             for line in file(self.path):
1504                 t = line.rstrip().split(' ')
1505                 if len(t) == 2:
1506                     self.apks[t[0]] = (t[1], None)
1507                 else:
1508                     self.apks[t[0]] = (t[1], time.strptime(t[2], '%Y-%m-%d'))
1509         self.changed = False
1510
1511     def writeifchanged(self):
1512         if not self.changed:
1513             return
1514
1515         if not os.path.exists('stats'):
1516             os.mkdir('stats')
1517
1518         lst = []
1519         for apk, app in self.apks.iteritems():
1520             appid, added = app
1521             line = apk + ' ' + appid
1522             if added:
1523                 line += ' ' + time.strftime('%Y-%m-%d', added)
1524             lst.append(line)
1525
1526         with open(self.path, 'w') as f:
1527             for line in sorted(lst, key=natural_key):
1528                 f.write(line + '\n')
1529
1530     # Record an apk (if it's new, otherwise does nothing)
1531     # Returns the date it was added.
1532     def recordapk(self, apk, app):
1533         if apk not in self.apks:
1534             self.apks[apk] = (app, time.gmtime(time.time()))
1535             self.changed = True
1536         _, added = self.apks[apk]
1537         return added
1538
1539     # Look up information - given the 'apkname', returns (app id, date added/None).
1540     # Or returns None for an unknown apk.
1541     def getapp(self, apkname):
1542         if apkname in self.apks:
1543             return self.apks[apkname]
1544         return None
1545
1546     # Get the most recent 'num' apps added to the repo, as a list of package ids
1547     # with the most recent first.
1548     def getlatest(self, num):
1549         apps = {}
1550         for apk, app in self.apks.iteritems():
1551             appid, added = app
1552             if added:
1553                 if appid in apps:
1554                     if apps[appid] > added:
1555                         apps[appid] = added
1556                 else:
1557                     apps[appid] = added
1558         sortedapps = sorted(apps.iteritems(), key=operator.itemgetter(1))[-num:]
1559         lst = [app for app, _ in sortedapps]
1560         lst.reverse()
1561         return lst
1562
1563
1564 def isApkDebuggable(apkfile, config):
1565     """Returns True if the given apk file is debuggable
1566
1567     :param apkfile: full path to the apk to check"""
1568
1569     p = SdkToolsPopen(['aapt', 'dump', 'xmltree', apkfile, 'AndroidManifest.xml'],
1570                       output=False)
1571     if p.returncode != 0:
1572         logging.critical("Failed to get apk manifest information")
1573         sys.exit(1)
1574     for line in p.output.splitlines():
1575         if 'android:debuggable' in line and not line.endswith('0x0'):
1576             return True
1577     return False
1578
1579
1580 class PopenResult:
1581     returncode = None
1582     output = ''
1583
1584
1585 def SdkToolsPopen(commands, cwd=None, output=True):
1586     cmd = commands[0]
1587     if cmd not in config:
1588         config[cmd] = find_sdk_tools_cmd(commands[0])
1589     abscmd = config[cmd]
1590     if abscmd is None:
1591         logging.critical("Could not find '%s' on your system" % cmd)
1592         sys.exit(1)
1593     return FDroidPopen([abscmd] + commands[1:],
1594                        cwd=cwd, output=output)
1595
1596
1597 def FDroidPopen(commands, cwd=None, output=True):
1598     """
1599     Run a command and capture the possibly huge output.
1600
1601     :param commands: command and argument list like in subprocess.Popen
1602     :param cwd: optionally specifies a working directory
1603     :returns: A PopenResult.
1604     """
1605
1606     global env
1607
1608     if cwd:
1609         cwd = os.path.normpath(cwd)
1610         logging.debug("Directory: %s" % cwd)
1611     logging.debug("> %s" % ' '.join(commands))
1612
1613     result = PopenResult()
1614     p = None
1615     try:
1616         p = subprocess.Popen(commands, cwd=cwd, shell=False, env=env,
1617                              stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
1618     except OSError, e:
1619         raise BuildException("OSError while trying to execute " +
1620                              ' '.join(commands) + ': ' + str(e))
1621
1622     stdout_queue = Queue.Queue()
1623     stdout_reader = AsynchronousFileReader(p.stdout, stdout_queue)
1624
1625     # Check the queue for output (until there is no more to get)
1626     while not stdout_reader.eof():
1627         while not stdout_queue.empty():
1628             line = stdout_queue.get()
1629             if output and options.verbose:
1630                 # Output directly to console
1631                 sys.stderr.write(line)
1632                 sys.stderr.flush()
1633             result.output += line
1634
1635         time.sleep(0.1)
1636
1637     result.returncode = p.wait()
1638     return result
1639
1640
1641 gradle_comment = re.compile(r'[ ]*//')
1642 gradle_signing_configs = re.compile(r'^[\t ]*signingConfigs[ \t]*{[ \t]*$')
1643 gradle_line_matches = [
1644     re.compile(r'^[\t ]*signingConfig [^ ]*$'),
1645     re.compile(r'.*android\.signingConfigs\.[^{]*$'),
1646     re.compile(r'.*variant\.outputFile = .*'),
1647     re.compile(r'.*output\.outputFile = .*'),
1648     re.compile(r'.*\.readLine\(.*'),
1649 ]
1650
1651
1652 def remove_signing_keys(build_dir):
1653     for root, dirs, files in os.walk(build_dir):
1654         if 'build.gradle' in files:
1655             path = os.path.join(root, 'build.gradle')
1656
1657             with open(path, "r") as o:
1658                 lines = o.readlines()
1659
1660             changed = False
1661
1662             opened = 0
1663             i = 0
1664             with open(path, "w") as o:
1665                 while i < len(lines):
1666                     line = lines[i]
1667                     i += 1
1668                     while line.endswith('\\\n'):
1669                         line = line.rstrip('\\\n') + lines[i]
1670                         i += 1
1671
1672                     if gradle_comment.match(line):
1673                         o.write(line)
1674                         continue
1675
1676                     if opened > 0:
1677                         opened += line.count('{')
1678                         opened -= line.count('}')
1679                         continue
1680
1681                     if gradle_signing_configs.match(line):
1682                         changed = True
1683                         opened += 1
1684                         continue
1685
1686                     if any(s.match(line) for s in gradle_line_matches):
1687                         changed = True
1688                         continue
1689
1690                     if opened == 0:
1691                         o.write(line)
1692
1693             if changed:
1694                 logging.info("Cleaned build.gradle of keysigning configs at %s" % path)
1695
1696         for propfile in [
1697                 'project.properties',
1698                 'build.properties',
1699                 'default.properties',
1700                 'ant.properties', ]:
1701             if propfile in files:
1702                 path = os.path.join(root, propfile)
1703
1704                 with open(path, "r") as o:
1705                     lines = o.readlines()
1706
1707                 changed = False
1708
1709                 with open(path, "w") as o:
1710                     for line in lines:
1711                         if any(line.startswith(s) for s in ('key.store', 'key.alias')):
1712                             changed = True
1713                             continue
1714
1715                         o.write(line)
1716
1717                 if changed:
1718                     logging.info("Cleaned %s of keysigning configs at %s" % (propfile, path))
1719
1720
1721 def reset_env_path():
1722     global env, orig_path
1723     env['PATH'] = orig_path
1724
1725
1726 def add_to_env_path(path):
1727     global env
1728     paths = env['PATH'].split(os.pathsep)
1729     if path in paths:
1730         return
1731     paths.append(path)
1732     env['PATH'] = os.pathsep.join(paths)
1733
1734
1735 def replace_config_vars(cmd, build):
1736     global env
1737     cmd = cmd.replace('$$SDK$$', config['sdk_path'])
1738     # env['ANDROID_NDK'] is set in build_local right before prepare_source
1739     cmd = cmd.replace('$$NDK$$', env['ANDROID_NDK'])
1740     cmd = cmd.replace('$$MVN3$$', config['mvn3'])
1741     if build is not None:
1742         cmd = cmd.replace('$$COMMIT$$', build['commit'])
1743         cmd = cmd.replace('$$VERSION$$', build['version'])
1744         cmd = cmd.replace('$$VERCODE$$', build['vercode'])
1745     return cmd
1746
1747
1748 def place_srclib(root_dir, number, libpath):
1749     if not number:
1750         return
1751     relpath = os.path.relpath(libpath, root_dir)
1752     proppath = os.path.join(root_dir, 'project.properties')
1753
1754     lines = []
1755     if os.path.isfile(proppath):
1756         with open(proppath, "r") as o:
1757             lines = o.readlines()
1758
1759     with open(proppath, "w") as o:
1760         placed = False
1761         for line in lines:
1762             if line.startswith('android.library.reference.%d=' % number):
1763                 o.write('android.library.reference.%d=%s\n' % (number, relpath))
1764                 placed = True
1765             else:
1766                 o.write(line)
1767         if not placed:
1768             o.write('android.library.reference.%d=%s\n' % (number, relpath))
1769
1770 apk_sigfile = re.compile(r'META-INF/[0-9A-Za-z]+\.(SF|RSA)')
1771
1772
1773 def verify_apks(signed_apk, unsigned_apk, tmp_dir):
1774     """Verify that two apks are the same
1775
1776     One of the inputs is signed, the other is unsigned. The signature metadata
1777     is transferred from the signed to the unsigned apk, and then jarsigner is
1778     used to verify that the signature from the signed apk is also varlid for
1779     the unsigned one.
1780     :param signed_apk: Path to a signed apk file
1781     :param unsigned_apk: Path to an unsigned apk file expected to match it
1782     :param tmp_dir: Path to directory for temporary files
1783     :returns: None if the verification is successful, otherwise a string
1784               describing what went wrong.
1785     """
1786     with ZipFile(signed_apk) as signed_apk_as_zip:
1787         meta_inf_files = ['META-INF/MANIFEST.MF']
1788         for f in signed_apk_as_zip.namelist():
1789             if apk_sigfile.match(f):
1790                 meta_inf_files.append(f)
1791         if len(meta_inf_files) < 3:
1792             return "Signature files missing from {0}".format(signed_apk)
1793         signed_apk_as_zip.extractall(tmp_dir, meta_inf_files)
1794     with ZipFile(unsigned_apk, mode='a') as unsigned_apk_as_zip:
1795         for meta_inf_file in meta_inf_files:
1796             unsigned_apk_as_zip.write(os.path.join(tmp_dir, meta_inf_file), arcname=meta_inf_file)
1797
1798     if subprocess.call(['jarsigner', '-verify', unsigned_apk]) != 0:
1799         logging.info("...NOT verified - {0}".format(signed_apk))
1800         return compare_apks(signed_apk, unsigned_apk, tmp_dir)
1801     logging.info("...successfully verified")
1802     return None
1803
1804 apk_badchars = re.compile('''[/ :;'"]''')
1805
1806
1807 def compare_apks(apk1, apk2, tmp_dir):
1808     """Compare two apks
1809
1810     Returns None if the apk content is the same (apart from the signing key),
1811     otherwise a string describing what's different, or what went wrong when
1812     trying to do the comparison.
1813     """
1814
1815     apk1dir = os.path.join(tmp_dir, apk_badchars.sub('_', apk1[0:-4]))  # trim .apk
1816     apk2dir = os.path.join(tmp_dir, apk_badchars.sub('_', apk2[0:-4]))  # trim .apk
1817     for d in [apk1dir, apk2dir]:
1818         if os.path.exists(d):
1819             shutil.rmtree(d)
1820         os.mkdir(d)
1821         os.mkdir(os.path.join(d, 'jar-xf'))
1822
1823     if subprocess.call(['jar', 'xf',
1824                         os.path.abspath(apk1)],
1825                        cwd=os.path.join(apk1dir, 'jar-xf')) != 0:
1826         return("Failed to unpack " + apk1)
1827     if subprocess.call(['jar', 'xf',
1828                         os.path.abspath(apk2)],
1829                        cwd=os.path.join(apk2dir, 'jar-xf')) != 0:
1830         return("Failed to unpack " + apk2)
1831
1832     # try to find apktool in the path, if it hasn't been manually configed
1833     if 'apktool' not in config:
1834         tmp = find_command('apktool')
1835         if tmp is not None:
1836             config['apktool'] = tmp
1837     if 'apktool' in config:
1838         if subprocess.call([config['apktool'], 'd', os.path.abspath(apk1), '--output', 'apktool'],
1839                            cwd=apk1dir) != 0:
1840             return("Failed to unpack " + apk1)
1841         if subprocess.call([config['apktool'], 'd', os.path.abspath(apk2), '--output', 'apktool'],
1842                            cwd=apk2dir) != 0:
1843             return("Failed to unpack " + apk2)
1844
1845     p = FDroidPopen(['diff', '-r', apk1dir, apk2dir], output=False)
1846     lines = p.output.splitlines()
1847     if len(lines) != 1 or 'META-INF' not in lines[0]:
1848         meld = find_command('meld')
1849         if meld is not None:
1850             p = FDroidPopen(['meld', apk1dir, apk2dir], output=False)
1851         return("Unexpected diff output - " + p.output)
1852
1853     # since everything verifies, delete the comparison to keep cruft down
1854     shutil.rmtree(apk1dir)
1855     shutil.rmtree(apk2dir)
1856
1857     # If we get here, it seems like they're the same!
1858     return None
1859
1860
1861 def find_command(command):
1862     '''find the full path of a command, or None if it can't be found in the PATH'''
1863
1864     def is_exe(fpath):
1865         return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
1866
1867     fpath, fname = os.path.split(command)
1868     if fpath:
1869         if is_exe(command):
1870             return command
1871     else:
1872         for path in os.environ["PATH"].split(os.pathsep):
1873             path = path.strip('"')
1874             exe_file = os.path.join(path, command)
1875             if is_exe(exe_file):
1876                 return exe_file
1877
1878     return None
1879
1880
1881 def genpassword():
1882     '''generate a random password for when generating keys'''
1883     h = hashlib.sha256()
1884     h.update(os.urandom(16))  # salt
1885     h.update(bytes(socket.getfqdn()))
1886     return h.digest().encode('base64').strip()
1887
1888
1889 def genkeystore(localconfig):
1890     '''Generate a new key with random passwords and add it to new keystore'''
1891     logging.info('Generating a new key in "' + localconfig['keystore'] + '"...')
1892     keystoredir = os.path.dirname(localconfig['keystore'])
1893     if keystoredir is None or keystoredir == '':
1894         keystoredir = os.path.join(os.getcwd(), keystoredir)
1895     if not os.path.exists(keystoredir):
1896         os.makedirs(keystoredir, mode=0o700)
1897
1898     write_password_file("keystorepass", localconfig['keystorepass'])
1899     write_password_file("keypass", localconfig['keypass'])
1900     p = FDroidPopen(['keytool', '-genkey',
1901                      '-keystore', localconfig['keystore'],
1902                      '-alias', localconfig['repo_keyalias'],
1903                      '-keyalg', 'RSA', '-keysize', '4096',
1904                      '-sigalg', 'SHA256withRSA',
1905                      '-validity', '10000',
1906                      '-storepass:file', config['keystorepassfile'],
1907                      '-keypass:file', config['keypassfile'],
1908                      '-dname', localconfig['keydname']])
1909     # TODO keypass should be sent via stdin
1910     if p.returncode != 0:
1911         raise BuildException("Failed to generate key", p.output)
1912     os.chmod(localconfig['keystore'], 0o0600)
1913     # now show the lovely key that was just generated
1914     p = FDroidPopen(['keytool', '-list', '-v',
1915                      '-keystore', localconfig['keystore'],
1916                      '-alias', localconfig['repo_keyalias'],
1917                      '-storepass:file', config['keystorepassfile']])
1918     logging.info(p.output.strip() + '\n\n')
1919
1920
1921 def write_to_config(thisconfig, key, value=None):
1922     '''write a key/value to the local config.py'''
1923     if value is None:
1924         origkey = key + '_orig'
1925         value = thisconfig[origkey] if origkey in thisconfig else thisconfig[key]
1926     with open('config.py', 'r') as f:
1927         data = f.read()
1928     pattern = '\n[\s#]*' + key + '\s*=\s*"[^"]*"'
1929     repl = '\n' + key + ' = "' + value + '"'
1930     data = re.sub(pattern, repl, data)
1931     # if this key is not in the file, append it
1932     if not re.match('\s*' + key + '\s*=\s*"', data):
1933         data += repl
1934     # make sure the file ends with a carraige return
1935     if not re.match('\n$', data):
1936         data += '\n'
1937     with open('config.py', 'w') as f:
1938         f.writelines(data)
1939
1940
1941 def parse_xml(path):
1942     return XMLElementTree.parse(path).getroot()
1943
1944
1945 def string_is_integer(string):
1946     try:
1947         int(string)
1948         return True
1949     except ValueError:
1950         return False
1951
1952
1953 def get_per_app_repos():
1954     '''per-app repos are dirs named with the packageName of a single app'''
1955
1956     # Android packageNames are Java packages, they may contain uppercase or
1957     # lowercase letters ('A' through 'Z'), numbers, and underscores
1958     # ('_'). However, individual package name parts may only start with
1959     # letters. https://developer.android.com/guide/topics/manifest/manifest-element.html#package
1960     p = re.compile('^([a-zA-Z][a-zA-Z0-9_]*(\\.[a-zA-Z][a-zA-Z0-9_]*)*)?$')
1961
1962     repos = []
1963     for root, dirs, files in os.walk(os.getcwd()):
1964         for d in dirs:
1965             print 'checking', root, 'for', d
1966             if d in ('archive', 'metadata', 'repo', 'srclibs', 'tmp'):
1967                 # standard parts of an fdroid repo, so never packageNames
1968                 continue
1969             elif p.match(d) \
1970                     and os.path.exists(os.path.join(d, 'fdroid', 'repo', 'index.jar')):
1971                 repos.append(d)
1972         break
1973     return repos