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         return XMLElementTree.tostring(element, encoding='utf-8', method='text')
 918
 919     for path in xmlfiles:
 920         if not os.path.isfile(path):
 921             continue
 922         xml = parse_xml(path)
 923         element = xml.find('string[@name="' + name + '"]')
 924         if element is not None:
 925             content = element_content(element)
 926             return retrieve_string(app_dir, content, xmlfiles)
 927
 928     return ''
 929
 930
 931 def retrieve_string_singleline(app_dir, string, xmlfiles=None):
 932     return retrieve_string(app_dir, string, xmlfiles).replace('\n', ' ').strip()
 933
 934
 935 # Return list of existing files that will be used to find the highest vercode
 936 def manifest_paths(app_dir, flavours):
 937
 938     possible_manifests = \
 939         [os.path.join(app_dir, 'AndroidManifest.xml'),
 940          os.path.join(app_dir, 'src', 'main', 'AndroidManifest.xml'),
 941          os.path.join(app_dir, 'src', 'AndroidManifest.xml'),
 942          os.path.join(app_dir, 'build.gradle')]
 943
 944     for flavour in flavours:
 945         if flavour == 'yes':
 946             continue
 947         possible_manifests.append(
 948             os.path.join(app_dir, 'src', flavour, 'AndroidManifest.xml'))
 949
 950     return [path for path in possible_manifests if os.path.isfile(path)]
 951
 952
 953 # Retrieve the package name. Returns the name, or None if not found.
 954 def fetch_real_name(app_dir, flavours):
 955     for path in manifest_paths(app_dir, flavours):
 956         if not has_extension(path, 'xml') or not os.path.isfile(path):
 957             continue
 958         logging.debug("fetch_real_name: Checking manifest at " + path)
 959         xml = parse_xml(path)
 960         app = xml.find('application')
 961         if "{http://schemas.android.com/apk/res/android}label" not in app.attrib:
 962             continue
 963         label = app.attrib["{http://schemas.android.com/apk/res/android}label"].encode('utf-8')
 964         result = retrieve_string_singleline(app_dir, label)
 965         if result:
 966             result = result.strip()
 967         return result
 968     return None
 969
 970
 971 def get_library_references(root_dir):
 972     libraries = []
 973     proppath = os.path.join(root_dir, 'project.properties')
 974     if not os.path.isfile(proppath):
 975         return libraries
 976     for line in file(proppath):
 977         if not line.startswith('android.library.reference.'):
 978             continue
 979         path = line.split('=')[1].strip()
 980         relpath = os.path.join(root_dir, path)
 981         if not os.path.isdir(relpath):
 982             continue
 983         logging.debug("Found subproject at %s" % path)
 984         libraries.append(path)
 985     return libraries
 986
 987
 988 def ant_subprojects(root_dir):
 989     subprojects = get_library_references(root_dir)
 990     for subpath in subprojects:
 991         subrelpath = os.path.join(root_dir, subpath)
 992         for p in get_library_references(subrelpath):
 993             relp = os.path.normpath(os.path.join(subpath, p))
 994             if relp not in subprojects:
 995                 subprojects.insert(0, relp)
 996     return subprojects
 997
 998
 999 def remove_debuggable_flags(root_dir):
1000     # Remove forced debuggable flags
1001     logging.debug("Removing debuggable flags from %s" % root_dir)
1002     for root, dirs, files in os.walk(root_dir):
1003         if 'AndroidManifest.xml' in files:
1004             regsub_file(r'android:debuggable="[^"]*"',
1005                         '',
1006                         os.path.join(root, 'AndroidManifest.xml'))
1007
1008
1009 # Extract some information from the AndroidManifest.xml at the given path.
1010 # Returns (version, vercode, package), any or all of which might be None.
1011 # All values returned are strings.
1012 def parse_androidmanifests(paths, ignoreversions=None):
1013
1014     if not paths:
1015         return (None, None, None)
1016
1017     vcsearch_g = re.compile(r'.*versionCode *=* *["\']*([0-9]+)["\']*').search
1018     vnsearch_g = re.compile(r'.*versionName *=* *(["\'])((?:(?=(\\?))\3.)*?)\1.*').search
1019     psearch_g = re.compile(r'.*(packageName|applicationId) *=* *["\']([^"]+)["\'].*').search
1020
1021     ignoresearch = re.compile(ignoreversions).search if ignoreversions else None
1022
1023     max_version = None
1024     max_vercode = None
1025     max_package = None
1026
1027     for path in paths:
1028
1029         if not os.path.isfile(path):
1030             continue
1031
1032         logging.debug("Parsing manifest at {0}".format(path))
1033         gradle = has_extension(path, 'gradle')
1034         version = None
1035         vercode = None
1036         package = None
1037
1038         if gradle:
1039             for line in file(path):
1040                 if gradle_comment.match(line):
1041                     continue
1042                 # Grab first occurence of each to avoid running into
1043                 # alternative flavours and builds.
1044                 if not package:
1045                     matches = psearch_g(line)
1046                     if matches:
1047                         package = matches.group(2)
1048                 if not version:
1049                     matches = vnsearch_g(line)
1050                     if matches:
1051                         version = matches.group(2)
1052                 if not vercode:
1053                     matches = vcsearch_g(line)
1054                     if matches:
1055                         vercode = matches.group(1)
1056         else:
1057             xml = parse_xml(path)
1058             if "package" in xml.attrib:
1059                 package = xml.attrib["package"].encode('utf-8')
1060             if "{http://schemas.android.com/apk/res/android}versionName" in xml.attrib:
1061                 version = xml.attrib["{http://schemas.android.com/apk/res/android}versionName"].encode('utf-8')
1062                 base_dir = os.path.dirname(path)
1063                 version = retrieve_string_singleline(base_dir, version)
1064             if "{http://schemas.android.com/apk/res/android}versionCode" in xml.attrib:
1065                 a = xml.attrib["{http://schemas.android.com/apk/res/android}versionCode"].encode('utf-8')
1066                 if string_is_integer(a):
1067                     vercode = a
1068
1069         # Remember package name, may be defined separately from version+vercode
1070         if package is None:
1071             package = max_package
1072
1073         logging.debug("..got package={0}, version={1}, vercode={2}"
1074                       .format(package, version, vercode))
1075
1076         # Always grab the package name and version name in case they are not
1077         # together with the highest version code
1078         if max_package is None and package is not None:
1079             max_package = package
1080         if max_version is None and version is not None:
1081             max_version = version
1082
1083         if max_vercode is None or (vercode is not None and vercode > max_vercode):
1084             if not ignoresearch or not ignoresearch(version):
1085                 if version is not None:
1086                     max_version = version
1087                 if vercode is not None:
1088                     max_vercode = vercode
1089                 if package is not None:
1090                     max_package = package
1091             else:
1092                 max_version = "Ignore"
1093
1094     if max_version is None:
1095         max_version = "Unknown"
1096
1097     if max_package and not is_valid_package_name(max_package):
1098         raise FDroidException("Invalid package name {0}".format(max_package))
1099
1100     return (max_version, max_vercode, max_package)
1101
1102
1103 def is_valid_package_name(name):
1104     return re.match("[A-Za-z_][A-Za-z_0-9.]+$", name)
1105
1106
1107 class FDroidException(Exception):
1108
1109     def __init__(self, value, detail=None):
1110         self.value = value
1111         self.detail = detail
1112
1113     def shortened_detail(self):
1114         if len(self.detail) < 16000:
1115             return self.detail
1116         return '[...]\n' + self.detail[-16000:]
1117
1118     def get_wikitext(self):
1119         ret = repr(self.value) + "\n"
1120         if self.detail:
1121             ret += "=detail=\n"
1122             ret += "<pre>\n" + self.shortened_detail() + "</pre>\n"
1123         return ret
1124
1125     def __str__(self):
1126         ret = self.value
1127         if self.detail:
1128             ret += "\n==== detail begin ====\n%s\n==== detail end ====" % self.detail.strip()
1129         return ret
1130
1131
1132 class VCSException(FDroidException):
1133     pass
1134
1135
1136 class BuildException(FDroidException):
1137     pass
1138
1139
1140 # Get the specified source library.
1141 # Returns the path to it. Normally this is the path to be used when referencing
1142 # it, which may be a subdirectory of the actual project. If you want the base
1143 # directory of the project, pass 'basepath=True'.
1144 def getsrclib(spec, srclib_dir, subdir=None, basepath=False,
1145               raw=False, prepare=True, preponly=False, refresh=True):
1146
1147     number = None
1148     subdir = None
1149     if raw:
1150         name = spec
1151         ref = None
1152     else:
1153         name, ref = spec.split('@')
1154         if ':' in name:
1155             number, name = name.split(':', 1)
1156         if '/' in name:
1157             name, subdir = name.split('/', 1)
1158
1159     if name not in metadata.srclibs:
1160         raise VCSException('srclib ' + name + ' not found.')
1161
1162     srclib = metadata.srclibs[name]
1163
1164     sdir = os.path.join(srclib_dir, name)
1165
1166     if not preponly:
1167         vcs = getvcs(srclib["Repo Type"], srclib["Repo"], sdir)
1168         vcs.srclib = (name, number, sdir)
1169         if ref:
1170             vcs.gotorevision(ref, refresh)
1171
1172         if raw:
1173             return vcs
1174
1175     libdir = None
1176     if subdir:
1177         libdir = os.path.join(sdir, subdir)
1178     elif srclib["Subdir"]:
1179         for subdir in srclib["Subdir"]:
1180             libdir_candidate = os.path.join(sdir, subdir)
1181             if os.path.exists(libdir_candidate):
1182                 libdir = libdir_candidate
1183                 break
1184
1185     if libdir is None:
1186         libdir = sdir
1187
1188     remove_signing_keys(sdir)
1189     remove_debuggable_flags(sdir)
1190
1191     if prepare:
1192
1193         if srclib["Prepare"]:
1194             cmd = replace_config_vars(srclib["Prepare"], None)
1195
1196             p = FDroidPopen(['bash', '-x', '-c', cmd], cwd=libdir)
1197             if p.returncode != 0:
1198                 raise BuildException("Error running prepare command for srclib %s"
1199                                      % name, p.output)
1200
1201     if basepath:
1202         libdir = sdir
1203
1204     return (name, number, libdir)
1205
1206
1207 # Prepare the source code for a particular build
1208 #  'vcs'         - the appropriate vcs object for the application
1209 #  'app'         - the application details from the metadata
1210 #  'build'       - the build details from the metadata
1211 #  'build_dir'   - the path to the build directory, usually
1212 #                   'build/app.id'
1213 #  'srclib_dir'  - the path to the source libraries directory, usually
1214 #                   'build/srclib'
1215 #  'extlib_dir'  - the path to the external libraries directory, usually
1216 #                   'build/extlib'
1217 # Returns the (root, srclibpaths) where:
1218 #   'root' is the root directory, which may be the same as 'build_dir' or may
1219 #          be a subdirectory of it.
1220 #   'srclibpaths' is information on the srclibs being used
1221 def prepare_source(vcs, app, build, build_dir, srclib_dir, extlib_dir, onserver=False, refresh=True):
1222
1223     # Optionally, the actual app source can be in a subdirectory
1224     if build['subdir']:
1225         root_dir = os.path.join(build_dir, build['subdir'])
1226     else:
1227         root_dir = build_dir
1228
1229     # Get a working copy of the right revision
1230     logging.info("Getting source for revision " + build['commit'])
1231     vcs.gotorevision(build['commit'], refresh)
1232
1233     # Initialise submodules if required
1234     if build['submodules']:
1235         logging.info("Initialising submodules")
1236         vcs.initsubmodules()
1237
1238     # Check that a subdir (if we're using one) exists. This has to happen
1239     # after the checkout, since it might not exist elsewhere
1240     if not os.path.exists(root_dir):
1241         raise BuildException('Missing subdir ' + root_dir)
1242
1243     # Run an init command if one is required
1244     if build['init']:
1245         cmd = replace_config_vars(build['init'], build)
1246         logging.info("Running 'init' commands in %s" % root_dir)
1247
1248         p = FDroidPopen(['bash', '-x', '-c', cmd], cwd=root_dir)
1249         if p.returncode != 0:
1250             raise BuildException("Error running init command for %s:%s" %
1251                                  (app['id'], build['version']), p.output)
1252
1253     # Apply patches if any
1254     if build['patch']:
1255         logging.info("Applying patches")
1256         for patch in build['patch']:
1257             patch = patch.strip()
1258             logging.info("Applying " + patch)
1259             patch_path = os.path.join('metadata', app['id'], patch)
1260             p = FDroidPopen(['patch', '-p1', '-i', os.path.abspath(patch_path)], cwd=build_dir)
1261             if p.returncode != 0:
1262                 raise BuildException("Failed to apply patch %s" % patch_path)
1263
1264     # Get required source libraries
1265     srclibpaths = []
1266     if build['srclibs']:
1267         logging.info("Collecting source libraries")
1268         for lib in build['srclibs']:
1269             srclibpaths.append(getsrclib(lib, srclib_dir, build, preponly=onserver, refresh=refresh))
1270
1271     for name, number, libpath in srclibpaths:
1272         place_srclib(root_dir, int(number) if number else None, libpath)
1273
1274     basesrclib = vcs.getsrclib()
1275     # If one was used for the main source, add that too.
1276     if basesrclib:
1277         srclibpaths.append(basesrclib)
1278
1279     # Update the local.properties file
1280     localprops = [os.path.join(build_dir, 'local.properties')]
1281     if build['subdir']:
1282         localprops += [os.path.join(root_dir, 'local.properties')]
1283     for path in localprops:
1284         props = ""
1285         if os.path.isfile(path):
1286             logging.info("Updating local.properties file at %s" % path)
1287             with open(path, 'r') as f:
1288                 props += f.read()
1289             props += '\n'
1290         else:
1291             logging.info("Creating local.properties file at %s" % path)
1292         # Fix old-fashioned 'sdk-location' by copying
1293         # from sdk.dir, if necessary
1294         if build['oldsdkloc']:
1295             sdkloc = re.match(r".*^sdk.dir=(\S+)$.*", props,
1296                               re.S | re.M).group(1)
1297             props += "sdk-location=%s\n" % sdkloc
1298         else:
1299             props += "sdk.dir=%s\n" % config['sdk_path']
1300             props += "sdk-location=%s\n" % config['sdk_path']
1301         if build['ndk_path']:
1302             # Add ndk location
1303             props += "ndk.dir=%s\n" % build['ndk_path']
1304             props += "ndk-location=%s\n" % build['ndk_path']
1305         # Add java.encoding if necessary
1306         if build['encoding']:
1307             props += "java.encoding=%s\n" % build['encoding']
1308         with open(path, 'w') as f:
1309             f.write(props)
1310
1311     flavours = []
1312     if build['type'] == 'gradle':
1313         flavours = build['gradle']
1314
1315         version_regex = re.compile(r"[^/]*'com\.android\.tools\.build:gradle:([^\.]+\.[^\.]+).*'.*")
1316         gradlepluginver = None
1317
1318         gradle_dirs = [root_dir]
1319
1320         # Parent dir build.gradle
1321         parent_dir = os.path.normpath(os.path.join(root_dir, '..'))
1322         if parent_dir.startswith(build_dir):
1323             gradle_dirs.append(parent_dir)
1324
1325         for dir_path in gradle_dirs:
1326             if gradlepluginver:
1327                 break
1328             if not os.path.isdir(dir_path):
1329                 continue
1330             for filename in os.listdir(dir_path):
1331                 if not filename.endswith('.gradle'):
1332                     continue
1333                 path = os.path.join(dir_path, filename)
1334                 if not os.path.isfile(path):
1335                     continue
1336                 for line in file(path):
1337                     match = version_regex.match(line)
1338                     if match:
1339                         gradlepluginver = match.group(1)
1340                         break
1341
1342         if gradlepluginver:
1343             build['gradlepluginver'] = LooseVersion(gradlepluginver)
1344         else:
1345             logging.warn("Could not fetch the gradle plugin version, defaulting to 0.11")
1346             build['gradlepluginver'] = LooseVersion('0.11')
1347
1348         if build['target']:
1349             n = build["target"].split('-')[1]
1350             regsub_file(r'compileSdkVersion[ =]+[0-9]+',
1351                         r'compileSdkVersion %s' % n,
1352                         os.path.join(root_dir, 'build.gradle'))
1353
1354     # Remove forced debuggable flags
1355     remove_debuggable_flags(root_dir)
1356
1357     # Insert version code and number into the manifest if necessary
1358     if build['forceversion']:
1359         logging.info("Changing the version name")
1360         for path in manifest_paths(root_dir, flavours):
1361             if not os.path.isfile(path):
1362                 continue
1363             if has_extension(path, 'xml'):
1364                 regsub_file(r'android:versionName="[^"]*"',
1365                             r'android:versionName="%s"' % build['version'],
1366                             path)
1367             elif has_extension(path, 'gradle'):
1368                 regsub_file(r"""(\s*)versionName[\s'"=]+.*""",
1369                             r"""\1versionName '%s'""" % build['version'],
1370                             path)
1371
1372     if build['forcevercode']:
1373         logging.info("Changing the version code")
1374         for path in manifest_paths(root_dir, flavours):
1375             if not os.path.isfile(path):
1376                 continue
1377             if has_extension(path, 'xml'):
1378                 regsub_file(r'android:versionCode="[^"]*"',
1379                             r'android:versionCode="%s"' % build['vercode'],
1380                             path)
1381             elif has_extension(path, 'gradle'):
1382                 regsub_file(r'versionCode[ =]+[0-9]+',
1383                             r'versionCode %s' % build['vercode'],
1384                             path)
1385
1386     # Delete unwanted files
1387     if build['rm']:
1388         logging.info("Removing specified files")
1389         for part in getpaths(build_dir, build['rm']):
1390             dest = os.path.join(build_dir, part)
1391             logging.info("Removing {0}".format(part))
1392             if os.path.lexists(dest):
1393                 if os.path.islink(dest):
1394                     FDroidPopen(['unlink', dest], output=False)
1395                 else:
1396                     FDroidPopen(['rm', '-rf', dest], output=False)
1397             else:
1398                 logging.info("...but it didn't exist")
1399
1400     remove_signing_keys(build_dir)
1401
1402     # Add required external libraries
1403     if build['extlibs']:
1404         logging.info("Collecting prebuilt libraries")
1405         libsdir = os.path.join(root_dir, 'libs')
1406         if not os.path.exists(libsdir):
1407             os.mkdir(libsdir)
1408         for lib in build['extlibs']:
1409             lib = lib.strip()
1410             logging.info("...installing extlib {0}".format(lib))
1411             libf = os.path.basename(lib)
1412             libsrc = os.path.join(extlib_dir, lib)
1413             if not os.path.exists(libsrc):
1414                 raise BuildException("Missing extlib file {0}".format(libsrc))
1415             shutil.copyfile(libsrc, os.path.join(libsdir, libf))
1416
1417     # Run a pre-build command if one is required
1418     if build['prebuild']:
1419         logging.info("Running 'prebuild' commands in %s" % root_dir)
1420
1421         cmd = replace_config_vars(build['prebuild'], build)
1422
1423         # Substitute source library paths into prebuild commands
1424         for name, number, libpath in srclibpaths:
1425             libpath = os.path.relpath(libpath, root_dir)
1426             cmd = cmd.replace('$$' + name + '$$', libpath)
1427
1428         p = FDroidPopen(['bash', '-x', '-c', cmd], cwd=root_dir)
1429         if p.returncode != 0:
1430             raise BuildException("Error running prebuild command for %s:%s" %
1431                                  (app['id'], build['version']), p.output)
1432
1433     # Generate (or update) the ant build file, build.xml...
1434     if build['update'] and build['update'] != ['no'] and build['type'] == 'ant':
1435         parms = ['android', 'update', 'lib-project']
1436         lparms = ['android', 'update', 'project']
1437
1438         if build['target']:
1439             parms += ['-t', build['target']]
1440             lparms += ['-t', build['target']]
1441         if build['update'] == ['auto']:
1442             update_dirs = ant_subprojects(root_dir) + ['.']
1443         else:
1444             update_dirs = build['update']
1445
1446         for d in update_dirs:
1447             subdir = os.path.join(root_dir, d)
1448             if d == '.':
1449                 logging.debug("Updating main project")
1450                 cmd = parms + ['-p', d]
1451             else:
1452                 logging.debug("Updating subproject %s" % d)
1453                 cmd = lparms + ['-p', d]
1454             p = SdkToolsPopen(cmd, cwd=root_dir)
1455             # Check to see whether an error was returned without a proper exit
1456             # code (this is the case for the 'no target set or target invalid'
1457             # error)
1458             if p.returncode != 0 or p.output.startswith("Error: "):
1459                 raise BuildException("Failed to update project at %s" % d, p.output)
1460             # Clean update dirs via ant
1461             if d != '.':
1462                 logging.info("Cleaning subproject %s" % d)
1463                 p = FDroidPopen(['ant', 'clean'], cwd=subdir)
1464
1465     return (root_dir, srclibpaths)
1466
1467
1468 # Extend via globbing the paths from a field and return them as a map from
1469 # original path to resulting paths
1470 def getpaths_map(build_dir, globpaths):
1471     paths = dict()
1472     for p in globpaths:
1473         p = p.strip()
1474         full_path = os.path.join(build_dir, p)
1475         full_path = os.path.normpath(full_path)
1476         paths[p] = [r[len(build_dir) + 1:] for r in glob.glob(full_path)]
1477     return paths
1478
1479
1480 # Extend via globbing the paths from a field and return them as a set
1481 def getpaths(build_dir, globpaths):
1482     paths_map = getpaths_map(build_dir, globpaths)
1483     paths = set()
1484     for k, v in paths_map.iteritems():
1485         for p in v:
1486             paths.add(p)
1487     return paths
1488
1489
1490 def natural_key(s):
1491     return [int(sp) if sp.isdigit() else sp for sp in re.split(r'(\d+)', s)]
1492
1493
1494 class KnownApks:
1495
1496     def __init__(self):
1497         self.path = os.path.join('stats', 'known_apks.txt')
1498         self.apks = {}
1499         if os.path.isfile(self.path):
1500             for line in file(self.path):
1501                 t = line.rstrip().split(' ')
1502                 if len(t) == 2:
1503                     self.apks[t[0]] = (t[1], None)
1504                 else:
1505                     self.apks[t[0]] = (t[1], time.strptime(t[2], '%Y-%m-%d'))
1506         self.changed = False
1507
1508     def writeifchanged(self):
1509         if not self.changed:
1510             return
1511
1512         if not os.path.exists('stats'):
1513             os.mkdir('stats')
1514
1515         lst = []
1516         for apk, app in self.apks.iteritems():
1517             appid, added = app
1518             line = apk + ' ' + appid
1519             if added:
1520                 line += ' ' + time.strftime('%Y-%m-%d', added)
1521             lst.append(line)
1522
1523         with open(self.path, 'w') as f:
1524             for line in sorted(lst, key=natural_key):
1525                 f.write(line + '\n')
1526
1527     # Record an apk (if it's new, otherwise does nothing)
1528     # Returns the date it was added.
1529     def recordapk(self, apk, app):
1530         if apk not in self.apks:
1531             self.apks[apk] = (app, time.gmtime(time.time()))
1532             self.changed = True
1533         _, added = self.apks[apk]
1534         return added
1535
1536     # Look up information - given the 'apkname', returns (app id, date added/None).
1537     # Or returns None for an unknown apk.
1538     def getapp(self, apkname):
1539         if apkname in self.apks:
1540             return self.apks[apkname]
1541         return None
1542
1543     # Get the most recent 'num' apps added to the repo, as a list of package ids
1544     # with the most recent first.
1545     def getlatest(self, num):
1546         apps = {}
1547         for apk, app in self.apks.iteritems():
1548             appid, added = app
1549             if added:
1550                 if appid in apps:
1551                     if apps[appid] > added:
1552                         apps[appid] = added
1553                 else:
1554                     apps[appid] = added
1555         sortedapps = sorted(apps.iteritems(), key=operator.itemgetter(1))[-num:]
1556         lst = [app for app, _ in sortedapps]
1557         lst.reverse()
1558         return lst
1559
1560
1561 def isApkDebuggable(apkfile, config):
1562     """Returns True if the given apk file is debuggable
1563
1564     :param apkfile: full path to the apk to check"""
1565
1566     p = SdkToolsPopen(['aapt', 'dump', 'xmltree', apkfile, 'AndroidManifest.xml'],
1567                       output=False)
1568     if p.returncode != 0:
1569         logging.critical("Failed to get apk manifest information")
1570         sys.exit(1)
1571     for line in p.output.splitlines():
1572         if 'android:debuggable' in line and not line.endswith('0x0'):
1573             return True
1574     return False
1575
1576
1577 class PopenResult:
1578     returncode = None
1579     output = ''
1580
1581
1582 def SdkToolsPopen(commands, cwd=None, output=True):
1583     cmd = commands[0]
1584     if cmd not in config:
1585         config[cmd] = find_sdk_tools_cmd(commands[0])
1586     abscmd = config[cmd]
1587     if abscmd is None:
1588         logging.critical("Could not find '%s' on your system" % cmd)
1589         sys.exit(1)
1590     return FDroidPopen([abscmd] + commands[1:],
1591                        cwd=cwd, output=output)
1592
1593
1594 def FDroidPopen(commands, cwd=None, output=True):
1595     """
1596     Run a command and capture the possibly huge output.
1597
1598     :param commands: command and argument list like in subprocess.Popen
1599     :param cwd: optionally specifies a working directory
1600     :returns: A PopenResult.
1601     """
1602
1603     global env
1604
1605     if cwd:
1606         cwd = os.path.normpath(cwd)
1607         logging.debug("Directory: %s" % cwd)
1608     logging.debug("> %s" % ' '.join(commands))
1609
1610     result = PopenResult()
1611     p = None
1612     try:
1613         p = subprocess.Popen(commands, cwd=cwd, shell=False, env=env,
1614                              stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
1615     except OSError, e:
1616         raise BuildException("OSError while trying to execute " +
1617                              ' '.join(commands) + ': ' + str(e))
1618
1619     stdout_queue = Queue.Queue()
1620     stdout_reader = AsynchronousFileReader(p.stdout, stdout_queue)
1621
1622     # Check the queue for output (until there is no more to get)
1623     while not stdout_reader.eof():
1624         while not stdout_queue.empty():
1625             line = stdout_queue.get()
1626             if output and options.verbose:
1627                 # Output directly to console
1628                 sys.stderr.write(line)
1629                 sys.stderr.flush()
1630             result.output += line
1631
1632         time.sleep(0.1)
1633
1634     result.returncode = p.wait()
1635     return result
1636
1637
1638 gradle_comment = re.compile(r'[ ]*//')
1639
1640
1641 def remove_signing_keys(build_dir):
1642     signing_configs = re.compile(r'^[\t ]*signingConfigs[ \t]*{[ \t]*$')
1643     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     for root, dirs, files in os.walk(build_dir):
1651         if 'build.gradle' in files:
1652             path = os.path.join(root, 'build.gradle')
1653
1654             with open(path, "r") as o:
1655                 lines = o.readlines()
1656
1657             changed = False
1658
1659             opened = 0
1660             i = 0
1661             with open(path, "w") as o:
1662                 while i < len(lines):
1663                     line = lines[i]
1664                     i += 1
1665                     while line.endswith('\\\n'):
1666                         line = line.rstrip('\\\n') + lines[i]
1667                         i += 1
1668
1669                     if gradle_comment.match(line):
1670                         o.write(line)
1671                         continue
1672
1673                     if opened > 0:
1674                         opened += line.count('{')
1675                         opened -= line.count('}')
1676                         continue
1677
1678                     if signing_configs.match(line):
1679                         changed = True
1680                         opened += 1
1681                         continue
1682
1683                     if any(s.match(line) for s in line_matches):
1684                         changed = True
1685                         continue
1686
1687                     if opened == 0:
1688                         o.write(line)
1689
1690             if changed:
1691                 logging.info("Cleaned build.gradle of keysigning configs at %s" % path)
1692
1693         for propfile in [
1694                 'project.properties',
1695                 'build.properties',
1696                 'default.properties',
1697                 'ant.properties', ]:
1698             if propfile in files:
1699                 path = os.path.join(root, propfile)
1700
1701                 with open(path, "r") as o:
1702                     lines = o.readlines()
1703
1704                 changed = False
1705
1706                 with open(path, "w") as o:
1707                     for line in lines:
1708                         if any(line.startswith(s) for s in ('key.store', 'key.alias')):
1709                             changed = True
1710                             continue
1711
1712                         o.write(line)
1713
1714                 if changed:
1715                     logging.info("Cleaned %s of keysigning configs at %s" % (propfile, path))
1716
1717
1718 def reset_env_path():
1719     global env, orig_path
1720     env['PATH'] = orig_path
1721
1722
1723 def add_to_env_path(path):
1724     global env
1725     paths = env['PATH'].split(os.pathsep)
1726     if path in paths:
1727         return
1728     paths.append(path)
1729     env['PATH'] = os.pathsep.join(paths)
1730
1731
1732 def replace_config_vars(cmd, build):
1733     global env
1734     cmd = cmd.replace('$$SDK$$', config['sdk_path'])
1735     # env['ANDROID_NDK'] is set in build_local right before prepare_source
1736     cmd = cmd.replace('$$NDK$$', env['ANDROID_NDK'])
1737     cmd = cmd.replace('$$MVN3$$', config['mvn3'])
1738     if build is not None:
1739         cmd = cmd.replace('$$COMMIT$$', build['commit'])
1740         cmd = cmd.replace('$$VERSION$$', build['version'])
1741         cmd = cmd.replace('$$VERCODE$$', build['vercode'])
1742     return cmd
1743
1744
1745 def place_srclib(root_dir, number, libpath):
1746     if not number:
1747         return
1748     relpath = os.path.relpath(libpath, root_dir)
1749     proppath = os.path.join(root_dir, 'project.properties')
1750
1751     lines = []
1752     if os.path.isfile(proppath):
1753         with open(proppath, "r") as o:
1754             lines = o.readlines()
1755
1756     with open(proppath, "w") as o:
1757         placed = False
1758         for line in lines:
1759             if line.startswith('android.library.reference.%d=' % number):
1760                 o.write('android.library.reference.%d=%s\n' % (number, relpath))
1761                 placed = True
1762             else:
1763                 o.write(line)
1764         if not placed:
1765             o.write('android.library.reference.%d=%s\n' % (number, relpath))
1766
1767
1768 def verify_apks(signed_apk, unsigned_apk, tmp_dir):
1769     """Verify that two apks are the same
1770
1771     One of the inputs is signed, the other is unsigned. The signature metadata
1772     is transferred from the signed to the unsigned apk, and then jarsigner is
1773     used to verify that the signature from the signed apk is also varlid for
1774     the unsigned one.
1775     :param signed_apk: Path to a signed apk file
1776     :param unsigned_apk: Path to an unsigned apk file expected to match it
1777     :param tmp_dir: Path to directory for temporary files
1778     :returns: None if the verification is successful, otherwise a string
1779               describing what went wrong.
1780     """
1781     sigfile = re.compile(r'META-INF/[0-9A-Za-z]+\.(SF|RSA)')
1782     with ZipFile(signed_apk) as signed_apk_as_zip:
1783         meta_inf_files = ['META-INF/MANIFEST.MF']
1784         for f in signed_apk_as_zip.namelist():
1785             if sigfile.match(f):
1786                 meta_inf_files.append(f)
1787         if len(meta_inf_files) < 3:
1788             return "Signature files missing from {0}".format(signed_apk)
1789         signed_apk_as_zip.extractall(tmp_dir, meta_inf_files)
1790     with ZipFile(unsigned_apk, mode='a') as unsigned_apk_as_zip:
1791         for meta_inf_file in meta_inf_files:
1792             unsigned_apk_as_zip.write(os.path.join(tmp_dir, meta_inf_file), arcname=meta_inf_file)
1793
1794     if subprocess.call(['jarsigner', '-verify', unsigned_apk]) != 0:
1795         logging.info("...NOT verified - {0}".format(signed_apk))
1796         return compare_apks(signed_apk, unsigned_apk, tmp_dir)
1797     logging.info("...successfully verified")
1798     return None
1799
1800
1801 def compare_apks(apk1, apk2, tmp_dir):
1802     """Compare two apks
1803
1804     Returns None if the apk content is the same (apart from the signing key),
1805     otherwise a string describing what's different, or what went wrong when
1806     trying to do the comparison.
1807     """
1808
1809     badchars = re.compile('''[/ :;'"]''')
1810     apk1dir = os.path.join(tmp_dir, badchars.sub('_', apk1[0:-4]))  # trim .apk
1811     apk2dir = os.path.join(tmp_dir, badchars.sub('_', apk2[0:-4]))  # trim .apk
1812     for d in [apk1dir, apk2dir]:
1813         if os.path.exists(d):
1814             shutil.rmtree(d)
1815         os.mkdir(d)
1816         os.mkdir(os.path.join(d, 'jar-xf'))
1817
1818     if subprocess.call(['jar', 'xf',
1819                         os.path.abspath(apk1)],
1820                        cwd=os.path.join(apk1dir, 'jar-xf')) != 0:
1821         return("Failed to unpack " + apk1)
1822     if subprocess.call(['jar', 'xf',
1823                         os.path.abspath(apk2)],
1824                        cwd=os.path.join(apk2dir, 'jar-xf')) != 0:
1825         return("Failed to unpack " + apk2)
1826
1827     # try to find apktool in the path, if it hasn't been manually configed
1828     if 'apktool' not in config:
1829         tmp = find_command('apktool')
1830         if tmp is not None:
1831             config['apktool'] = tmp
1832     if 'apktool' in config:
1833         if subprocess.call([config['apktool'], 'd', os.path.abspath(apk1), '--output', 'apktool'],
1834                            cwd=apk1dir) != 0:
1835             return("Failed to unpack " + apk1)
1836         if subprocess.call([config['apktool'], 'd', os.path.abspath(apk2), '--output', 'apktool'],
1837                            cwd=apk2dir) != 0:
1838             return("Failed to unpack " + apk2)
1839
1840     p = FDroidPopen(['diff', '-r', apk1dir, apk2dir], output=False)
1841     lines = p.output.splitlines()
1842     if len(lines) != 1 or 'META-INF' not in lines[0]:
1843         meld = find_command('meld')
1844         if meld is not None:
1845             p = FDroidPopen(['meld', apk1dir, apk2dir], output=False)
1846         return("Unexpected diff output - " + p.output)
1847
1848     # since everything verifies, delete the comparison to keep cruft down
1849     shutil.rmtree(apk1dir)
1850     shutil.rmtree(apk2dir)
1851
1852     # If we get here, it seems like they're the same!
1853     return None
1854
1855
1856 def find_command(command):
1857     '''find the full path of a command, or None if it can't be found in the PATH'''
1858
1859     def is_exe(fpath):
1860         return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
1861
1862     fpath, fname = os.path.split(command)
1863     if fpath:
1864         if is_exe(command):
1865             return command
1866     else:
1867         for path in os.environ["PATH"].split(os.pathsep):
1868             path = path.strip('"')
1869             exe_file = os.path.join(path, command)
1870             if is_exe(exe_file):
1871                 return exe_file
1872
1873     return None
1874
1875
1876 def genpassword():
1877     '''generate a random password for when generating keys'''
1878     h = hashlib.sha256()
1879     h.update(os.urandom(16))  # salt
1880     h.update(bytes(socket.getfqdn()))
1881     return h.digest().encode('base64').strip()
1882
1883
1884 def genkeystore(localconfig):
1885     '''Generate a new key with random passwords and add it to new keystore'''
1886     logging.info('Generating a new key in "' + localconfig['keystore'] + '"...')
1887     keystoredir = os.path.dirname(localconfig['keystore'])
1888     if keystoredir is None or keystoredir == '':
1889         keystoredir = os.path.join(os.getcwd(), keystoredir)
1890     if not os.path.exists(keystoredir):
1891         os.makedirs(keystoredir, mode=0o700)
1892
1893     write_password_file("keystorepass", localconfig['keystorepass'])
1894     write_password_file("keypass", localconfig['keypass'])
1895     p = FDroidPopen(['keytool', '-genkey',
1896                      '-keystore', localconfig['keystore'],
1897                      '-alias', localconfig['repo_keyalias'],
1898                      '-keyalg', 'RSA', '-keysize', '4096',
1899                      '-sigalg', 'SHA256withRSA',
1900                      '-validity', '10000',
1901                      '-storepass:file', config['keystorepassfile'],
1902                      '-keypass:file', config['keypassfile'],
1903                      '-dname', localconfig['keydname']])
1904     # TODO keypass should be sent via stdin
1905     if p.returncode != 0:
1906         raise BuildException("Failed to generate key", p.output)
1907     os.chmod(localconfig['keystore'], 0o0600)
1908     # now show the lovely key that was just generated
1909     p = FDroidPopen(['keytool', '-list', '-v',
1910                      '-keystore', localconfig['keystore'],
1911                      '-alias', localconfig['repo_keyalias'],
1912                      '-storepass:file', config['keystorepassfile']])
1913     logging.info(p.output.strip() + '\n\n')
1914
1915
1916 def write_to_config(thisconfig, key, value=None):
1917     '''write a key/value to the local config.py'''
1918     if value is None:
1919         origkey = key + '_orig'
1920         value = thisconfig[origkey] if origkey in thisconfig else thisconfig[key]
1921     with open('config.py', 'r') as f:
1922         data = f.read()
1923     pattern = '\n[\s#]*' + key + '\s*=\s*"[^"]*"'
1924     repl = '\n' + key + ' = "' + value + '"'
1925     data = re.sub(pattern, repl, data)
1926     # if this key is not in the file, append it
1927     if not re.match('\s*' + key + '\s*=\s*"', data):
1928         data += repl
1929     # make sure the file ends with a carraige return
1930     if not re.match('\n$', data):
1931         data += '\n'
1932     with open('config.py', 'w') as f:
1933         f.writelines(data)
1934
1935
1936 def parse_xml(path):
1937     return XMLElementTree.parse(path).getroot()
1938
1939
1940 def string_is_integer(string):
1941     try:
1942         int(string)
1943         return True
1944     except ValueError:
1945         return False
1946
1947
1948 def get_per_app_repos():
1949     '''per-app repos are dirs named with the packageName of a single app'''
1950
1951     # Android packageNames are Java packages, they may contain uppercase or
1952     # lowercase letters ('A' through 'Z'), numbers, and underscores
1953     # ('_'). However, individual package name parts may only start with
1954     # letters. https://developer.android.com/guide/topics/manifest/manifest-element.html#package
1955     p = re.compile('^([a-zA-Z][a-zA-Z0-9_]*(\\.[a-zA-Z][a-zA-Z0-9_]*)*)?$')
1956
1957     repos = []
1958     for root, dirs, files in os.walk(os.getcwd()):
1959         for d in dirs:
1960             print 'checking', root, 'for', d
1961             if d in ('archive', 'metadata', 'repo', 'srclibs', 'tmp'):
1962                 # standard parts of an fdroid repo, so never packageNames
1963                 continue
1964             elif p.match(d) \
1965                     and os.path.exists(os.path.join(d, 'fdroid', 'repo', 'index.jar')):
1966                 repos.append(d)
1967         break
1968     return repos