support.py

   1 # Copyright (C) 2006, Thomas Leonard
   2 # See http://0install.net/0compile.html
   3
   4 import os, sys, shutil, traceback
   5 import subprocess
   6 from os.path import join
   7 from logging import info
   8 import ConfigParser
   9
  10 from zeroinstall.injector import model, selections, qdom
  11 from zeroinstall.injector.arch import canonicalize_os, canonicalize_machine
  12
  13 from zeroinstall.injector.iface_cache import iface_cache
  14 from zeroinstall import SafeException
  15 from zeroinstall.zerostore import Store, NotStored
  16
  17 def _(x): return x
  18
  19 ENV_FILE = '0compile.properties'
  20 XMLNS_0COMPILE = 'http://zero-install.sourceforge.net/2006/namespaces/0compile'
  21
  22 zeroinstall_dir = os.environ.get('0COMPILE_ZEROINSTALL', None)
  23 if zeroinstall_dir:
  24         launch_prog = [os.path.join(zeroinstall_dir, '0launch')]
  25 else:
  26         launch_prog = ['0launch']
  27
  28 if os.path.isdir('dependencies'):
  29         dep_dir = os.path.realpath('dependencies')
  30         iface_cache.stores.stores.append(Store(dep_dir))
  31         launch_prog += ['--with-store', dep_dir]
  32
  33 class NoImpl:
  34         id = "none"
  35         version = "none"
  36 no_impl = NoImpl()
  37
  38 def is_package_impl(impl):
  39         return impl.id.startswith("package:")
  40
  41 def lookup(impl_or_sel):
  42         id = impl_or_sel.id
  43         if id.startswith('/'):
  44                 if os.path.isdir(id):
  45                         return id
  46                 raise SafeException("Directory '%s' no longer exists. Try '0compile setup'" % id)
  47         try:
  48                 return iface_cache.stores.lookup_any(impl_or_sel.digests)
  49         except NotStored, ex:
  50                 raise NotStored(str(ex) + "\nHint: try '0compile setup'")
  51
  52 def ensure_dir(d, clean = False):
  53         if os.path.isdir(d):
  54                 if clean:
  55                         print "Removing", d
  56                         shutil.rmtree(d)
  57                 else:
  58                         return
  59         if os.path.exists(d):
  60                 raise SafeException("'%s' exists, but is not a directory!" % d)
  61         os.mkdir(d)
  62
  63 def find_in_path(prog):
  64         for d in os.environ['PATH'].split(':'):
  65                 path = os.path.join(d, prog)
  66                 if os.path.isfile(path):
  67                         return path
  68         return None
  69
  70 def spawn_and_check(prog, args):
  71         status = os.spawnv(os.P_WAIT, prog, [prog] + args)
  72         if status > 0:
  73                 raise SafeException("Program '%s' failed with exit code %d" % (prog, status))
  74         elif status < 0:
  75                 raise SafeException("Program '%s' failed with signal %d" % (prog, -status))
  76
  77 def wait_for_child(child):
  78         """Wait for child to exit and reap it. Throw an exception if it doesn't return success."""
  79         pid, status = os.waitpid(child, 0)
  80         assert pid == child
  81         if os.WIFEXITED(status):
  82                 exit_code = os.WEXITSTATUS(status)
  83                 if exit_code == 0:
  84                         return
  85                 else:
  86                         raise SafeException('Command failed with exit status %d' % exit_code)
  87         else:
  88                 raise SafeException('Command failed with signal %d' % os.WTERMSIG(status))
  89
  90 def spawn_maybe_sandboxed(readable, writable, tmpdir, prog, args):
  91         child = os.fork()
  92         if child == 0:
  93                 try:
  94                         try:
  95                                 exec_maybe_sandboxed(readable, writable, tmpdir, prog, args)
  96                         except:
  97                                 traceback.print_exc()
  98                 finally:
  99                         print >>sys.stderr, "Exec failed"
 100                         os._exit(1)
 101         wait_for_child(child)
 102
 103 def exec_maybe_sandboxed(readable, writable, tmpdir, prog, args):
 104         """execl prog, with (only) the 'writable' directories writable if sandboxing is available.
 105         The readable directories will be readable, as well as various standard locations.
 106         If no sandbox is available, run without a sandbox."""
 107
 108         USE_PLASH = 'USE_PLASH_0COMPILE'
 109
 110         assert prog.startswith('/')
 111         _pola_run = find_in_path('pola-run')
 112
 113         if _pola_run is None:
 114                 print "Not using sandbox (plash not installed)"
 115                 use_plash = False
 116         else:
 117                 use_plash = os.environ.get(USE_PLASH, '').lower() or 'not set'
 118                 if use_plash in ('not set', 'false'):
 119                         print "Not using plash: $%s is %s" % (USE_PLASH, use_plash)
 120                         use_plash = False
 121                 elif use_plash == 'true':
 122                         use_plash = True
 123                 else:
 124                         raise Exception('$%s must be "true" or "false", not "%s"' % (USE_PLASH, use_plash))
 125
 126         if not use_plash:
 127                 os.execlp(prog, prog, *args)
 128
 129         print "Using plash to sandbox the build..."
 130
 131         # We have pola-shell :-)
 132         pola_args = ['--prog', prog, '-B']
 133         for a in args:
 134                 pola_args += ['-a', a]
 135         for r in readable:
 136                 pola_args += ['-f', r]
 137         for w in writable:
 138                 pola_args += ['-fw', w]
 139         pola_args += ['-tw', '/tmp', tmpdir]
 140         os.environ['TMPDIR'] = '/tmp'
 141         os.execl(_pola_run, _pola_run, *pola_args)
 142
 143 def get_arch_name():
 144         uname = os.uname()
 145         target_os = canonicalize_os(uname[0])
 146         target_machine = canonicalize_machine(uname[4])
 147         if target_os == 'Darwin' and target_machine == 'i386':
 148                 # this system detection shell script comes from config.guess (20090918):
 149                 CC = os.getenv("CC_FOR_BUILD") or os.getenv("CC") or os.getenv("HOST_CC") or "cc"
 150                 process = subprocess.Popen("(echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | " +
 151                                            "(CCOPTS= %s -E - 2>/dev/null) | " % CC +
 152                                            "grep IS_64BIT_ARCH >/dev/null", stdout=subprocess.PIPE, shell=True)
 153                 output, error = process.communicate()
 154                 retcode = process.poll()
 155                 if retcode == 0:
 156                         target_machine='x86_64'
 157         if target_machine in ('i585', 'i686'):
 158                 target_machine = 'i486' # (sensible default)
 159         return target_os + '-' + target_machine
 160
 161 class BuildEnv:
 162         def __init__(self, need_config = True):
 163                 if need_config and not os.path.isfile(ENV_FILE):
 164                         raise SafeException("Run 0compile from a directory containing a '%s' file" % ENV_FILE)
 165
 166                 self.config = ConfigParser.RawConfigParser()
 167                 self.config.add_section('compile')
 168                 self.config.set('compile', 'download-base-url', '')
 169                 self.config.set('compile', 'version-modifier', '')
 170                 self.config.set('compile', 'interface', '')
 171                 self.config.set('compile', 'selections', '')
 172                 self.config.set('compile', 'metadir', '0install')
 173                 self.config.set('compile', 'distdir', '')
 174
 175                 self.config.read(ENV_FILE)
 176
 177                 self._selections = None
 178
 179                 return
 180
 181         @property
 182         def iface_name(self):
 183                 iface_name = os.path.basename(self.interface)
 184                 if iface_name.endswith('.xml'):
 185                         iface_name = iface_name[:-4]
 186                 iface_name = iface_name.replace(' ', '-')
 187                 if iface_name.endswith('-src'):
 188                         iface_name = iface_name[:-4]
 189                 return iface_name
 190
 191         interface = property(lambda self: model.canonical_iface_uri(self.config.get('compile', 'interface')))
 192
 193         @property
 194         def distdir(self):
 195                 distdir_name = self.config.get('compile', 'distdir') or \
 196                         '%s-%s' % (self.iface_name.lower(), get_arch_name().lower())
 197                 assert '/' not in distdir_name
 198                 return os.path.realpath(distdir_name)
 199
 200         @property
 201         def metadir(self):
 202                 metadir = self.config.get('compile', 'metadir')
 203                 assert not metadir.startswith('/')
 204                 return join(self.distdir, metadir)
 205
 206         @property
 207         def local_iface_file(self):
 208                 return join(self.metadir, self.iface_name + '.xml')
 209
 210         @property
 211         def target_arch(self):
 212                 return get_arch_name()
 213
 214         @property
 215         def version_modifier(self):
 216                 vm = self.config.get('compile', 'version-modifier')
 217                 if vm: return vm
 218                 if self.user_srcdir:
 219                         return '-1'
 220                 return ''
 221
 222         @property
 223         def archive_stem(self):
 224                 # Use the version that we actually built, not the version we would build now
 225                 feed = self.load_built_feed()
 226                 assert len(feed.implementations) == 1
 227                 version = feed.implementations.values()[0].get_version()
 228
 229                 # Don't use the feed's name, as it may contain the version number
 230                 name = feed.get_name().lower().replace(' ', '-')
 231
 232                 return '%s-%s-%s' % (name, self.target_arch.lower(), version)
 233
 234         def load_built_feed(self):
 235                 path = self.local_iface_file
 236                 stream = file(path)
 237                 try:
 238                         feed = model.ZeroInstallFeed(qdom.parse(stream), local_path = path)
 239                 finally:
 240                         stream.close()
 241                 return feed
 242
 243         def load_built_selections(self):
 244                 path = join(self.metadir, 'build-environment.xml')
 245                 if os.path.exists(path):
 246                         stream = file(path)
 247                         try:
 248                                 return selections.Selections(qdom.parse(stream))
 249                         finally:
 250                                 stream.close()
 251                 return None
 252
 253         @property
 254         def download_base_url(self):
 255                 return self.config.get('compile', 'download-base-url')
 256
 257         def chosen_impl(self, uri):
 258                 sels = self.get_selections()
 259                 assert uri in sels.selections
 260                 return sels.selections[uri]
 261
 262         @property
 263         def local_download_iface(self):
 264                 impl, = self.load_built_feed().implementations.values()
 265                 return '%s-%s.xml' % (self.iface_name, impl.get_version())
 266
 267         def save(self):
 268                 stream = file(ENV_FILE, 'w')
 269                 try:
 270                         self.config.write(stream)
 271                 finally:
 272                         stream.close()
 273
 274         def get_selections(self, prompt = False):
 275                 if self._selections:
 276                         assert not prompt
 277                         return self._selections
 278
 279                 selections_file = self.config.get('compile', 'selections')
 280                 if selections_file:
 281                         if prompt:
 282                                 raise SafeException("Selections are fixed by %s" % selections_file)
 283                         stream = file(selections_file)
 284                         try:
 285                                 self._selections = selections.Selections(qdom.parse(stream))
 286                         finally:
 287                                 stream.close()
 288                         from zeroinstall.injector import handler, policy
 289                         if os.isatty(1):
 290                                 h = handler.ConsoleHandler()
 291                         else:
 292                                 h = handler.Handler()
 293                         config = policy.load_config(h)
 294                         blocker = self._selections.download_missing(config)
 295                         if blocker:
 296                                 print "Waiting for selected implementations to be downloaded..."
 297                                 h.wait_for_blocker(blocker)
 298                 else:
 299                         options = []
 300                         if prompt and '--console' not in launch_prog:
 301                                 options.append('--gui')
 302                         child = subprocess.Popen(launch_prog + ['--source', '--get-selections'] + options + [self.interface], stdout = subprocess.PIPE)
 303                         try:
 304                                 self._selections = selections.Selections(qdom.parse(child.stdout))
 305                         finally:
 306                                 if child.wait():
 307                                         raise SafeException("0launch --get-selections failed (exit code %d)" % child.returncode)
 308
 309                 self.root_impl = self._selections.selections[self.interface]
 310
 311                 self.orig_srcdir = os.path.realpath(lookup(self.root_impl))
 312                 self.user_srcdir = None
 313
 314                 if os.path.isdir('src'):
 315                         self.user_srcdir = os.path.realpath('src')
 316                         if self.user_srcdir == self.orig_srcdir or \
 317                            self.user_srcdir.startswith(self.orig_srcdir + '/') or \
 318                            self.orig_srcdir.startswith(self.user_srcdir + '/'):
 319                                 info("Ignoring 'src' directory because it coincides with %s",
 320                                         self.orig_srcdir)
 321                                 self.user_srcdir = None
 322
 323                 return self._selections
 324
 325         def get_build_changes(self):
 326                 sels = self.get_selections()
 327                 old_sels = self.load_built_selections()
 328                 changes = []
 329                 if old_sels:
 330                         # See if things have changed since the last build
 331                         all_ifaces = set(sels.selections) | set(old_sels.selections)
 332                         for x in all_ifaces:
 333                                 old_impl = old_sels.selections.get(x, no_impl)
 334                                 new_impl = sels.selections.get(x, no_impl)
 335                                 if old_impl.version != new_impl.version:
 336                                         changes.append("Version change for %s: %s -> %s" % (x, old_impl.version, new_impl.version))
 337                                 elif old_impl.id != new_impl.id:
 338                                         changes.append("Version change for %s: %s -> %s" % (x, old_impl.id, new_impl.id))
 339                 return changes
 340
 341 def depth(node):
 342         root = node.ownerDocument.documentElement
 343         depth = 0
 344         while node and node is not root:
 345                 node = node.parentNode
 346                 depth += 1
 347         return depth
 348
 349 def parse_bool(s):
 350         if s == 'true': return True
 351         if s == 'false': return False
 352         raise SafeException('Expected "true" or "false" but got "%s"' % s)