fdroidserver/common.py

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