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, 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()
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')
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()
