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