build.py

   1 # Copyright (C) 2006, Thomas Leonard
   2 # See http://0install.net/0compile.html
   3
   4 import sys, os, __main__, time, shutil, glob, codecs, subprocess
   5 from os.path import join
   6 from logging import info
   7 from xml.dom import minidom, XMLNS_NAMESPACE
   8 from optparse import OptionParser
   9
  10 from support import *
  11
  12 # If we have to modify any pkg-config files, we put the new versions in $TMPDIR/PKG_CONFIG_OVERRIDES
  13 PKG_CONFIG_OVERRIDES = 'pkg-config-overrides'
  14
  15 def env(name, value):
  16         os.environ[name] = value
  17         print "%s=%s" % (name, value)
  18
  19 def do_env_binding(binding, path):
  20         env(binding.name, binding.get_value(path, os.environ.get(binding.name, None)))
  21
  22 def correct_for_64bit(base, rel_path):
  23         """If rel_path starts lib or usr/lib and doesn't exist, try with lib64 instead."""
  24         if os.path.exists(os.path.join(base, rel_path)):
  25                 return rel_path
  26
  27         if rel_path.startswith('lib/') or rel_path.startswith('usr/lib/'):
  28                 new_rel_path = rel_path.replace('lib/', 'lib64/', 1)
  29                 if os.path.exists(os.path.join(base, new_rel_path)):
  30                         return new_rel_path
  31
  32         return rel_path
  33
  34 def write_pc(name, lines):
  35         overrides_dir = os.path.join(os.environ['TMPDIR'], PKG_CONFIG_OVERRIDES)
  36         if not os.path.isdir(overrides_dir):
  37                 os.mkdir(overrides_dir)
  38         stream = open(os.path.join(overrides_dir, name), 'w')
  39         stream.write(''.join(lines))
  40         stream.close()
  41
  42 def do_pkg_config_binding(binding, impl):
  43         feed_name = impl.feed.split('/')[-1]
  44         path = lookup(impl.id)
  45         new_insert = correct_for_64bit(path, binding.insert)
  46         if new_insert != binding.insert:
  47                 print "PKG_CONFIG_PATH dir <%s>/%s not found; using %s instead" % (feed_name, binding.insert, new_insert)
  48                 binding = model.EnvironmentBinding(binding.name,
  49                                         new_insert,
  50                                         binding.default,
  51                                         binding.mode)
  52
  53         orig_path = os.path.join(path, binding.insert)
  54         if os.path.isdir(orig_path):
  55                 for pc in os.listdir(orig_path):
  56                         stream = open(os.path.join(orig_path, pc))
  57                         lines = stream.readlines()
  58                         stream.close()
  59                         for i, line in enumerate(lines):
  60                                 if '=' not in line: continue
  61                                 name, value = [x.strip() for x in line.split('=', 1)]
  62                                 if name == 'prefix' and value.startswith('/'):
  63                                         print "Absolute prefix=%s in %s; overriding..." % (value, feed_name)
  64                                         lines[i] = 'prefix=%s/%s\n' % (path, value[1:])
  65                                         write_pc(pc, lines)
  66                                         break
  67         do_env_binding(binding, path)
  68
  69 def fixup_generated_pkgconfig_file(pc_file):
  70         stream = open(pc_file)
  71         lines = stream.readlines()
  72         stream.close()
  73         for i, line in enumerate(lines):
  74                 if '=' not in line: continue
  75                 name, value = [x.strip() for x in line.split('=', 1)]
  76                 if name == 'prefix' and value.startswith('/'):
  77                         print "Absolute prefix=%s in %s; fixing..." % (value, pc_file)
  78                         rel_path = os.path.relpath(value, os.path.dirname(pc_file))     # Requires Python 2.6
  79                         lines[i] = 'prefix=${pcfiledir}/%s\n' % rel_path
  80                         write_pc(pc_file, lines)
  81                         break
  82
  83 # After doing a build, check that we didn't generate pkgconfig files with absolute paths
  84 # Rewrite if so
  85 def fixup_generated_pkgconfig_files():
  86         for root, dirs, files in os.walk(os.environ['DISTDIR']):
  87                 if os.path.basename(root) == 'pkgconfig':
  88                         for f in files:
  89                                 if f.endswith('.pc'):
  90                                         info("Checking generated pkgconfig file '%s'", f)
  91                                         fixup_generated_pkgconfig_file(os.path.join(root, f))
  92
  93 def do_build_internal(options, args):
  94         """build-internal"""
  95         # If a sandbox is being used, we're in it now.
  96         import getpass, socket, time
  97
  98         buildenv = BuildEnv()
  99         sels = buildenv.get_selections()
 100
 101         builddir = os.path.realpath('build')
 102         ensure_dir(buildenv.metadir)
 103
 104         build_env_xml = join(buildenv.metadir, 'build-environment.xml')
 105
 106         buildenv_doc = buildenv.get_selections().toDOM()
 107
 108         # Create build-environment.xml file
 109         root = buildenv_doc.documentElement
 110         info = buildenv_doc.createElementNS(XMLNS_0COMPILE, 'build-info')
 111         root.appendChild(info)
 112         info.setAttributeNS(None, 'time', time.strftime('%Y-%m-%d %H:%M').strip())
 113         info.setAttributeNS(None, 'host', socket.getfqdn())
 114         info.setAttributeNS(None, 'user', getpass.getuser())
 115         uname = os.uname()
 116         info.setAttributeNS(None, 'arch', '%s-%s' % (uname[0], uname[4]))
 117         stream = file(build_env_xml, 'w')
 118         buildenv_doc.writexml(stream, addindent="  ", newl="\n")
 119         stream.close()
 120
 121         # Create local binary interface file
 122         src_iface = iface_cache.get_interface(buildenv.interface)
 123         src_impl = buildenv.chosen_impl(buildenv.interface)
 124         write_sample_interface(buildenv, src_iface, src_impl)
 125
 126         # Check 0compile is new enough
 127         min_version = parse_version(src_impl.attrs.get(XMLNS_0COMPILE + ' min-version', None))
 128         if min_version and min_version > parse_version(__main__.version):
 129                 raise SafeException("%s-%s requires 0compile >= %s, but we are only version %s" %
 130                                 (src_iface.get_name(), src_impl.version, format_version(min_version), __main__.version))
 131
 132         # Create the patch
 133         patch_file = join(buildenv.metadir, 'from-%s.patch' % src_impl.version)
 134         if buildenv.user_srcdir:
 135                 # (ignore errors; will already be shown on stderr)
 136                 os.system("diff -urN '%s' src > %s" %
 137                         (buildenv.orig_srcdir.replace('\\', '\\\\').replace("'", "\\'"),
 138                          patch_file))
 139                 if os.path.getsize(patch_file) == 0:
 140                         os.unlink(patch_file)
 141         elif os.path.exists(patch_file):
 142                 os.unlink(patch_file)
 143
 144         env('BUILDDIR', builddir)
 145         env('DISTDIR', buildenv.distdir)
 146         env('SRCDIR', buildenv.user_srcdir or buildenv.orig_srcdir)
 147         os.chdir(builddir)
 148         print "cd", builddir
 149
 150         for needed_iface in sels.selections:
 151                 impl = buildenv.chosen_impl(needed_iface)
 152                 assert impl
 153                 for dep in impl.dependencies:
 154                         dep_iface = sels.selections[dep.interface]
 155                         for b in dep.bindings:
 156                                 if isinstance(b, EnvironmentBinding):
 157                                         dep_impl = buildenv.chosen_impl(dep.interface)
 158                                         if b.name == 'PKG_CONFIG_PATH':
 159                                                 do_pkg_config_binding(b, dep_impl)
 160                                         else:
 161                                                 do_env_binding(b, lookup(dep_impl.id))
 162
 163         mappings = {}
 164         for impl in sels.selections.values():
 165                 new_mappings = impl.attrs.get(XMLNS_0COMPILE + ' lib-mappings', '')
 166                 if new_mappings:
 167                         new_mappings = new_mappings.split(' ')
 168                         for mapping in new_mappings:
 169                                 assert ':' in mapping, "lib-mappings missing ':' in '%s' from '%s'" % (mapping, impl.feed)
 170                                 name, major_version = mapping.split(':', 1)
 171                                 assert '/' not in mapping, "lib-mappings '%s' contains a / in the version number (from '%s')!" % (mapping, impl.feed)
 172                                 mappings[name] = 'lib%s.so.%s' % (name, major_version)
 173                 impl_path = lookup(impl.id)
 174                 for libdirname in ['lib', 'usr/lib', 'lib64', 'usr/lib64']:
 175                         libdir = os.path.join(impl_path, libdirname)
 176                         if os.path.isdir(libdir):
 177                                 find_broken_version_symlinks(libdir, mappings)
 178
 179         if mappings:
 180                 set_up_mappings(mappings)
 181
 182         overrides_dir = os.path.join(os.environ['TMPDIR'], PKG_CONFIG_OVERRIDES)
 183         if os.path.isdir(overrides_dir):
 184                 add_overrides = model.EnvironmentBinding('PKG_CONFIG_PATH', PKG_CONFIG_OVERRIDES)
 185                 do_env_binding(add_overrides, os.environ['TMPDIR'])
 186
 187         # Some programs want to put temporary build files in the source directory.
 188         # Make a copy of the source if needed.
 189         dup_src_type = src_impl.attrs.get(XMLNS_0COMPILE + ' dup-src', None)
 190         if dup_src_type == 'true':
 191                 dup_src(shutil.copy2)
 192                 env('SRCDIR', builddir)
 193         elif dup_src_type:
 194                 raise Exception("Unknown dup-src value '%s'" % dup_src_type)
 195
 196         if options.shell:
 197                 spawn_and_check(find_in_path('sh'), [])
 198         else:
 199                 command = src_impl.attrs[XMLNS_0COMPILE + ' command']
 200
 201                 # Remove any existing log files
 202                 for log in ['build.log', 'build-success.log', 'build-failure.log']:
 203                         if os.path.exists(log):
 204                                 os.unlink(log)
 205
 206                 # Run the command, copying output to a new log
 207                 log = file('build.log', 'w')
 208                 try:
 209                         print >>log, "Build log for %s-%s" % (src_iface.get_name(),
 210                                                               src_impl.version)
 211                         print >>log, "\nBuilt using 0compile-%s" % __main__.version
 212                         print >>log, "\nBuild system: " + ', '.join(uname)
 213                         print >>log, "\n%s:\n" % ENV_FILE
 214                         shutil.copyfileobj(file("../" + ENV_FILE), log)
 215
 216                         log.write('\n')
 217
 218                         if os.path.exists(patch_file):
 219                                 print >>log, "\nPatched with:\n"
 220                                 shutil.copyfileobj(file(patch_file), log)
 221                                 log.write('\n')
 222
 223                         print "Executing: " + command
 224                         print >>log, "Executing: " + command
 225
 226                         # Tee the output to the console and to the log
 227                         child = subprocess.Popen(command, shell = True, stdout = subprocess.PIPE, stderr = subprocess.STDOUT)
 228                         while True:
 229                                 data = os.read(child.stdout.fileno(), 100)
 230                                 if not data: break
 231                                 sys.stdout.write(data)
 232                                 log.write(data)
 233                         status = child.wait()
 234                         failure = None
 235                         if status == 0:
 236                                 print >>log, "Build successful"
 237                                 fixup_generated_pkgconfig_files()
 238                         elif status > 0:
 239                                 failure = "Build failed with exit code %d" % status
 240                         else:
 241                                 failure = "Build failure: exited due to signal %d" % (-status)
 242                         if failure:
 243                                 print >>log, failure
 244                                 os.rename('build.log', 'build-failure.log')
 245                                 raise SafeException("Command '%s': %s" % (command, failure))
 246                         else:
 247                                 os.rename('build.log', 'build-success.log')
 248                 finally:
 249                         log.close()
 250
 251 def do_build(args):
 252         """build [ --no-sandbox ] [ --shell | --force | --clean ]"""
 253         buildenv = BuildEnv()
 254         sels = buildenv.get_selections()
 255
 256         parser = OptionParser(usage="usage: %prog build [options]")
 257
 258         parser.add_option('', "--no-sandbox", help="disable use of sandboxing", action='store_true')
 259         parser.add_option("-s", "--shell", help="run a shell instead of building", action='store_true')
 260         parser.add_option("-c", "--clean", help="remove the build directories", action='store_true')
 261         parser.add_option("-f", "--force", help="build even if dependencies have changed", action='store_true')
 262
 263         parser.disable_interspersed_args()
 264
 265         (options, args2) = parser.parse_args(args)
 266
 267         builddir = os.path.realpath('build')
 268
 269         changes = buildenv.get_build_changes()
 270         if changes:
 271                 if not (options.force or options.clean):
 272                         raise SafeException("Build dependencies have changed:\n" +
 273                                         '\n'.join(changes) + "\n\n" +
 274                                         "To build anyway, use: 0compile build --force\n" +
 275                                         "To do a clean build:  0compile build --clean")
 276                 if not options.no_sandbox:
 277                         print "Build dependencies have changed:\n" + '\n'.join(changes)
 278
 279         ensure_dir(builddir, options.clean)
 280         ensure_dir(buildenv.distdir, options.clean)
 281
 282         if options.no_sandbox:
 283                 return do_build_internal(options, args2)
 284
 285         tmpdir = tempfile.mkdtemp(prefix = '0compile-')
 286         try:
 287                 my_dir = os.path.dirname(__file__)
 288                 readable = ['.', my_dir]
 289                 writable = ['build', buildenv.distdir, tmpdir]
 290                 env('TMPDIR', tmpdir)
 291
 292                 for selection in sels.selections.values():
 293                         readable.append(lookup(selection.id))
 294
 295                 options = []
 296                 if __main__.options.verbose:
 297                         options.append('--verbose')
 298
 299                 readable.append('/etc') # /etc/ld.*
 300
 301                 spawn_maybe_sandboxed(readable, writable, tmpdir, sys.executable, [sys.argv[0]] + options + ['build', '--no-sandbox'] + args)
 302         finally:
 303                 info("Deleting temporary directory '%s'" % tmpdir)
 304                 shutil.rmtree(tmpdir)
 305
 306 def write_sample_interface(buildenv, iface, src_impl):
 307         path = buildenv.local_iface_file
 308         target_arch = buildenv.target_arch
 309
 310         impl = minidom.getDOMImplementation()
 311
 312         XMLNS_IFACE = namespaces.XMLNS_IFACE
 313
 314         doc = impl.createDocument(XMLNS_IFACE, "interface", None)
 315
 316         root = doc.documentElement
 317         root.setAttributeNS(XMLNS_NAMESPACE, 'xmlns', XMLNS_IFACE)
 318
 319         def addSimple(parent, name, text = None):
 320                 elem = doc.createElementNS(XMLNS_IFACE, name)
 321
 322                 parent.appendChild(doc.createTextNode('\n' + '  ' * (1 + depth(parent))))
 323                 parent.appendChild(elem)
 324                 if text:
 325                         elem.appendChild(doc.createTextNode(text))
 326                 return elem
 327
 328         def close(element):
 329                 element.appendChild(doc.createTextNode('\n' + '  ' * depth(element)))
 330
 331         addSimple(root, 'name', iface.name)
 332         addSimple(root, 'summary', iface.summary)
 333         addSimple(root, 'description', iface.description)
 334         feed_for = addSimple(root, 'feed-for')
 335
 336         uri = iface.uri
 337         if uri.startswith('/'):
 338                 print "Note: source %s is a local feed" % iface.uri
 339                 for feed_uri in iface.feed_for or []:
 340                         uri = feed_uri
 341                         print "Will use <feed-for interface='%s'> instead..." % uri
 342                         break
 343                 else:
 344                         master_feed = minidom.parse(uri).documentElement
 345                         if master_feed.hasAttribute('uri'):
 346                                 uri = master_feed.getAttribute('uri')
 347                                 print "Will use <feed-for interface='%s'> instead..." % uri
 348
 349         feed_for.setAttributeNS(None, 'interface', uri)
 350
 351         group = addSimple(root, 'group')
 352         main = src_impl.attrs.get(XMLNS_0COMPILE + ' binary-main', None)
 353         if main:
 354                 group.setAttributeNS(None, 'main', main)
 355
 356         lib_mappings = src_impl.attrs.get(XMLNS_0COMPILE + ' binary-lib-mappings', None)
 357         if lib_mappings:
 358                 root.setAttributeNS(XMLNS_NAMESPACE, 'xmlns:compile', XMLNS_0COMPILE)
 359                 group.setAttributeNS(XMLNS_0COMPILE, 'compile:lib-mappings', lib_mappings)
 360
 361         for d in src_impl.dependencies:
 362                 # 0launch < 0.32 messed up the namespace...
 363                 if parse_bool(d.metadata.get('include-binary', 'false')) or \
 364                    parse_bool(d.metadata.get(XMLNS_0COMPILE + ' include-binary', 'false')):
 365                         requires = addSimple(group, 'requires')
 366                         requires.setAttributeNS(None, 'interface', d.interface)
 367                         for b in d.bindings:
 368                                 if isinstance(b, model.EnvironmentBinding):
 369                                         env_elem = addSimple(requires, 'environment')
 370                                         env_elem.setAttributeNS(None, 'name', b.name)
 371                                         env_elem.setAttributeNS(None, 'insert', b.insert)
 372                                         if b.default:
 373                                                 env_elem.setAttributeNS(None, 'default', b.default)
 374                                 else:
 375                                         raise Exception('Unknown binding type ' + b)
 376                         close(requires)
 377
 378         group.setAttributeNS(None, 'arch', target_arch)
 379         impl_elem = addSimple(group, 'implementation')
 380         impl_elem.setAttributeNS(None, 'version', src_impl.version)
 381
 382         version_modifier = buildenv.version_modifier
 383         if version_modifier:
 384                 impl_elem.setAttributeNS(None, 'version-modifier', version_modifier)
 385
 386         impl_elem.setAttributeNS(None, 'id', '..')
 387         impl_elem.setAttributeNS(None, 'released', time.strftime('%Y-%m-%d'))
 388         close(group)
 389         close(root)
 390
 391         stream = codecs.open(path, 'w', encoding = 'utf-8')
 392         try:
 393                 doc.writexml(stream)
 394         finally:
 395                 stream.close()
 396
 397 def find_broken_version_symlinks(libdir, mappings):
 398         """libdir may be a legacy -devel package containing lib* symlinks whose
 399         targets would be provided by the corresponding runtime package. If so,
 400         create fixed symlinks under $TMPDIR with the real location."""
 401         for x in os.listdir(libdir):
 402                 if x.startswith('lib') and x.endswith('.so'):
 403                         path = os.path.join(libdir, x)
 404                         if os.path.islink(path):
 405                                 target = os.readlink(path)
 406                                 if '/' not in target and not os.path.exists(os.path.join(libdir, target)):
 407                                         print "Broken link %s -> %s; will relocate..." % (x, target)
 408                                         mappings[x[3:-3]] = target
 409
 410 def set_up_mappings(mappings):
 411         """Create a temporary directory with symlinks for each of the library mappings."""
 412         libdirs = []
 413         for d in os.environ.get('LD_LIBRARY_PATH', '').split(':'):
 414                 if d: libdirs.append(d)
 415         libdirs += ['/lib', '/usr/lib']
 416
 417         def add_ldconf(config_file):
 418                 if not os.path.isfile(config_file):
 419                         return
 420                 for line in file(config_file):
 421                         d = line.strip()
 422                         if d.startswith('include '):
 423                                 glob_pattern = d.split(' ', 1)[1]
 424                                 for conf in glob.glob(glob_pattern):
 425                                         add_ldconf(conf)
 426                         elif d and not d.startswith('#'):
 427                                 libdirs.append(d)
 428         add_ldconf('/etc/ld.so.conf')
 429
 430         def find_library(name, wanted):
 431                 # Takes a short-name and target name of a library and returns
 432                 # the full path of the library.
 433                 for d in libdirs:
 434                         path = os.path.join(d, wanted)
 435                         if os.path.exists(path):
 436                                 return path
 437                 print "WARNING: library '%s' not found (searched '%s')!" % (wanted, libdirs)
 438                 return None
 439
 440         mappings_dir = os.path.join(os.environ['TMPDIR'], 'lib-mappings')
 441         os.mkdir(mappings_dir)
 442
 443         old_path = os.environ.get('LIBRARY_PATH', '')
 444         if old_path: old_path = ':' + old_path
 445         os.environ['LIBRARY_PATH'] = mappings_dir + old_path
 446
 447         for name, wanted in mappings.items():
 448                 target = find_library(name, wanted)
 449                 if target:
 450                         print "Adding mapping lib%s.so -> %s" % (name, target)
 451                         os.symlink(target, os.path.join(mappings_dir, 'lib' + name + '.so'))
 452
 453 def dup_src(fn):
 454         srcdir = os.environ['SRCDIR'] + '/'
 455         for root, dirs, files in os.walk(srcdir):
 456                 assert root.startswith(srcdir)
 457                 reldir = root[len(srcdir):]
 458                 for f in files:
 459                         target = os.path.join(reldir, f)
 460                         #print "Copy %s -> %s" % (os.path.join(root, f), target)
 461                         if os.path.exists(target):
 462                                 os.unlink(target)
 463                         fn(os.path.join(root, f), target)
 464                 for d in dirs:
 465                         target = os.path.join(reldir, d)
 466                         if not os.path.isdir(target):
 467                                 os.mkdir(target)
 468
 469 __main__.commands.append(do_build)