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         jobs = multiprocessing.cpu_count()
 490         ndkbuild = os.path.join(config['ndk_path'], "ndk-build")
 491         cmd = [ndkbuild, "-j"+str(jobs)]
 492         for d in jni_components:
 493             logging.info("Building native code in '%s'" % d)
 494             manifest = root_dir + '/' + d + '/AndroidManifest.xml'
 495             if os.path.exists(manifest):
 496                 # Read and write the whole AM.xml to fix newlines and avoid
 497                 # the ndk r8c or later 'wordlist' errors. The outcome of this
 498                 # under gnu/linux is the same as when using tools like
 499                 # dos2unix, but the native python way is faster and will
 500                 # work in non-unix systems.
 501                 manifest_text = open(manifest, 'U').read()
 502                 open(manifest, 'w').write(manifest_text)
 503                 # In case the AM.xml read was big, free the memory
 504                 del manifest_text
 505             p = FDroidPopen(cmd, cwd=os.path.join(root_dir,d))
 506             if p.returncode != 0:
 507                 raise BuildException("NDK build failed for %s:%s" % (app['id'], thisbuild['version']), p.stdout)
 508
 509     p = None
 510     # Build the release...
 511     if thisbuild['type'] == 'maven':
 512         logging.info("Building Maven project...")
 513
 514         if '@' in thisbuild['maven']:
 515             maven_dir = os.path.join(root_dir, thisbuild['maven'].split('@',1)[1])
 516         else:
 517             maven_dir = root_dir
 518
 519         mvncmd = [config['mvn3'], '-Dandroid.sdk.path=' + config['sdk_path'],
 520                 '-Dandroid.sign.debug=false', '-Dmaven.test.skip=true',
 521                 '-Dandroid.release=true', 'package']
 522         if 'target' in thisbuild:
 523             target = thisbuild["target"].split('-')[1]
 524             FDroidPopen(['sed', '-i',
 525                     's@<platform>[0-9]*</platform>@<platform>'+target+'</platform>@g',
 526                     'pom.xml'], cwd=root_dir)
 527             if '@' in thisbuild['maven']:
 528                 FDroidPopen(['sed', '-i',
 529                         's@<platform>[0-9]*</platform>@<platform>'+target+'</platform>@g',
 530                         'pom.xml'], cwd=maven_dir)
 531
 532         if 'mvnflags' in thisbuild:
 533             mvncmd += thisbuild['mvnflags']
 534
 535         p = FDroidPopen(mvncmd, cwd=maven_dir)
 536
 537         bindir = os.path.join(root_dir, 'target')
 538
 539     elif thisbuild['type'] == 'kivy':
 540         logging.info("Building Kivy project...")
 541
 542         spec = os.path.join(root_dir, 'buildozer.spec')
 543         if not os.path.exists(spec):
 544             raise BuildException("Expected to find buildozer-compatible spec at {0}"
 545                     .format(spec))
 546
 547         defaults = {'orientation': 'landscape', 'icon': '',
 548                 'permissions': '', 'android.api': "18"}
 549         bconfig = ConfigParser(defaults, allow_no_value=True)
 550         bconfig.read(spec)
 551
 552         distdir = 'python-for-android/dist/fdroid'
 553         if os.path.exists(distdir):
 554             shutil.rmtree(distdir)
 555
 556         modules = bconfig.get('app', 'requirements').split(',')
 557
 558         cmd = 'ANDROIDSDK=' + config['sdk_path']
 559         cmd += ' ANDROIDNDK=' + config['ndk_path']
 560         cmd += ' ANDROIDNDKVER=r9'
 561         cmd += ' ANDROIDAPI=' + str(bconfig.get('app', 'android.api'))
 562         cmd += ' VIRTUALENV=virtualenv'
 563         cmd += ' ./distribute.sh'
 564         cmd += ' -m ' + "'" + ' '.join(modules) + "'"
 565         cmd += ' -d fdroid'
 566         p = FDroidPopen(cmd, cwd='python-for-android', shell=True)
 567         if p.returncode != 0:
 568             raise BuildException("Distribute build failed")
 569
 570         cid = bconfig.get('app', 'package.domain') + '.' + bconfig.get('app', 'package.name')
 571         if cid != app['id']:
 572             raise BuildException("Package ID mismatch between metadata and spec")
 573
 574         orientation = bconfig.get('app', 'orientation', 'landscape')
 575         if orientation == 'all':
 576             orientation = 'sensor'
 577
 578         cmd = ['./build.py'
 579                 '--dir', root_dir,
 580                 '--name', bconfig.get('app', 'title'),
 581                 '--package', app['id'],
 582                 '--version', bconfig.get('app', 'version'),
 583                 '--orientation', orientation,
 584                 ]
 585
 586         perms = bconfig.get('app', 'permissions')
 587         for perm in perms.split(','):
 588             cmd.extend(['--permission', perm])
 589
 590         if config.get('app', 'fullscreen') == 0:
 591             cmd.append('--window')
 592
 593         icon = bconfig.get('app', 'icon.filename')
 594         if icon:
 595             cmd.extend(['--icon', os.path.join(root_dir, icon)])
 596
 597         cmd.append('release')
 598         p = FDroidPopen(cmd, cwd=distdir)
 599
 600     elif thisbuild['type'] == 'gradle':
 601         logging.info("Building Gradle project...")
 602         if '@' in thisbuild['gradle']:
 603             flavours = thisbuild['gradle'].split('@')[0].split(',')
 604             gradle_dir = thisbuild['gradle'].split('@')[1]
 605             gradle_dir = os.path.join(root_dir, gradle_dir)
 606         else:
 607             flavours = thisbuild['gradle'].split(',')
 608             gradle_dir = root_dir
 609
 610         if len(flavours) == 1 and flavours[0] in ['main', 'yes', '']:
 611             flavours[0] = ''
 612
 613         commands = [config['gradle']]
 614         if 'preassemble' in thisbuild:
 615             commands += thisbuild['preassemble'].split()
 616         flavours_cmd = ''.join(flavours)
 617         flavours_cmd = flavours_cmd[0].upper() + flavours_cmd[1:]
 618         commands += ['assemble'+flavours_cmd+'Release']
 619
 620         p = FDroidPopen(commands, cwd=gradle_dir)
 621
 622     elif thisbuild['type'] == 'ant':
 623         logging.info("Building Ant project...")
 624         cmd = ['ant']
 625         if 'antcommand' in thisbuild:
 626             cmd += [thisbuild['antcommand']]
 627         else:
 628             cmd += ['release']
 629         p = FDroidPopen(cmd, cwd=root_dir)
 630
 631         bindir = os.path.join(root_dir, 'bin')
 632
 633     if p is not None and p.returncode != 0:
 634         raise BuildException("Build failed for %s:%s" % (app['id'], thisbuild['version']), p.stdout)
 635     logging.info("Successfully built version " + thisbuild['version'] + ' of ' + app['id'])
 636
 637     if thisbuild['type'] == 'maven':
 638         stdout_apk = '\n'.join([
 639             line for line in p.stdout.splitlines() if any(a in line for a in ('.apk','.ap_'))])
 640         m = re.match(r".*^\[INFO\] .*apkbuilder.*/([^/]*)\.apk",
 641                 stdout_apk, re.S|re.M)
 642         if not m:
 643             m = re.match(r".*^\[INFO\] Creating additional unsigned apk file .*/([^/]+)\.apk[^l]",
 644                     stdout_apk, re.S|re.M)
 645         if not m:
 646             m = re.match(r'.*^\[INFO\] [^$]*aapt \[package,[^$]*' + bindir + r'/([^/]+)\.ap[_k][,\]]',
 647                     stdout_apk, re.S|re.M)
 648         if not m:
 649             raise BuildException('Failed to find output')
 650         src = m.group(1)
 651         src = os.path.join(bindir, src) + '.apk'
 652     elif thisbuild['type'] == 'kivy':
 653         src = 'python-for-android/dist/default/bin/{0}-{1}-release.apk'.format(
 654                 bconfig.get('app', 'title'), bconfig.get('app', 'version'))
 655     elif thisbuild['type'] == 'gradle':
 656         dd = build_dir
 657         if 'subdir' in thisbuild:
 658             dd = os.path.join(dd, thisbuild['subdir'])
 659         if len(flavours) == 1 and flavours[0] == '':
 660             name = '-'.join([os.path.basename(dd), 'release', 'unsigned'])
 661         else:
 662             name = '-'.join([os.path.basename(dd), '-'.join(flavours), 'release', 'unsigned'])
 663         src = os.path.join(dd, 'build', 'apk', name+'.apk')
 664     elif thisbuild['type'] == 'ant':
 665         stdout_apk = '\n'.join([
 666             line for line in p.stdout.splitlines() if '.apk' in line])
 667         src = re.match(r".*^.*Creating (.+) for release.*$.*", stdout_apk,
 668             re.S|re.M).group(1)
 669         src = os.path.join(bindir, src)
 670     elif thisbuild['type'] == 'raw':
 671         src = os.path.join(root_dir, thisbuild['output'])
 672         src = os.path.normpath(src)
 673
 674     # Make sure it's not debuggable...
 675     if common.isApkDebuggable(src, config):
 676         raise BuildException("APK is debuggable")
 677
 678     # By way of a sanity check, make sure the version and version
 679     # code in our new apk match what we expect...
 680     logging.info("Checking " + src)
 681     if not os.path.exists(src):
 682         raise BuildException("Unsigned apk is not at expected location of " + src)
 683
 684     p = SilentPopen([os.path.join(config['sdk_path'],
 685         'build-tools', config['build_tools'], 'aapt'),
 686         'dump', 'badging', src])
 687
 688     vercode = None
 689     version = None
 690     foundid = None
 691     for line in p.stdout.splitlines():
 692         if line.startswith("package:"):
 693             pat = re.compile(".*name='([a-zA-Z0-9._]*)'.*")
 694             m = pat.match(line)
 695             if m:
 696                 foundid = m.group(1)
 697             pat = re.compile(".*versionCode='([0-9]*)'.*")
 698             m = pat.match(line)
 699             if m:
 700                 vercode = m.group(1)
 701             pat = re.compile(".*versionName='([^']*)'.*")
 702             m = pat.match(line)
 703             if m:
 704                 version = m.group(1)
 705
 706     if thisbuild['novcheck']:
 707         vercode = thisbuild['vercode']
 708         version = thisbuild['version']
 709     if not version or not vercode:
 710         raise BuildException("Could not find version information in build in output")
 711     if not foundid:
 712         raise BuildException("Could not find package ID in output")
 713     if foundid != app['id']:
 714         raise BuildException("Wrong package ID - build " + foundid + " but expected " + app['id'])
 715
 716     # Some apps (e.g. Timeriffic) have had the bonkers idea of
 717     # including the entire changelog in the version number. Remove
 718     # it so we can compare. (TODO: might be better to remove it
 719     # before we compile, in fact)
 720     index = version.find(" //")
 721     if index != -1:
 722         version = version[:index]
 723
 724     if (version != thisbuild['version'] or
 725             vercode != thisbuild['vercode']):
 726         raise BuildException(("Unexpected version/version code in output;"
 727                              " APK: '%s' / '%s', "
 728                              " Expected: '%s' / '%s'")
 729                              % (version, str(vercode), thisbuild['version'], str(thisbuild['vercode']))
 730                             )
 731
 732     # Copy the unsigned apk to our destination directory for further
 733     # processing (by publish.py)...
 734     dest = os.path.join(output_dir, common.getapkname(app,thisbuild))
 735     shutil.copyfile(src, dest)
 736
 737     # Move the source tarball into the output directory...
 738     if output_dir != tmp_dir and not options.notarball:
 739         shutil.move(os.path.join(tmp_dir, tarname),
 740             os.path.join(output_dir, tarname))
 741
 742
 743 def trybuild(app, thisbuild, build_dir, output_dir, also_check_dir, srclib_dir, extlib_dir,
 744         tmp_dir, repo_dir, vcs, test, server, force, onserver):
 745     """
 746     Build a particular version of an application, if it needs building.
 747
 748     :param output_dir: The directory where the build output will go. Usually
 749        this is the 'unsigned' directory.
 750     :param repo_dir: The repo directory - used for checking if the build is
 751        necessary.
 752     :paaram also_check_dir: An additional location for checking if the build
 753        is necessary (usually the archive repo)
 754     :param test: True if building in test mode, in which case the build will
 755        always happen, even if the output already exists. In test mode, the
 756        output directory should be a temporary location, not any of the real
 757        ones.
 758
 759     :returns: True if the build was done, False if it wasn't necessary.
 760     """
 761
 762     dest_apk = common.getapkname(app, thisbuild)
 763
 764     dest = os.path.join(output_dir, dest_apk)
 765     dest_repo = os.path.join(repo_dir, dest_apk)
 766
 767     if not test:
 768         if os.path.exists(dest) or os.path.exists(dest_repo):
 769             return False
 770
 771         if also_check_dir:
 772             dest_also = os.path.join(also_check_dir, dest_apk)
 773             if os.path.exists(dest_also):
 774                 return False
 775
 776     if 'disable' in thisbuild:
 777         return False
 778
 779     logging.info("Building version " + thisbuild['version'] + ' of ' + app['id'])
 780
 781     if server:
 782         # When using server mode, still keep a local cache of the repo, by
 783         # grabbing the source now.
 784         vcs.gotorevision(thisbuild['commit'])
 785
 786         build_server(app, thisbuild, vcs, build_dir, output_dir, force)
 787     else:
 788         build_local(app, thisbuild, vcs, build_dir, output_dir, srclib_dir, extlib_dir, tmp_dir, force, onserver)
 789     return True
 790
 791
 792 def parse_commandline():
 793     """Parse the command line. Returns options, args."""
 794
 795     parser = OptionParser(usage="Usage: %prog [options] [APPID[:VERCODE] [APPID[:VERCODE] ...]]")
 796     parser.add_option("-v", "--verbose", action="store_true", default=False,
 797                       help="Spew out even more information than normal")
 798     parser.add_option("-q", "--quiet", action="store_true", default=False,
 799                       help="Restrict output to warnings and errors")
 800     parser.add_option("-l", "--latest", action="store_true", default=False,
 801                       help="Build only the latest version of each package")
 802     parser.add_option("-s", "--stop", action="store_true", default=False,
 803                       help="Make the build stop on exceptions")
 804     parser.add_option("-t", "--test", action="store_true", default=False,
 805                       help="Test mode - put output in the tmp directory only, and always build, even if the output already exists.")
 806     parser.add_option("--server", action="store_true", default=False,
 807                       help="Use build server")
 808     parser.add_option("--resetserver", action="store_true", default=False,
 809                       help="Reset and create a brand new build server, even if the existing one appears to be ok.")
 810     parser.add_option("--on-server", dest="onserver", action="store_true", default=False,
 811                       help="Specify that we're running on the build server")
 812     parser.add_option("--skip-scan", dest="skipscan", action="store_true", default=False,
 813                       help="Skip scanning the source code for binaries and other problems")
 814     parser.add_option("--no-tarball", dest="notarball", action="store_true", default=False,
 815                       help="Don't create a source tarball, useful when testing a build")
 816     parser.add_option("-f", "--force", action="store_true", default=False,
 817                       help="Force build of disabled apps, and carries on regardless of scan problems. Only allowed in test mode.")
 818     parser.add_option("-a", "--all", action="store_true", default=False,
 819                       help="Build all applications available")
 820     parser.add_option("-w", "--wiki", default=False, action="store_true",
 821                       help="Update the wiki")
 822     options, args = parser.parse_args()
 823
 824     # Force --stop with --on-server to get correct exit code
 825     if options.onserver:
 826         options.stop = True
 827
 828     if options.force and not options.test:
 829         raise OptionError("Force is only allowed in test mode", "force")
 830
 831     return options, args
 832
 833 options = None
 834 config = None
 835
 836 def main():
 837
 838     global options, config
 839
 840     options, args = parse_commandline()
 841     if not args and not options.all:
 842         raise OptionError("If you really want to build all the apps, use --all", "all")
 843
 844     config = common.read_config(options)
 845
 846     if config['build_server_always']:
 847         options.server = True
 848     if options.resetserver and not options.server:
 849         raise OptionError("Using --resetserver without --server makes no sense", "resetserver")
 850
 851     log_dir = 'logs'
 852     if not os.path.isdir(log_dir):
 853         logging.info("Creating log directory")
 854         os.makedirs(log_dir)
 855
 856     tmp_dir = 'tmp'
 857     if not os.path.isdir(tmp_dir):
 858         logging.info("Creating temporary directory")
 859         os.makedirs(tmp_dir)
 860
 861     if options.test:
 862         output_dir = tmp_dir
 863     else:
 864         output_dir = 'unsigned'
 865         if not os.path.isdir(output_dir):
 866             logging.info("Creating output directory")
 867             os.makedirs(output_dir)
 868
 869     if config['archive_older'] != 0:
 870         also_check_dir = 'archive'
 871     else:
 872         also_check_dir = None
 873
 874     repo_dir = 'repo'
 875
 876     build_dir = 'build'
 877     if not os.path.isdir(build_dir):
 878         logging.info("Creating build directory")
 879         os.makedirs(build_dir)
 880     srclib_dir = os.path.join(build_dir, 'srclib')
 881     extlib_dir = os.path.join(build_dir, 'extlib')
 882
 883     # Get all apps...
 884     allapps = metadata.read_metadata(xref=not options.onserver)
 885
 886     apps = common.read_app_args(args, allapps, True)
 887     apps = [app for app in apps if (options.force or not app['Disabled']) and
 888             len(app['Repo Type']) > 0 and len(app['builds']) > 0]
 889
 890     if len(apps) == 0:
 891         raise Exception("No apps to process.")
 892
 893     if options.latest:
 894         for app in apps:
 895             for build in reversed(app['builds']):
 896                 if 'disable' in build:
 897                     continue
 898                 app['builds'] = [ build ]
 899                 break
 900
 901     if options.wiki:
 902         import mwclient
 903         site = mwclient.Site((config['wiki_protocol'], config['wiki_server']),
 904                 path=config['wiki_path'])
 905         site.login(config['wiki_user'], config['wiki_password'])
 906
 907     # Build applications...
 908     failed_apps = {}
 909     build_succeeded = []
 910     for app in apps:
 911
 912         first = True
 913
 914         for thisbuild in app['builds']:
 915             wikilog = None
 916             try:
 917
 918                 # For the first build of a particular app, we need to set up
 919                 # the source repo. We can reuse it on subsequent builds, if
 920                 # there are any.
 921                 if first:
 922                     if app['Repo Type'] == 'srclib':
 923                         build_dir = os.path.join('build', 'srclib', app['Repo'])
 924                     else:
 925                         build_dir = os.path.join('build', app['id'])
 926
 927                     # Set up vcs interface and make sure we have the latest code...
 928                     logging.debug("Getting {0} vcs interface for {1}".format(
 929                             app['Repo Type'], app['Repo']))
 930                     vcs = common.getvcs(app['Repo Type'], app['Repo'], build_dir)
 931
 932                     first = False
 933
 934                 logging.debug("Checking " + thisbuild['version'])
 935                 if trybuild(app, thisbuild, build_dir, output_dir, also_check_dir,
 936                         srclib_dir, extlib_dir, tmp_dir, repo_dir, vcs, options.test,
 937                         options.server, options.force, options.onserver):
 938                     build_succeeded.append(app)
 939                     wikilog = "Build succeeded"
 940             except BuildException as be:
 941                 logfile = open(os.path.join(log_dir, app['id'] + '.log'), 'a+')
 942                 logfile.write(str(be))
 943                 logfile.close()
 944                 print("Could not build app %s due to BuildException: %s" % (app['id'], be))
 945                 if options.stop:
 946                     sys.exit(1)
 947                 failed_apps[app['id']] = be
 948                 wikilog = be.get_wikitext()
 949             except VCSException as vcse:
 950                 print("VCS error while building app %s: %s" % (app['id'], vcse))
 951                 if options.stop:
 952                     sys.exit(1)
 953                 failed_apps[app['id']] = vcse
 954                 wikilog = str(vcse)
 955             except Exception as e:
 956                 print("Could not build app %s due to unknown error: %s" % (app['id'], traceback.format_exc()))
 957                 if options.stop:
 958                     sys.exit(1)
 959                 failed_apps[app['id']] = e
 960                 wikilog = str(e)
 961
 962             if options.wiki and wikilog:
 963                 try:
 964                     newpage = site.Pages[app['id'] + '/lastbuild']
 965                     txt = "Build completed at " + time.strftime("%Y-%m-%d %H:%M:%SZ", time.gmtime()) + "\n\n" + wikilog
 966                     newpage.save(txt, summary='Build log')
 967                 except:
 968                     logging.info("Error while attempting to publish build log")
 969
 970     for app in build_succeeded:
 971         logging.info("success: %s" % (app['id']))
 972
 973     if not options.verbose:
 974         for fa in failed_apps:
 975             logging.info("Build for app %s failed:\n%s" % (fa, failed_apps[fa]))
 976
 977     logging.info("Finished.")
 978     if len(build_succeeded) > 0:
 979         logging.info(str(len(build_succeeded)) + ' builds succeeded')
 980     if len(failed_apps) > 0:
 981         logging.info(str(len(failed_apps)) + ' builds failed')
 982
 983     sys.exit(0)
 984
 985 if __name__ == "__main__":
 986     main()
 987