def __init__(self, output=sys.stdout, tracking=False): # Needed to avoid deprecation warnings with python 2.6 warnings.filterwarnings("ignore", category=DeprecationWarning) # Set up logging self.logger = logging.getLogger('BitBake') console = logging.StreamHandler(output) bb.msg.addDefaultlogFilter(console) format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s") if output.isatty(): format.enable_color() console.setFormatter(format) self.logger.addHandler(console) self.config = CookerConfiguration() configparams = TinfoilConfigParameters(parse_only=True) self.config.setConfigParameters(configparams) self.config.setServerRegIdleCallback(self.register_idle_function) features = [] if tracking: features.append(CookerFeatures.BASEDATASTORE_TRACKING) self.cooker = BBCooker(self.config, features) self.config_data = self.cooker.data bb.providers.logger.setLevel(logging.ERROR) self.cooker_data = None
def __init__(self, command_channel, event_queue, configuration): Process.__init__(self) self.command_channel = command_channel self.event_queue = event_queue self.event = EventAdapter(event_queue) self.configuration = configuration self.cooker = BBCooker(configuration, self.register_idle_function) self._idlefunctions = {} self.event_handle = bb.event.register_UIHhandler(self) self.quit = False self.keep_running = Event() self.keep_running.set() for event in bb.event.ui_queue: self.event_queue.put(event)
class Tinfoil: def __init__(self, output=sys.stdout, tracking=False): # Needed to avoid deprecation warnings with python 2.6 warnings.filterwarnings("ignore", category=DeprecationWarning) # Set up logging self.logger = logging.getLogger('BitBake') console = logging.StreamHandler(output) bb.msg.addDefaultlogFilter(console) format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s") if output.isatty(): format.enable_color() console.setFormatter(format) self.logger.addHandler(console) self.config = CookerConfiguration() configparams = TinfoilConfigParameters(parse_only=True) self.config.setConfigParameters(configparams) self.config.setServerRegIdleCallback(self.register_idle_function) features = [] if tracking: features.append(CookerFeatures.BASEDATASTORE_TRACKING) self.cooker = BBCooker(self.config, features) self.config_data = self.cooker.data bb.providers.logger.setLevel(logging.ERROR) self.cooker_data = None def register_idle_function(self, function, data): pass def parseRecipes(self): sys.stderr.write("Parsing recipes..") self.logger.setLevel(logging.WARNING) try: while self.cooker.state in (state.initial, state.parsing): self.cooker.updateCache() except KeyboardInterrupt: self.cooker.shutdown() self.cooker.updateCache() sys.exit(2) self.logger.setLevel(logging.INFO) sys.stderr.write("done.\n") self.cooker_data = self.cooker.recipecache def prepare(self, config_only = False): if not self.cooker_data: if config_only: self.cooker.parseConfiguration() self.cooker_data = self.cooker.recipecache else: self.parseRecipes()
class Tinfoil: def __init__(self, output=sys.stdout, tracking=False): # Needed to avoid deprecation warnings with python 2.6 warnings.filterwarnings("ignore", category=DeprecationWarning) # Set up logging self.logger = logging.getLogger('BitBake') console = logging.StreamHandler(output) bb.msg.addDefaultlogFilter(console) format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s") if output.isatty(): format.enable_color() console.setFormatter(format) self.logger.addHandler(console) self.config = CookerConfiguration() configparams = TinfoilConfigParameters(parse_only=True) self.config.setConfigParameters(configparams) self.config.setServerRegIdleCallback(self.register_idle_function) features = [] if tracking: features.append(CookerFeatures.BASEDATASTORE_TRACKING) self.cooker = BBCooker(self.config, features) self.config_data = self.cooker.data bb.providers.logger.setLevel(logging.ERROR) self.cooker_data = None def register_idle_function(self, function, data): pass def parseRecipes(self): sys.stderr.write("Parsing recipes..") self.logger.setLevel(logging.WARNING) try: while self.cooker.state in (state.initial, state.parsing): self.cooker.updateCache() except KeyboardInterrupt: self.cooker.shutdown() self.cooker.updateCache() sys.exit(2) self.logger.setLevel(logging.INFO) sys.stderr.write("done.\n") self.cooker_data = self.cooker.recipecache def prepare(self, config_only=False): if not self.cooker_data: if config_only: self.cooker.parseConfiguration() self.cooker_data = self.cooker.recipecache else: self.parseRecipes()
class Tinfoil: def __init__(self, output=sys.stdout, tracking=False): # Needed to avoid deprecation warnings with python 2.6 warnings.filterwarnings("ignore", category=DeprecationWarning) # Set up logging self.logger = logging.getLogger('BitBake') self._log_hdlr = logging.StreamHandler(output) bb.msg.addDefaultlogFilter(self._log_hdlr) format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s") if output.isatty(): format.enable_color() self._log_hdlr.setFormatter(format) self.logger.addHandler(self._log_hdlr) self.config = CookerConfiguration() configparams = TinfoilConfigParameters(parse_only=True) self.config.setConfigParameters(configparams) self.config.setServerRegIdleCallback(self.register_idle_function) features = [] if tracking: features.append(CookerFeatures.BASEDATASTORE_TRACKING) self.cooker = BBCooker(self.config, features) self.config_data = self.cooker.data bb.providers.logger.setLevel(logging.ERROR) self.cooker_data = None def register_idle_function(self, function, data): pass def __enter__(self): return self def __exit__(self, type, value, traceback): self.shutdown() def parseRecipes(self): sys.stderr.write("Parsing recipes..") self.logger.setLevel(logging.WARNING) try: while self.cooker.state in (state.initial, state.parsing): self.cooker.updateCache() except KeyboardInterrupt: self.cooker.shutdown() self.cooker.updateCache() sys.exit(2) self.logger.setLevel(logging.INFO) sys.stderr.write("done.\n") self.cooker_data = self.cooker.recipecaches[''] def prepare(self, config_only=False): if not self.cooker_data: if config_only: self.cooker.parseConfiguration() self.cooker_data = self.cooker.recipecaches[''] else: self.parseRecipes() def parse_recipe_file(self, fn, appends=True, appendlist=None, config_data=None): """ Parse the specified recipe file (with or without bbappends) and return a datastore object representing the environment for the recipe. Parameters: fn: recipe file to parse - can be a file path or virtual specification appends: True to apply bbappends, False otherwise appendlist: optional list of bbappend files to apply, if you want to filter them config_data: custom config datastore to use. NOTE: if you specify config_data then you cannot use a virtual specification for fn. """ if appends and appendlist == []: appends = False if appends: if appendlist: appendfiles = appendlist else: if not hasattr(self.cooker, 'collection'): raise Exception( 'You must call tinfoil.prepare() with config_only=False in order to get bbappends' ) appendfiles = self.cooker.collection.get_file_appends(fn) else: appendfiles = None if config_data: # We have to use a different function here if we're passing in a datastore localdata = bb.data.createCopy(config_data) envdata = bb.cache.parse_recipe(localdata, fn, appendfiles)[''] else: # Use the standard path parser = bb.cache.NoCache(self.cooker.databuilder) envdata = parser.loadDataFull(fn, appendfiles) return envdata def shutdown(self): self.cooker.shutdown(force=True) self.cooker.post_serve() self.cooker.unlockBitbake() self.logger.removeHandler(self._log_hdlr)
class Tinfoil: def __init__(self, output=sys.stdout, tracking=False): # Needed to avoid deprecation warnings with python 2.6 warnings.filterwarnings("ignore", category=DeprecationWarning) # Set up logging self.logger = logging.getLogger('BitBake') self._log_hdlr = logging.StreamHandler(output) bb.msg.addDefaultlogFilter(self._log_hdlr) format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s") if output.isatty(): format.enable_color() self._log_hdlr.setFormatter(format) self.logger.addHandler(self._log_hdlr) self.config = CookerConfiguration() configparams = TinfoilConfigParameters(parse_only=True) self.config.setConfigParameters(configparams) self.config.setServerRegIdleCallback(self.register_idle_function) features = [] if tracking: features.append(CookerFeatures.BASEDATASTORE_TRACKING) self.cooker = BBCooker(self.config, features) self.config_data = self.cooker.data bb.providers.logger.setLevel(logging.ERROR) self.cooker_data = None def register_idle_function(self, function, data): pass def __enter__(self): return self def __exit__(self, type, value, traceback): self.shutdown() def parseRecipes(self): sys.stderr.write("Parsing recipes..") self.logger.setLevel(logging.WARNING) try: while self.cooker.state in (state.initial, state.parsing): self.cooker.updateCache() except KeyboardInterrupt: self.cooker.shutdown() self.cooker.updateCache() sys.exit(2) self.logger.setLevel(logging.INFO) sys.stderr.write("done.\n") self.cooker_data = self.cooker.recipecaches[''] def prepare(self, config_only = False): if not self.cooker_data: if config_only: self.cooker.parseConfiguration() self.cooker_data = self.cooker.recipecaches[''] else: self.parseRecipes() def parse_recipe_file(self, fn, appends=True, appendlist=None, config_data=None): """ Parse the specified recipe file (with or without bbappends) and return a datastore object representing the environment for the recipe. Parameters: fn: recipe file to parse - can be a file path or virtual specification appends: True to apply bbappends, False otherwise appendlist: optional list of bbappend files to apply, if you want to filter them config_data: custom config datastore to use. NOTE: if you specify config_data then you cannot use a virtual specification for fn. """ if appends and appendlist == []: appends = False if appends: if appendlist: appendfiles = appendlist else: if not hasattr(self.cooker, 'collection'): raise Exception('You must call tinfoil.prepare() with config_only=False in order to get bbappends') appendfiles = self.cooker.collection.get_file_appends(fn) else: appendfiles = None if config_data: # We have to use a different function here if we're passing in a datastore localdata = bb.data.createCopy(config_data) envdata = bb.cache.parse_recipe(localdata, fn, appendfiles)[''] else: # Use the standard path parser = bb.cache.NoCache(self.cooker.databuilder) envdata = parser.loadDataFull(fn, appendfiles) return envdata def shutdown(self): self.cooker.shutdown(force=True) self.cooker.post_serve() self.cooker.unlockBitbake() self.logger.removeHandler(self._log_hdlr)
class ProcessServer(Process): profile_filename = "profile.log" profile_processed_filename = "profile.log.processed" def __init__(self, command_channel, event_queue, configuration): Process.__init__(self) self.command_channel = command_channel self.event_queue = event_queue self.event = EventAdapter(event_queue) self.configuration = configuration self.cooker = BBCooker(configuration, self.register_idle_function) self._idlefunctions = {} self.event_handle = bb.event.register_UIHhandler(self) self.quit = False self.keep_running = Event() self.keep_running.set() for event in bb.event.ui_queue: self.event_queue.put(event) def register_idle_function(self, function, data): """Register a function to be called while the server is idle""" assert hasattr(function, '__call__') self._idlefunctions[function] = data def run(self): if self.configuration.profile: return self.profile_main() else: return self.main() def profile_main(self): import cProfile profiler = cProfile.Profile() try: return profiler.runcall(self.main) finally: profiler.dump_stats(self.profile_filename) self.write_profile_stats() sys.__stderr__.write( "Raw profiling information saved to %s and " "processed statistics to %s\n" % (self.profile_filename, self.profile_processed_filename)) def write_profile_stats(self): import pstats with open(self.profile_processed_filename, 'w') as outfile: stats = pstats.Stats(self.profile_filename, stream=outfile) stats.sort_stats('time') stats.print_stats() stats.print_callers() stats.sort_stats('cumulative') stats.print_stats() def main(self): # Ignore SIGINT within the server, as all SIGINT handling is done by # the UI and communicated to us signal.signal(signal.SIGINT, signal.SIG_IGN) while self.keep_running.is_set(): try: if self.command_channel.poll(): command = self.command_channel.recv() self.runCommand(command) self.idle_commands(.1) except Exception: logger.exception('Running command %s', command) self.event_queue.cancel_join_thread() bb.event.unregister_UIHhandler(self.event_handle) self.command_channel.close() self.cooker.stop() self.idle_commands(.1) def idle_commands(self, delay): nextsleep = delay for function, data in self._idlefunctions.items(): try: retval = function(self, data, False) if retval is False: del self._idlefunctions[function] elif retval is True: nextsleep = None elif nextsleep is None: continue elif retval < nextsleep: nextsleep = retval except SystemExit: raise except Exception: logger.exception('Running idle function') if nextsleep is not None: time.sleep(nextsleep) def runCommand(self, command): """ Run a cooker command on the server """ self.command_channel.send(self.cooker.command.runCommand(command)) def stop(self): self.keep_running.clear()
class ProcessServer(Process): profile_filename = "profile.log" profile_processed_filename = "profile.log.processed" def __init__(self, command_channel, event_queue, configuration): Process.__init__(self) self.command_channel = command_channel self.event_queue = event_queue self.event = EventAdapter(event_queue) self.configuration = configuration self.cooker = BBCooker(configuration, self.register_idle_function) self._idlefunctions = {} self.event_handle = bb.event.register_UIHhandler(self) self.quit = False self.keep_running = Event() self.keep_running.set() for event in bb.event.ui_queue: self.event_queue.put(event) def register_idle_function(self, function, data): """Register a function to be called while the server is idle""" assert hasattr(function, "__call__") self._idlefunctions[function] = data def run(self): if self.configuration.profile: return self.profile_main() else: return self.main() def profile_main(self): import cProfile profiler = cProfile.Profile() try: return profiler.runcall(self.main) finally: profiler.dump_stats(self.profile_filename) self.write_profile_stats() sys.__stderr__.write( "Raw profiling information saved to %s and " "processed statistics to %s\n" % (self.profile_filename, self.profile_processed_filename) ) def write_profile_stats(self): import pstats with open(self.profile_processed_filename, "w") as outfile: stats = pstats.Stats(self.profile_filename, stream=outfile) stats.sort_stats("time") stats.print_stats() stats.print_callers() stats.sort_stats("cumulative") stats.print_stats() def main(self): # Ignore SIGINT within the server, as all SIGINT handling is done by # the UI and communicated to us signal.signal(signal.SIGINT, signal.SIG_IGN) while self.keep_running.is_set(): try: if self.command_channel.poll(): command = self.command_channel.recv() self.runCommand(command) self.idle_commands(0.1) except Exception: logger.exception("Running command %s", command) self.event_queue.cancel_join_thread() bb.event.unregister_UIHhandler(self.event_handle) self.command_channel.close() self.cooker.stop() self.idle_commands(0.1) def idle_commands(self, delay): nextsleep = delay for function, data in self._idlefunctions.items(): try: retval = function(self, data, False) if retval is False: del self._idlefunctions[function] elif retval is True: nextsleep = None elif nextsleep is None: continue elif retval < nextsleep: nextsleep = retval except SystemExit: raise except Exception: logger.exception("Running idle function") if nextsleep is not None: time.sleep(nextsleep) def runCommand(self, command): """ Run a cooker command on the server """ self.command_channel.send(self.cooker.command.runCommand(command)) def stop(self): self.keep_running.clear() def bootstrap_2_6_6(self): """Pulled from python 2.6.6. Needed to ensure we have the fix from http://bugs.python.org/issue5313 when running on python version 2.6.2 or lower.""" try: self._children = set() self._counter = itertools.count(1) try: sys.stdin.close() sys.stdin = open(os.devnull) except (OSError, ValueError): pass multiprocessing._current_process = self util._finalizer_registry.clear() util._run_after_forkers() util.info("child process calling self.run()") try: self.run() exitcode = 0 finally: util._exit_function() except SystemExit, e: if not e.args: exitcode = 1 elif type(e.args[0]) is int: exitcode = e.args[0] else: sys.stderr.write(e.args[0] + "\n") sys.stderr.flush() exitcode = 1 except:
class ProcessServer(Process): profile_filename = "profile.log" profile_processed_filename = "profile.log.processed" def __init__(self, command_channel, event_queue, configuration): Process.__init__(self) self.command_channel = command_channel self.event_queue = event_queue self.event = EventAdapter(event_queue) self.configuration = configuration self.cooker = BBCooker(configuration, self.register_idle_function) self._idlefunctions = {} self.event_handle = bb.event.register_UIHhandler(self) self.quit = False self.keep_running = Event() self.keep_running.set() for event in bb.event.ui_queue: self.event_queue.put(event) def register_idle_function(self, function, data): """Register a function to be called while the server is idle""" assert hasattr(function, '__call__') self._idlefunctions[function] = data def run(self): if self.configuration.profile: return self.profile_main() else: return self.main() def profile_main(self): import cProfile profiler = cProfile.Profile() try: return profiler.runcall(self.main) finally: profiler.dump_stats(self.profile_filename) self.write_profile_stats() sys.__stderr__.write("Raw profiling information saved to %s and " "processed statistics to %s\n" % (self.profile_filename, self.profile_processed_filename)) def write_profile_stats(self): import pstats with open(self.profile_processed_filename, 'w') as outfile: stats = pstats.Stats(self.profile_filename, stream=outfile) stats.sort_stats('time') stats.print_stats() stats.print_callers() stats.sort_stats('cumulative') stats.print_stats() def main(self): # Ignore SIGINT within the server, as all SIGINT handling is done by # the UI and communicated to us signal.signal(signal.SIGINT, signal.SIG_IGN) while self.keep_running.is_set(): try: if self.command_channel.poll(): command = self.command_channel.recv() self.runCommand(command) self.idle_commands(.1) except Exception: logger.exception('Running command %s', command) self.event_queue.cancel_join_thread() bb.event.unregister_UIHhandler(self.event_handle) self.command_channel.close() self.cooker.stop() self.idle_commands(.1) def idle_commands(self, delay): nextsleep = delay for function, data in self._idlefunctions.items(): try: retval = function(self, data, False) if retval is False: del self._idlefunctions[function] elif retval is True: nextsleep = None elif nextsleep is None: continue elif retval < nextsleep: nextsleep = retval except SystemExit: raise except Exception: logger.exception('Running idle function') if nextsleep is not None: time.sleep(nextsleep) def runCommand(self, command): """ Run a cooker command on the server """ self.command_channel.send(self.cooker.command.runCommand(command)) def stop(self): self.keep_running.clear()