compile.py

   1 # Copyright (C) 2009, Thomas Leonard
   2 # See the README file for details, or visit http://0install.net.
   3
   4 import tempfile, shutil, os, sys
   5 import ConfigParser
   6 from logging import info
   7 from zeroinstall.support import basedir
   8
   9 import support
  10
  11 class Compiler:
  12         def __init__(self, options, src_feed_name):
  13                 self.src_feed_name = src_feed_name
  14                 self.src_feed = support.load_feed(src_feed_name)
  15                 self.archive_dir_public_url = options.archive_dir_public_url
  16                 assert options.archive_dir_public_url
  17
  18                 self.config = ConfigParser.RawConfigParser()
  19
  20                 # Start with a default configuration
  21                 self.config.add_section('global')
  22                 self.config.set('global', 'builders', 'host')
  23
  24                 self.config.add_section('builder-host')
  25                 #self.config.set('builder-host', 'build', '0launch --not-before 0.10 http://0install.net/2007/interfaces/0release.xml --build-slave "$@"')
  26                 self.config.set('builder-host', 'build', '')
  27
  28                 self.src_impl = support.get_singleton_impl(self.src_feed)
  29                 if self.src_impl.arch and self.src_impl.arch.endswith('-src'):
  30                         path = basedir.load_first_config('0install.net', '0release', 'builders.conf')
  31                         if path:
  32                                 info("Loading configuration file '%s'", path)
  33                                 self.config.read(path)
  34                         else:
  35                                 info("No builders.conf configuration; will build a binary for this host only")
  36
  37                         if options.builders is not None:
  38                                 builders = options.builders
  39                         else:
  40                                 builders = self.config.get('global', 'builders').strip()
  41                         if builders:
  42                                 self.targets = [x.strip() for x in builders.split(',')]
  43                                 info("%d build targets configured: %s", len(self.targets), self.targets)
  44                         else:
  45                                 self.targets = []
  46                                 info("No builders set; no binaries will be built")
  47                 else:
  48                         self.targets = []
  49
  50         # We run the build in a sub-process. The idea is that the build may need to run
  51         # on a different machine.
  52         def build_binaries(self):
  53                 if not self.targets: return
  54
  55                 print "Source package, so generating binaries..."
  56
  57                 archive_file = support.get_archive_basename(self.src_impl)
  58
  59                 for target in self.targets:
  60                         start = self.get('builder-' + target, 'start', None)
  61                         command = self.config.get('builder-' + target, 'build')
  62                         stop = self.get('builder-' + target, 'stop', None)
  63
  64                         binary_feed = 'binary-' + target + '.xml'
  65                         if os.path.exists(binary_feed):
  66                                 print "Feed %s already exists; not rebuilding" % binary_feed
  67                         else:
  68                                 print "\nBuilding binary with builder '%s' ...\n" % target
  69
  70                                 if start: support.show_and_run(start, [])
  71                                 try:
  72                                         args = [os.path.basename(self.src_feed_name), archive_file, self.archive_dir_public_url, binary_feed + '.new']
  73                                         if not command:
  74                                                 assert target == 'host', 'Missing build command'
  75                                                 support.check_call([sys.executable, sys.argv[0], '--build-slave'] + args)
  76                                         else:
  77                                                 support.show_and_run(command, args)
  78                                 finally:
  79                                         if stop: support.show_and_run(stop, [])
  80
  81                                 bin_feed = support.load_feed(binary_feed + '.new')
  82                                 bin_impl = support.get_singleton_impl(bin_feed)
  83                                 bin_archive_file = support.get_archive_basename(bin_impl)
  84                                 bin_size = bin_impl.download_sources[0].size
  85
  86                                 assert os.path.exists(bin_archive_file), "Compiled binary '%s' not found!" % os.path.abspath(bin_archive_file)
  87                                 assert os.path.getsize(bin_archive_file) == bin_size, "Compiled binary '%s' has wrong size!" % os.path.abspath(bin_archive_file)
  88
  89                                 os.rename(binary_feed + '.new', binary_feed)
  90
  91         def get_binary_feeds(self):
  92                 return ['binary-%s.xml' % target for target in self.targets]
  93
  94         def get(self, section, option, default):
  95                 try:
  96                         return self.config.get(section, option)
  97                 except ConfigParser.NoOptionError:
  98                         return default
  99
 100 # This is the actual build process, running on the build machine
 101 def build_slave(src_feed, archive_file, archive_dir_public_url, target_feed):
 102         try:
 103                 COMPILE = [os.environ['0COMPILE']]
 104         except KeyError:
 105                 # (build slave has an old 0release)
 106                 COMPILE = ['0launch', '--not-before=0.30', 'http://0install.net/2006/interfaces/0compile.xml']
 107
 108         feed = support.load_feed(src_feed)
 109
 110         src_feed = os.path.abspath(src_feed)
 111         archive_file = os.path.abspath(archive_file)
 112         target_feed = os.path.abspath(target_feed)
 113
 114         impl, = feed.implementations.values()
 115
 116         tmpdir = tempfile.mkdtemp(prefix = '0release-')
 117         try:
 118                 os.chdir(tmpdir)
 119                 depdir = os.path.join(tmpdir, 'dependencies')
 120                 os.mkdir(depdir)
 121
 122                 support.unpack_tarball(archive_file)
 123                 os.rename(impl.download_sources[0].extract, os.path.join(depdir, impl.id))
 124
 125                 config = ConfigParser.RawConfigParser()
 126                 config.add_section('compile')
 127                 config.set('compile', 'download-base-url', archive_dir_public_url)
 128                 config.set('compile', 'version-modifier', '')
 129                 config.set('compile', 'interface', src_feed)
 130                 config.set('compile', 'selections', '')
 131                 config.set('compile', 'metadir', '0install')
 132                 stream = open(os.path.join(tmpdir, '0compile.properties'), 'w')
 133                 try:
 134                         config.write(stream)
 135                 finally:
 136                         stream.close()
 137
 138                 support.check_call(COMPILE + ['build'], cwd = tmpdir)
 139                 support.check_call(COMPILE + ['publish', '--target-feed', target_feed], cwd = tmpdir)
 140
 141                 # TODO: run unit-tests
 142
 143                 feed = support.load_feed(target_feed)
 144                 impl = support.get_singleton_impl(feed)
 145                 archive_file = support.get_archive_basename(impl)
 146
 147                 shutil.move(archive_file, os.path.join(os.path.dirname(target_feed), archive_file))
 148         except:
 149                 print "\nLeaving temporary directory %s for inspection...\n" % tmpdir
 150                 raise
 151         else:
 152                 shutil.rmtree(tmpdir)