fdroidserver/build.py

   1 #!/usr/bin/env python2
   2 # -*- coding: utf-8 -*-
   3 #
   4 # build.py - part of the FDroid server tools
   5 # Copyright (C) 2010-13, Ciaran Gultnieks, ciaran@ciarang.com
   6 # Copyright (C) 2013-2014 Daniel Martí <mvdan@mvdan.cc>
   7 #
   8 # This program is free software: you can redistribute it and/or modify
   9 # it under the terms of the GNU Affero General Public License as published by
  10 # the Free Software Foundation, either version 3 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU Affero General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU Affero General Public License
  19 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 import sys
  22 import os
  23 import shutil
  24 import subprocess
  25 import re
  26 import tarfile
  27 import traceback
  28 import time
  29 import json
  30 from ConfigParser import ConfigParser
  31 from optparse import OptionParser, OptionError
  32 import logging
  33 import multiprocessing
  34
  35 import common, metadata
  36 from common import BuildException, VCSException, FDroidPopen, SilentPopen
  37
  38 def get_builder_vm_id():
  39     vd = os.path.join('builder', '.vagrant')
  40     if os.path.isdir(vd):
  41         # Vagrant 1.2 (and maybe 1.1?) it's a directory tree...
  42         with open(os.path.join(vd, 'machines', 'default', 'virtualbox', 'id')) as vf:
  43             id = vf.read()
  44         return id
  45     else:
  46         # Vagrant 1.0 - it's a json file...
  47         with open(os.path.join('builder', '.vagrant')) as vf:
  48             v = json.load(vf)
  49         return v['active']['default']
  50
  51 def got_valid_builder_vm():
  52     """Returns True if we have a valid-looking builder vm
  53     """
  54     if not os.path.exists(os.path.join('builder', 'Vagrantfile')):
  55         return False
  56     vd = os.path.join('builder', '.vagrant')
  57     if not os.path.exists(vd):
  58         return False
  59     if not os.path.isdir(vd):
  60         # Vagrant 1.0 - if the directory is there, it's valid...
  61         return True
  62     # Vagrant 1.2 - the directory can exist, but the id can be missing...
  63     if not os.path.exists(os.path.join(vd, 'machines', 'default', 'virtualbox', 'id')):
  64         return False
  65     return True
  66
  67
  68 def vagrant(params, cwd=None, printout=False):
  69     """Run vagrant.
  70
  71     :param: list of parameters to pass to vagrant
  72     :cwd: directory to run in, or None for current directory
  73     :returns: (ret, out) where ret is the return code, and out
  74                is the stdout (and stderr) from vagrant
  75     """
  76     p = FDroidPopen(['vagrant'] + params, cwd=cwd)
  77     return (p.returncode, p.stdout)
  78
  79
  80 # Note that 'force' here also implies test mode.
  81 def build_server(app, thisbuild, vcs, build_dir, output_dir, force):
  82     """Do a build on the build server."""
  83
  84     import ssh
  85     if options.verbose:
  86         logging.getLogger("ssh").setLevel(logging.DEBUG)
  87     else:
  88         logging.getLogger("ssh").setLevel(logging.WARN)
  89
  90     # Reset existing builder machine to a clean state if possible.
  91     vm_ok = False
  92     if not options.resetserver:
  93         logging.info("Checking for valid existing build server")
  94
  95         if got_valid_builder_vm():
  96             logging.info("...VM is present")
  97             p = FDroidPopen(['VBoxManage', 'snapshot', get_builder_vm_id(), 'list', '--details'], cwd='builder')
  98             if 'fdroidclean' in p.stdout:
  99                 logging.info("...snapshot exists - resetting build server to clean state")
 100                 retcode, output = vagrant(['status'], cwd='builder')
 101
 102                 if 'running' in output:
 103                     logging.info("...suspending")
 104                     vagrant(['suspend'], cwd='builder')
 105                     logging.info("...waiting a sec...")
 106                     time.sleep(10)
 107                 p = FDroidPopen(['VBoxManage', 'snapshot', get_builder_vm_id(), 'restore', 'fdroidclean'],
 108                     cwd='builder')
 109
 110                 if p.returncode == 0:
 111                     logging.info("...reset to snapshot - server is valid")
 112                     retcode, output = vagrant(['up'], cwd='builder')
 113                     if retcode != 0:
 114                         raise BuildException("Failed to start build server")
 115                     logging.info("...waiting a sec...")
 116                     time.sleep(10)
 117                     vm_ok = True
 118                 else:
 119                     logging.info("...failed to reset to snapshot")
 120             else:
 121                 logging.info("...snapshot doesn't exist - VBoxManage snapshot list:\n" + output)
 122
 123     # If we can't use the existing machine for any reason, make a
 124     # new one from scratch.
 125     if not vm_ok:
 126         if os.path.exists('builder'):
 127             logging.info("Removing broken/incomplete/unwanted build server")
 128             vagrant(['destroy', '-f'], cwd='builder')
 129             shutil.rmtree('builder')
 130         os.mkdir('builder')
 131
 132         p = subprocess.Popen('vagrant --version', shell=True, stdout=subprocess.PIPE)
 133         vver = p.communicate()[0]
 134         if vver.startswith('Vagrant version 1.2'):
 135             with open('builder/Vagrantfile', 'w') as vf:
 136                 vf.write('Vagrant.configure("2") do |config|\n')
 137                 vf.write('config.vm.box = "buildserver"\n')
 138                 vf.write('end\n')
 139         else:
 140             with open('builder/Vagrantfile', 'w') as vf:
 141                 vf.write('Vagrant::Config.run do |config|\n')
 142                 vf.write('config.vm.box = "buildserver"\n')
 143                 vf.write('end\n')
 144
 145         logging.info("Starting new build server")
 146         retcode, _ = vagrant(['up'], cwd='builder')
 147         if retcode != 0:
 148             raise BuildException("Failed to start build server")
 149
 150         # Open SSH connection to make sure it's working and ready...
 151         logging.info("Connecting to virtual machine...")
 152         if subprocess.call('vagrant ssh-config >sshconfig',
 153                 cwd='builder', shell=True) != 0:
 154             raise BuildException("Error getting ssh config")
 155         vagranthost = 'default' # Host in ssh config file
 156         sshconfig = ssh.SSHConfig()
 157         sshf = open('builder/sshconfig', 'r')
 158         sshconfig.parse(sshf)
 159         sshf.close()
 160         sshconfig = sshconfig.lookup(vagranthost)
 161         sshs = ssh.SSHClient()
 162         sshs.set_missing_host_key_policy(ssh.AutoAddPolicy())
 163         idfile = sshconfig['identityfile']
 164         if idfile.startswith('"') and idfile.endswith('"'):
 165             idfile = idfile[1:-1]
 166         sshs.connect(sshconfig['hostname'], username=sshconfig['user'],
 167             port=int(sshconfig['port']), timeout=300, look_for_keys=False,
 168             key_filename=idfile)
 169         sshs.close()
 170
 171         logging.info("Saving clean state of new build server")
 172         retcode, _ = vagrant(['suspend'], cwd='builder')
 173         if retcode != 0:
 174             raise BuildException("Failed to suspend build server")
 175         logging.info("...waiting a sec...")
 176         time.sleep(10)
 177         p = FDroidPopen(['VBoxManage', 'snapshot', get_builder_vm_id(), 'take', 'fdroidclean'],
 178                 cwd='builder')
 179         if p.returncode != 0:
 180             raise BuildException("Failed to take snapshot")
 181         logging.info("...waiting a sec...")
 182         time.sleep(10)
 183         logging.info("Restarting new build server")
 184         retcode, _ = vagrant(['up'], cwd='builder')
 185         if retcode != 0:
 186             raise BuildException("Failed to start build server")
 187         logging.info("...waiting a sec...")
 188         time.sleep(10)
 189         # Make sure it worked...
 190         p = FDroidPopen(['VBoxManage', 'snapshot', get_builder_vm_id(), 'list', '--details'],
 191             cwd='builder')
 192         if 'fdroidclean' not in p.stdout:
 193             raise BuildException("Failed to take snapshot.")
 194
 195     try:
 196
 197         # Get SSH configuration settings for us to connect...
 198         logging.info("Getting ssh configuration...")
 199         subprocess.call('vagrant ssh-config >sshconfig',
 200                 cwd='builder', shell=True)
 201         vagranthost = 'default' # Host in ssh config file
 202
 203         # Load and parse the SSH config...
 204         sshconfig = ssh.SSHConfig()
 205         sshf = open('builder/sshconfig', 'r')
 206         sshconfig.parse(sshf)
 207         sshf.close()
 208         sshconfig = sshconfig.lookup(vagranthost)
 209
 210         # Open SSH connection...
 211         logging.info("Connecting to virtual machine...")
 212         sshs = ssh.SSHClient()
 213         sshs.set_missing_host_key_policy(ssh.AutoAddPolicy())
 214         idfile = sshconfig['identityfile']
 215         if idfile.startswith('"') and idfile.endswith('"'):
 216             idfile = idfile[1:-1]
 217         sshs.connect(sshconfig['hostname'], username=sshconfig['user'],
 218             port=int(sshconfig['port']), timeout=300, look_for_keys=False,
 219             key_filename=idfile)
 220
 221         # Get an SFTP connection...
 222         ftp = sshs.open_sftp()
 223         ftp.get_channel().settimeout(15)
 224
 225         # Put all the necessary files in place...
 226         ftp.chdir('/home/vagrant')
 227
 228         # Helper to copy the contents of a directory to the server...
 229         def send_dir(path):
 230             root = os.path.dirname(path)
 231             main = os.path.basename(path)
 232             ftp.mkdir(main)
 233             for r, d, f in os.walk(path):
 234                 rr = os.path.relpath(r, root)
 235                 ftp.chdir(rr)
 236                 for dd in d:
 237                     ftp.mkdir(dd)
 238                 for ff in f:
 239                     lfile = os.path.join(root, rr, ff)
 240                     if not os.path.islink(lfile):
 241                         ftp.put(lfile, ff)
 242                         ftp.chmod(ff, os.stat(lfile).st_mode)
 243                 for i in range(len(rr.split('/'))):
 244                     ftp.chdir('..')
 245             ftp.chdir('..')
 246
 247         logging.info("Preparing server for build...")
 248         serverpath = os.path.abspath(os.path.dirname(__file__))
 249         ftp.put(os.path.join(serverpath, 'build.py'), 'build.py')
 250         ftp.put(os.path.join(serverpath, 'common.py'), 'common.py')
 251         ftp.put(os.path.join(serverpath, 'metadata.py'), 'metadata.py')
 252         ftp.put(os.path.join(serverpath, '..', 'buildserver',
 253             'config.buildserver.py'), 'config.py')
 254         ftp.chmod('config.py', 0o600)
 255
 256         # Copy the metadata - just the file for this app...
 257         ftp.mkdir('metadata')
 258         ftp.mkdir('srclibs')
 259         ftp.chdir('metadata')
 260         ftp.put(os.path.join('metadata', app['id'] + '.txt'),
 261                 app['id'] + '.txt')
 262         # And patches if there are any...
 263         if os.path.exists(os.path.join('metadata', app['id'])):
 264             send_dir(os.path.join('metadata', app['id']))
 265
 266         ftp.chdir('/home/vagrant')
 267         # Create the build directory...
 268         ftp.mkdir('build')
 269         ftp.chdir('build')
 270         ftp.mkdir('extlib')
 271         ftp.mkdir('srclib')
 272         # Copy any extlibs that are required...
 273         if 'extlibs' in thisbuild:
 274             ftp.chdir('/home/vagrant/build/extlib')
 275             for lib in thisbuild['extlibs']:
 276                 lib = lib.strip()
 277                 libsrc = os.path.join('build/extlib', lib)
 278                 if not os.path.exists(libsrc):
 279                     raise BuildException("Missing extlib {0}".format(libsrc))
 280                 lp = lib.split('/')
 281                 for d in lp[:-1]:
 282                     if d not in ftp.listdir():
 283                         ftp.mkdir(d)
 284                     ftp.chdir(d)
 285                 ftp.put(libsrc, lp[-1])
 286                 for _ in lp[:-1]:
 287                     ftp.chdir('..')
 288         # Copy any srclibs that are required...
 289         srclibpaths = []
 290         if 'srclibs' in thisbuild:
 291             for lib in thisbuild['srclibs']:
 292                 srclibpaths.append(common.getsrclib(lib, 'build/srclib', srclibpaths,
 293                     basepath=True, prepare=False))
 294
 295         # If one was used for the main source, add that too.
 296         basesrclib = vcs.getsrclib()
 297         if basesrclib:
 298             srclibpaths.append(basesrclib)
 299         for name, number, lib in srclibpaths:
 300             logging.info("Sending srclib '%s'" % lib)
 301             ftp.chdir('/home/vagrant/build/srclib')
 302             if not os.path.exists(lib):
 303                 raise BuildException("Missing srclib directory '" + lib + "'")
 304             fv = '.fdroidvcs-' + name
 305             ftp.put(os.path.join('build/srclib', fv), fv)
 306             send_dir(lib)
 307             # Copy the metadata file too...
 308             ftp.chdir('/home/vagrant/srclibs')
 309             ftp.put(os.path.join('srclibs', name + '.txt'),
 310                     name + '.txt')
 311         # Copy the main app source code
 312         # (no need if it's a srclib)
 313         if (not basesrclib) and os.path.exists(build_dir):
 314             ftp.chdir('/home/vagrant/build')
 315             fv = '.fdroidvcs-' + app['id']
 316             ftp.put(os.path.join('build', fv), fv)
 317             send_dir(build_dir)
 318
 319         # Execute the build script...
 320         logging.info("Starting build...")
 321         chan = sshs.get_transport().open_session()
 322         chan.get_pty()
 323         cmdline = 'python build.py --on-server'
 324         if force:
 325             cmdline += ' --force --test'
 326         if options.verbose:
 327             cmdline += ' --verbose'
 328         cmdline += " %s:%s" % (app['id'], thisbuild['vercode'])
 329         chan.exec_command('bash -c ". ~/.bsenv && ' + cmdline + '"')
 330         output = ''
 331         while not chan.exit_status_ready():
 332             while chan.recv_ready():
 333                 output += chan.recv(1024)
 334             time.sleep(0.1)
 335         logging.info("...getting exit status")
 336         returncode = chan.recv_exit_status()
 337         while True:
 338             get = chan.recv(1024)
 339             if len(get) == 0:
 340                 break
 341             output += get
 342         if returncode != 0:
 343             raise BuildException("Build.py failed on server for %s:%s" % (app['id'], thisbuild['version']), output)
 344
 345         # Retrieve the built files...
 346         logging.info("Retrieving build output...")
 347         if force:
 348             ftp.chdir('/home/vagrant/tmp')
 349         else:
 350             ftp.chdir('/home/vagrant/unsigned')
 351         apkfile = common.getapkname(app,thisbuild)
 352         tarball = common.getsrcname(app,thisbuild)
 353         try:
 354             ftp.get(apkfile, os.path.join(output_dir, apkfile))
 355             if not options.notarball:
 356                 ftp.get(tarball, os.path.join(output_dir, tarball))
 357         except:
 358             raise BuildException("Build failed for %s:%s - missing output files" % (app['id'], thisbuild['version']), output)
 359         ftp.close()
 360
 361     finally:
 362
 363         # Suspend the build server.
 364         logging.info("Suspending build server")
 365         subprocess.call(['vagrant', 'suspend'], cwd='builder')
 366
 367 def adapt_gradle(build_dir):
 368     for root, dirs, files in os.walk(build_dir):
 369         if 'build.gradle' in files:
 370             path = os.path.join(root, 'build.gradle')
 371             logging.info("Adapting build.gradle at %s" % path)
 372
 373             FDroidPopen(['sed', '-i',
 374                     r's@buildToolsVersion\([ =]*\)["\'][0-9\.]*["\']@buildToolsVersion\1"'
 375                     + config['build_tools'] + '"@g', path])
 376
 377
 378 def build_local(app, thisbuild, vcs, build_dir, output_dir, srclib_dir, extlib_dir, tmp_dir, force, onserver):
 379     """Do a build locally."""
 380
 381     if thisbuild.get('buildjni') not in (None, ['no']):
 382         if not config['ndk_path']:
 383             logging.critical("$ANDROID_NDK is not set!")
 384             sys.exit(3)
 385         elif not os.path.isdir(config['sdk_path']):
 386             logging.critical("$ANDROID_NDK points to a non-existing directory!")
 387             sys.exit(3)
 388
 389     # Prepare the source code...
 390     root_dir, srclibpaths = common.prepare_source(vcs, app, thisbuild,
 391             build_dir, srclib_dir, extlib_dir, onserver)
 392
 393     # We need to clean via the build tool in case the binary dirs are
 394     # different from the default ones
 395     p = None
 396     if thisbuild['type'] == 'maven':
 397         logging.info("Cleaning Maven project...")
 398         cmd = [config['mvn3'], 'clean', '-Dandroid.sdk.path=' + config['sdk_path']]
 399
 400         if '@' in thisbuild['maven']:
 401             maven_dir = os.path.join(root_dir, thisbuild['maven'].split('@',1)[1])
 402             maven_dir = os.path.normpath(maven_dir)
 403         else:
 404             maven_dir = root_dir
 405
 406         p = FDroidPopen(cmd, cwd=maven_dir)
 407
 408     elif thisbuild['type'] == 'gradle':
 409
 410         logging.info("Cleaning Gradle project...")
 411         cmd = [config['gradle'], 'clean']
 412
 413         if '@' in thisbuild['gradle']:
 414             gradle_dir = os.path.join(root_dir, thisbuild['gradle'].split('@',1)[1])
 415             gradle_dir = os.path.normpath(gradle_dir)
 416         else:
 417             gradle_dir = root_dir
 418
 419         adapt_gradle(build_dir)
 420         for name, number, libpath in srclibpaths:
 421             adapt_gradle(libpath)
 422
 423         p = FDroidPopen(cmd, cwd=gradle_dir)
 424
 425     elif thisbuild['type'] == 'kivy':
 426         pass
 427
 428     elif thisbuild['type'] == 'ant':
 429         logging.info("Cleaning Ant project...")
 430         p = FDroidPopen(['ant', 'clean'], cwd=root_dir)
 431
 432     if p is not None and p.returncode != 0:
 433         raise BuildException("Error cleaning %s:%s" %
 434                 (app['id'], thisbuild['version']), p.stdout)
 435
 436     logging.info("Getting rid of Gradle wrapper binaries...")
 437     for root, dirs, files in os.walk(build_dir):
 438         # Don't remove possibly necessary 'gradle' dirs if 'gradlew' is not there
 439         if 'gradlew' in files:
 440             os.remove(os.path.join(root, 'gradlew'))
 441             if 'gradlew.bat' in files:
 442                 os.remove(os.path.join(root, 'gradlew.bat'))
 443             if 'gradle' in dirs:
 444                 shutil.rmtree(os.path.join(root, 'gradle'))
 445
 446     if not options.skipscan:
 447         # Scan before building...
 448         logging.info("Scanning source for common problems...")
 449         buildprobs = common.scan_source(build_dir, root_dir, thisbuild)
 450         if len(buildprobs) > 0:
 451             logging.warn('Scanner found %d problems:' % len(buildprobs))
 452             for problem in buildprobs:
 453                 logging.info('    %s' % problem)
 454             if not force:
 455                 raise BuildException("Can't build due to " +
 456                     str(len(buildprobs)) + " scanned problems")
 457
 458     if not options.notarball:
 459         # Build the source tarball right before we build the release...
 460         logging.info("Creating source tarball...")
 461         tarname = common.getsrcname(app,thisbuild)
 462         tarball = tarfile.open(os.path.join(tmp_dir, tarname), "w:gz")
 463         def tarexc(f):
 464             return any(f.endswith(s) for s in ['.svn', '.git', '.hg', '.bzr'])
 465         tarball.add(build_dir, tarname, exclude=tarexc)
 466         tarball.close()
 467
 468     # Run a build command if one is required...
 469     if 'build' in thisbuild:
 470         cmd = common.replace_config_vars(thisbuild['build'])
 471         # Substitute source library paths into commands...
 472         for name, number, libpath in srclibpaths:
 473             libpath = os.path.relpath(libpath, root_dir)
 474             cmd = cmd.replace('$$' + name + '$$', libpath)
 475         logging.info("Running 'build' commands in %s" % root_dir)
 476
 477         p = FDroidPopen(['bash', '-x', '-c', cmd], cwd=root_dir)
 478
 479         if p.returncode != 0:
 480             raise BuildException("Error running build command for %s:%s" %
 481                     (app['id'], thisbuild['version']), p.stdout)
 482
 483     # Build native stuff if required...
 484     if thisbuild.get('buildjni') not in (None, ['no']):
 485         logging.info("Building native libraries...")
 486         jni_components = thisbuild.get('buildjni')
 487         if jni_components == ['yes']:
 488             jni_components = ['']
 489         cmd = [ os.path.join(config['ndk_path'], "ndk-build", "-j1" ]
 490         for d in jni_components:
 491             logging.info("Building native code in '%s'" % d)
 492             manifest = root_dir + '/' + d + '/AndroidManifest.xml'
 493             if os.path.exists(manifest):
 494                 # Read and write the whole AM.xml to fix newlines and avoid
 495                 # the ndk r8c or later 'wordlist' errors. The outcome of this
 496                 # under gnu/linux is the same as when using tools like
 497                 # dos2unix, but the native python way is faster and will
 498                 # work in non-unix systems.
 499                 manifest_text = open(manifest, 'U').read()
 500                 open(manifest, 'w').write(manifest_text)
 501                 # In case the AM.xml read was big, free the memory
 502                 del manifest_text
 503             p = FDroidPopen(cmd, cwd=os.path.join(root_dir,d))
 504             if p.returncode != 0:
 505                 raise BuildException("NDK build failed for %s:%s" % (app['id'], thisbuild['version']), p.stdout)
 506
 507     p = None
 508     # Build the release...
 509     if thisbuild['type'] == 'maven':
 510         logging.info("Building Maven project...")
 511
 512         if '@' in thisbuild['maven']:
 513             maven_dir = os.path.join(root_dir, thisbuild['maven'].split('@',1)[1])
 514         else:
 515             maven_dir = root_dir
 516
 517         mvncmd = [config['mvn3'], '-Dandroid.sdk.path=' + config['sdk_path'],
 518                 '-Dandroid.sign.debug=false', '-Dmaven.test.skip=true',
 519                 '-Dandroid.release=true', 'package']
 520         if 'target' in thisbuild:
 521             target = thisbuild["target"].split('-')[1]
 522             FDroidPopen(['sed', '-i',
 523                     's@<platform>[0-9]*</platform>@<platform>'+target+'</platform>@g',
 524                     'pom.xml'], cwd=root_dir)
 525             if '@' in thisbuild['maven']:
 526                 FDroidPopen(['sed', '-i',
 527                         's@<platform>[0-9]*</platform>@<platform>'+target+'</platform>@g',
 528                         'pom.xml'], cwd=maven_dir)
 529
 530         if 'mvnflags' in thisbuild:
 531             mvncmd += thisbuild['mvnflags']
 532
 533         p = FDroidPopen(mvncmd, cwd=maven_dir)
 534
 535         bindir = os.path.join(root_dir, 'target')
 536
 537     elif thisbuild['type'] == 'kivy':
 538         logging.info("Building Kivy project...")
 539
 540         spec = os.path.join(root_dir, 'buildozer.spec')
 541         if not os.path.exists(spec):
 542             raise BuildException("Expected to find buildozer-compatible spec at {0}"
 543                     .format(spec))
 544
 545         defaults = {'orientation': 'landscape', 'icon': '',
 546                 'permissions': '', 'android.api': "18"}
 547         bconfig = ConfigParser(defaults, allow_no_value=True)
 548         bconfig.read(spec)
 549
 550         distdir = 'python-for-android/dist/fdroid'
 551         if os.path.exists(distdir):
 552             shutil.rmtree(distdir)
 553
 554         modules = bconfig.get('app', 'requirements').split(',')
 555
 556         cmd = 'ANDROIDSDK=' + config['sdk_path']
 557         cmd += ' ANDROIDNDK=' + config['ndk_path']
 558         cmd += ' ANDROIDNDKVER=r9'
 559         cmd += ' ANDROIDAPI=' + str(bconfig.get('app', 'android.api'))
 560         cmd += ' VIRTUALENV=virtualenv'
 561         cmd += ' ./distribute.sh'
 562         cmd += ' -m ' + "'" + ' '.join(modules) + "'"
 563         cmd += ' -d fdroid'
 564         p = FDroidPopen(cmd, cwd='python-for-android', shell=True)
 565         if p.returncode != 0:
 566             raise BuildException("Distribute build failed")
 567
 568         cid = bconfig.get('app', 'package.domain') + '.' + bconfig.get('app', 'package.name')
 569         if cid != app['id']:
 570             raise BuildException("Package ID mismatch between metadata and spec")
 571
 572         orientation = bconfig.get('app', 'orientation', 'landscape')
 573         if orientation == 'all':
 574             orientation = 'sensor'
 575
 576         cmd = ['./build.py'
 577                 '--dir', root_dir,
 578                 '--name', bconfig.get('app', 'title'),
 579                 '--package', app['id'],
 580                 '--version', bconfig.get('app', 'version'),
 581                 '--orientation', orientation,
 582                 ]
 583
 584         perms = bconfig.get('app', 'permissions')
 585         for perm in perms.split(','):
 586             cmd.extend(['--permission', perm])
 587
 588         if config.get('app', 'fullscreen') == 0:
 589             cmd.append('--window')
 590
 591         icon = bconfig.get('app', 'icon.filename')
 592         if icon:
 593             cmd.extend(['--icon', os.path.join(root_dir, icon)])
 594
 595         cmd.append('release')
 596         p = FDroidPopen(cmd, cwd=distdir)
 597
 598     elif thisbuild['type'] == 'gradle':
 599         logging.info("Building Gradle project...")
 600         if '@' in thisbuild['gradle']:
 601             flavours = thisbuild['gradle'].split('@')[0].split(',')
 602             gradle_dir = thisbuild['gradle'].split('@')[1]
 603             gradle_dir = os.path.join(root_dir, gradle_dir)
 604         else:
 605             flavours = thisbuild['gradle'].split(',')
 606             gradle_dir = root_dir
 607
 608         if len(flavours) == 1 and flavours[0] in ['main', 'yes', '']:
 609             flavours[0] = ''
 610
 611         commands = [config['gradle']]
 612         if 'preassemble' in thisbuild:
 613             commands += thisbuild['preassemble'].split()
 614
 615         flavours_cmd = ''.join(flavours)
 616         if flavours_cmd:
 617             flavours_cmd = flavours_cmd[0].upper() + flavours_cmd[1:]
 618
 619         commands += ['assemble'+flavours_cmd+'Release']
 620
 621         p = FDroidPopen(commands, cwd=gradle_dir)
 622
 623     elif thisbuild['type'] == 'ant':
 624         logging.info("Building Ant project...")
 625         cmd = ['ant']
 626         if 'antcommand' in thisbuild:
 627             cmd += [thisbuild['antcommand']]
 628         else:
 629             cmd += ['release']
 630         p = FDroidPopen(cmd, cwd=root_dir)
 631
 632         bindir = os.path.join(root_dir, 'bin')
 633
 634     if p is not None and p.returncode != 0:
 635         raise BuildException("Build failed for %s:%s" % (app['id'], thisbuild['version']), p.stdout)
 636     logging.info("Successfully built version " + thisbuild['version'] + ' of ' + app['id'])
 637
 638     if thisbuild['type'] == 'maven':
 639         stdout_apk = '\n'.join([
 640             line for line in p.stdout.splitlines() if any(a in line for a in ('.apk','.ap_'))])
 641         m = re.match(r".*^\[INFO\] .*apkbuilder.*/([^/]*)\.apk",
 642                 stdout_apk, re.S|re.M)
 643         if not m:
 644             m = re.match(r".*^\[INFO\] Creating additional unsigned apk file .*/([^/]+)\.apk[^l]",
 645                     stdout_apk, re.S|re.M)
 646         if not m:
 647             m = re.match(r'.*^\[INFO\] [^$]*aapt \[package,[^$]*' + bindir + r'/([^/]+)\.ap[_k][,\]]',
 648                     stdout_apk, re.S|re.M)
 649         if not m:
 650             raise BuildException('Failed to find output')
 651         src = m.group(1)
 652         src = os.path.join(bindir, src) + '.apk'
 653     elif thisbuild['type'] == 'kivy':
 654         src = 'python-for-android/dist/default/bin/{0}-{1}-release.apk'.format(
 655                 bconfig.get('app', 'title'), bconfig.get('app', 'version'))
 656     elif thisbuild['type'] == 'gradle':
 657         dd = build_dir
 658         if 'subdir' in thisbuild:
 659             dd = os.path.join(dd, thisbuild['subdir'])
 660         if len(flavours) == 1 and flavours[0] == '':
 661             name = '-'.join([os.path.basename(dd), 'release', 'unsigned'])
 662         else:
 663             name = '-'.join([os.path.basename(dd), '-'.join(flavours), 'release', 'unsigned'])
 664         src = os.path.join(dd, 'build', 'apk', name+'.apk')
 665     elif thisbuild['type'] == 'ant':
 666         stdout_apk = '\n'.join([
 667             line for line in p.stdout.splitlines() if '.apk' in line])
 668         src = re.match(r".*^.*Creating (.+) for release.*$.*", stdout_apk,
 669             re.S|re.M).group(1)
 670         src = os.path.join(bindir, src)
 671     elif thisbuild['type'] == 'raw':
 672         src = os.path.join(root_dir, thisbuild['output'])
 673         src = os.path.normpath(src)
 674
 675     # Make sure it's not debuggable...
 676     if common.isApkDebuggable(src, config):
 677         raise BuildException("APK is debuggable")
 678
 679     # By way of a sanity check, make sure the version and version
 680     # code in our new apk match what we expect...
 681     logging.info("Checking " + src)
 682     if not os.path.exists(src):
 683         raise BuildException("Unsigned apk is not at expected location of " + src)
 684
 685     p = SilentPopen([os.path.join(config['sdk_path'],
 686         'build-tools', config['build_tools'], 'aapt'),
 687         'dump', 'badging', src])
 688
 689     vercode = None
 690     version = None
 691     foundid = None
 692     for line in p.stdout.splitlines():
 693         if line.startswith("package:"):
 694             pat = re.compile(".*name='([a-zA-Z0-9._]*)'.*")
 695             m = pat.match(line)
 696             if m:
 697                 foundid = m.group(1)
 698             pat = re.compile(".*versionCode='([0-9]*)'.*")
 699             m = pat.match(line)
 700             if m:
 701                 vercode = m.group(1)
 702             pat = re.compile(".*versionName='([^']*)'.*")
 703             m = pat.match(line)
 704             if m:
 705                 version = m.group(1)
 706
 707     if thisbuild['novcheck']:
 708         vercode = thisbuild['vercode']
 709         version = thisbuild['version']
 710     if not version or not vercode:
 711         raise BuildException("Could not find version information in build in output")
 712     if not foundid:
 713         raise BuildException("Could not find package ID in output")
 714     if foundid != app['id']:
 715         raise BuildException("Wrong package ID - build " + foundid + " but expected " + app['id'])
 716
 717     # Some apps (e.g. Timeriffic) have had the bonkers idea of
 718     # including the entire changelog in the version number. Remove
 719     # it so we can compare. (TODO: might be better to remove it
 720     # before we compile, in fact)
 721     index = version.find(" //")
 722     if index != -1:
 723         version = version[:index]
 724
 725     if (version != thisbuild['version'] or
 726             vercode != thisbuild['vercode']):
 727         raise BuildException(("Unexpected version/version code in output;"
 728                              " APK: '%s' / '%s', "
 729                              " Expected: '%s' / '%s'")
 730                              % (version, str(vercode), thisbuild['version'], str(thisbuild['vercode']))
 731                             )
 732
 733     # Copy the unsigned apk to our destination directory for further
 734     # processing (by publish.py)...
 735     dest = os.path.join(output_dir, common.getapkname(app,thisbuild))
 736     shutil.copyfile(src, dest)
 737
 738     # Move the source tarball into the output directory...
 739     if output_dir != tmp_dir and not options.notarball:
 740         shutil.move(os.path.join(tmp_dir, tarname),
 741             os.path.join(output_dir, tarname))
 742
 743
 744 def trybuild(app, thisbuild, build_dir, output_dir, also_check_dir, srclib_dir, extlib_dir,
 745         tmp_dir, repo_dir, vcs, test, server, force, onserver):
 746     """
 747     Build a particular version of an application, if it needs building.
 748
 749     :param output_dir: The directory where the build output will go. Usually
 750        this is the 'unsigned' directory.
 751     :param repo_dir: The repo directory - used for checking if the build is
 752        necessary.
 753     :paaram also_check_dir: An additional location for checking if the build
 754        is necessary (usually the archive repo)
 755     :param test: True if building in test mode, in which case the build will
 756        always happen, even if the output already exists. In test mode, the
 757        output directory should be a temporary location, not any of the real
 758        ones.
 759
 760     :returns: True if the build was done, False if it wasn't necessary.
 761     """
 762
 763     dest_apk = common.getapkname(app, thisbuild)
 764
 765     dest = os.path.join(output_dir, dest_apk)
 766     dest_repo = os.path.join(repo_dir, dest_apk)
 767
 768     if not test:
 769         if os.path.exists(dest) or os.path.exists(dest_repo):
 770             return False
 771
 772         if also_check_dir:
 773             dest_also = os.path.join(also_check_dir, dest_apk)
 774             if os.path.exists(dest_also):
 775                 return False
 776
 777     if 'disable' in thisbuild:
 778         return False
 779
 780     logging.info("Building version " + thisbuild['version'] + ' of ' + app['id'])
 781
 782     if server:
 783         # When using server mode, still keep a local cache of the repo, by
 784         # grabbing the source now.
 785         vcs.gotorevision(thisbuild['commit'])
 786
 787         build_server(app, thisbuild, vcs, build_dir, output_dir, force)
 788     else:
 789         build_local(app, thisbuild, vcs, build_dir, output_dir, srclib_dir, extlib_dir, tmp_dir, force, onserver)
 790     return True
 791
 792
 793 def parse_commandline():
 794     """Parse the command line. Returns options, args."""
 795
 796     parser = OptionParser(usage="Usage: %prog [options] [APPID[:VERCODE] [APPID[:VERCODE] ...]]")
 797     parser.add_option("-v", "--verbose", action="store_true", default=False,
 798                       help="Spew out even more information than normal")
 799     parser.add_option("-q", "--quiet", action="store_true", default=False,
 800                       help="Restrict output to warnings and errors")
 801     parser.add_option("-l", "--latest", action="store_true", default=False,
 802                       help="Build only the latest version of each package")
 803     parser.add_option("-s", "--stop", action="store_true", default=False,
 804                       help="Make the build stop on exceptions")
 805     parser.add_option("-t", "--test", action="store_true", default=False,
 806                       help="Test mode - put output in the tmp directory only, and always build, even if the output already exists.")
 807     parser.add_option("--server", action="store_true", default=False,
 808                       help="Use build server")
 809     parser.add_option("--resetserver", action="store_true", default=False,
 810                       help="Reset and create a brand new build server, even if the existing one appears to be ok.")
 811     parser.add_option("--on-server", dest="onserver", action="store_true", default=False,
 812                       help="Specify that we're running on the build server")
 813     parser.add_option("--skip-scan", dest="skipscan", action="store_true", default=False,
 814                       help="Skip scanning the source code for binaries and other problems")
 815     parser.add_option("--no-tarball", dest="notarball", action="store_true", default=False,
 816                       help="Don't create a source tarball, useful when testing a build")
 817     parser.add_option("-f", "--force", action="store_true", default=False,
 818                       help="Force build of disabled apps, and carries on regardless of scan problems. Only allowed in test mode.")
 819     parser.add_option("-a", "--all", action="store_true", default=False,
 820                       help="Build all applications available")
 821     parser.add_option("-w", "--wiki", default=False, action="store_true",
 822                       help="Update the wiki")
 823     options, args = parser.parse_args()
 824
 825     # Force --stop with --on-server to get correct exit code
 826     if options.onserver:
 827         options.stop = True
 828
 829     if options.force and not options.test:
 830         raise OptionError("Force is only allowed in test mode", "force")
 831
 832     return options, args
 833
 834 options = None
 835 config = None
 836
 837 def main():
 838
 839     global options, config
 840
 841     options, args = parse_commandline()
 842     if not args and not options.all:
 843         raise OptionError("If you really want to build all the apps, use --all", "all")
 844
 845     config = common.read_config(options)
 846
 847     if config['build_server_always']:
 848         options.server = True
 849     if options.resetserver and not options.server:
 850         raise OptionError("Using --resetserver without --server makes no sense", "resetserver")
 851
 852     log_dir = 'logs'
 853     if not os.path.isdir(log_dir):
 854         logging.info("Creating log directory")
 855         os.makedirs(log_dir)
 856
 857     tmp_dir = 'tmp'
 858     if not os.path.isdir(tmp_dir):
 859         logging.info("Creating temporary directory")
 860         os.makedirs(tmp_dir)
 861
 862     if options.test:
 863         output_dir = tmp_dir
 864     else:
 865         output_dir = 'unsigned'
 866         if not os.path.isdir(output_dir):
 867             logging.info("Creating output directory")
 868             os.makedirs(output_dir)
 869
 870     if config['archive_older'] != 0:
 871         also_check_dir = 'archive'
 872     else:
 873         also_check_dir = None
 874
 875     repo_dir = 'repo'
 876
 877     build_dir = 'build'
 878     if not os.path.isdir(build_dir):
 879         logging.info("Creating build directory")
 880         os.makedirs(build_dir)
 881     srclib_dir = os.path.join(build_dir, 'srclib')
 882     extlib_dir = os.path.join(build_dir, 'extlib')
 883
 884     # Get all apps...
 885     allapps = metadata.read_metadata(xref=not options.onserver)
 886
 887     apps = common.read_app_args(args, allapps, True)
 888     apps = [app for app in apps if (options.force or not app['Disabled']) and
 889             len(app['Repo Type']) > 0 and len(app['builds']) > 0]
 890
 891     if len(apps) == 0:
 892         raise Exception("No apps to process.")
 893
 894     if options.latest:
 895         for app in apps:
 896             for build in reversed(app['builds']):
 897                 if 'disable' in build:
 898                     continue
 899                 app['builds'] = [ build ]
 900                 break
 901
 902     if options.wiki:
 903         import mwclient
 904         site = mwclient.Site((config['wiki_protocol'], config['wiki_server']),
 905                 path=config['wiki_path'])
 906         site.login(config['wiki_user'], config['wiki_password'])
 907
 908     # Build applications...
 909     failed_apps = {}
 910     build_succeeded = []
 911     for app in apps:
 912
 913         first = True
 914
 915         for thisbuild in app['builds']:
 916             wikilog = None
 917             try:
 918
 919                 # For the first build of a particular app, we need to set up
 920                 # the source repo. We can reuse it on subsequent builds, if
 921                 # there are any.
 922                 if first:
 923                     if app['Repo Type'] == 'srclib':
 924                         build_dir = os.path.join('build', 'srclib', app['Repo'])
 925                     else:
 926                         build_dir = os.path.join('build', app['id'])
 927
 928                     # Set up vcs interface and make sure we have the latest code...
 929                     logging.debug("Getting {0} vcs interface for {1}".format(
 930                             app['Repo Type'], app['Repo']))
 931                     vcs = common.getvcs(app['Repo Type'], app['Repo'], build_dir)
 932
 933                     first = False
 934
 935                 logging.debug("Checking " + thisbuild['version'])
 936                 if trybuild(app, thisbuild, build_dir, output_dir, also_check_dir,
 937                         srclib_dir, extlib_dir, tmp_dir, repo_dir, vcs, options.test,
 938                         options.server, options.force, options.onserver):
 939                     build_succeeded.append(app)
 940                     wikilog = "Build succeeded"
 941             except BuildException as be:
 942                 logfile = open(os.path.join(log_dir, app['id'] + '.log'), 'a+')
 943                 logfile.write(str(be))
 944                 logfile.close()
 945                 reason = str(be).split('\n',1)[0] if options.verbose else str(be)
 946                 print("Could not build app %s due to BuildException: %s" % (
 947                     app['id'], reason))
 948                 if options.stop:
 949                     sys.exit(1)
 950                 failed_apps[app['id']] = be
 951                 wikilog = be.get_wikitext()
 952             except VCSException as vcse:
 953                 print("VCS error while building app %s: %s" % (app['id'], vcse))
 954                 if options.stop:
 955                     sys.exit(1)
 956                 failed_apps[app['id']] = vcse
 957                 wikilog = str(vcse)
 958             except Exception as e:
 959                 print("Could not build app %s due to unknown error: %s" % (app['id'], traceback.format_exc()))
 960                 if options.stop:
 961                     sys.exit(1)
 962                 failed_apps[app['id']] = e
 963                 wikilog = str(e)
 964
 965             if options.wiki and wikilog:
 966                 try:
 967                     newpage = site.Pages[app['id'] + '/lastbuild']
 968                     txt = "Build completed at " + time.strftime("%Y-%m-%d %H:%M:%SZ", time.gmtime()) + "\n\n" + wikilog
 969                     newpage.save(txt, summary='Build log')
 970                 except:
 971                     logging.info("Error while attempting to publish build log")
 972
 973     for app in build_succeeded:
 974         logging.info("success: %s" % (app['id']))
 975
 976     if not options.verbose:
 977         for fa in failed_apps:
 978             logging.info("Build for app %s failed:\n%s" % (fa, failed_apps[fa]))
 979
 980     logging.info("Finished.")
 981     if len(build_succeeded) > 0:
 982         logging.info(str(len(build_succeeded)) + ' builds succeeded')
 983     if len(failed_apps) > 0:
 984         logging.info(str(len(failed_apps)) + ' builds failed')
 985
 986     sys.exit(0)
 987
 988 if __name__ == "__main__":
 989     main()
 990