#!/usr/bin/env python import os import sys import warnings sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib')) try: import cPickle as pickle except ImportError: import pickle bb.msg.note(1, bb.msg.domain.Cache, "Importing cPickle failed. Falling back to a very slow implementation.") class BBConfiguration(object): """ Manages build options and configurations for one run """ def __init__(self, debug, debug_domains): setattr(self, "data", {}) setattr(self, "file", []) setattr(self, "cmd", None) setattr(self, "dump_signatures", True) setattr(self, "debug", debug) setattr(self, "debug_domains", debug_domains) _warnings_showwarning = warnings.showwarning def _showwarning(message, category, filename, lineno, file=None, line=None): """Display python warning messages using bb.msg""" if file is not None: if _warnings_showwarning is not None: _warnings_showwarning(message, category, filename, lineno, file, line) else: s = warnings.formatwarning(message, category, filename, lineno) s = s.split("\n")[0] bb.msg.warn(None, s) warnings.showwarning = _showwarning warnings.simplefilter("ignore", DeprecationWarning) import bb.event # Need to map our I/O correctly. stdout is a pipe to the server expecting # events. We save this and then map stdout to stderr. eventfd = os.dup(sys.stdout.fileno()) bb.event.worker_pipe = os.fdopen(eventfd, 'w', 0) # map stdout to stderr os.dup2(sys.stderr.fileno(), sys.stdout.fileno()) # Replace those fds with our own #logout = data.expand("${TMPDIR}/log/stdout.%s" % os.getpid(), self.cfgData, True) #mkdirhier(os.path.dirname(logout)) #newso = open("/tmp/stdout.%s" % os.getpid(), 'w') #os.dup2(newso.fileno(), sys.stdout.fileno()) #os.dup2(newso.fileno(), sys.stderr.fileno()) # Don't read from stdin from the parent si = file("/dev/null", 'r') os.dup2(si.fileno( ), sys.stdin.fileno( )) # We don't want to see signals to our parent, e.g. Ctrl+C os.setpgrp() # Save out the PID so that the event can include it the # events bb.event.worker_pid = os.getpid() bb.event.useStdout = False hashfile = sys.argv[1] buildfile = sys.argv[2] taskname = sys.argv[3] import bb.cooker p = pickle.Unpickler(file(hashfile, "rb")) hashdata = p.load() debug = hashdata["msg-debug"] debug_domains = hashdata["msg-debug-domains"] verbose = hashdata["verbose"] bb.utils.init_logger(bb.msg, verbose, debug, debug_domains) cooker = bb.cooker.BBCooker(BBConfiguration(debug, debug_domains), None) cooker.parseConfiguration() cooker.bb_cache = bb.cache.init(cooker) cooker.status = bb.cache.CacheData() (fn, cls) = cooker.bb_cache.virtualfn2realfn(buildfile) buildfile = cooker.matchFile(fn) fn = cooker.bb_cache.realfn2virtual(buildfile, cls) cooker.buildSetVars() # Load data into the cache for fn and parse the loaded cache data the_data = cooker.bb_cache.loadDataFull(fn, cooker.get_file_appends(fn), cooker.configuration.data) cooker.bb_cache.setData(fn, buildfile, the_data) cooker.bb_cache.handle_data(fn, cooker.status) if taskname.endswith("_setscene"): the_data.setVarFlag(taskname, "quieterrors", "1") bb.parse.siggen.set_taskdata(hashdata["hashes"], hashdata["deps"]) for h in hashdata["hashes"]: bb.data.setVar("BBHASH_%s" % h, hashdata["hashes"][h], the_data) for h in hashdata["deps"]: bb.data.setVar("BBHASHDEPS_%s" % h, hashdata["deps"][h], the_data) ret = 0 if sys.argv[4] != "True": ret = bb.build.exec_task(fn, taskname, the_data) sys.exit(ret) 3cbd07d9f8'>plain)