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