From 656f9a07588cc00704825a78de9649ca4a1552b8 Mon Sep 17 00:00:00 2001 From: Dongxiao Xu Date: Mon, 28 Nov 2011 14:32:40 +0800 Subject: Hob: A new implemetation (v2) This commit implements a new design for hob Some of the new features: - Friendly new designed GUI. Quick response to user actions. - Two step builds support package generation and image generation. - Support running GUI seprarately from bitbake server. - Recipe/package selection and deselection. - Accurate customization for image contents and size. - Progress bars showing the parsing and build status. - Load/save user configurations from/into templates. (Bitbake rev: 4dacd29f9c957d20f4583330b51e5420f9c3338d) Signed-off-by: Dongxiao Xu Signed-off-by: Shane Wang Signed-off-by: Liming An Signed-off-by: Fengxia Hua Designed-by: Belen Barros Pena Signed-off-by: Richard Purdie --- bitbake/lib/bb/ui/crumbs/hobeventhandler.py | 586 +++++++++++++++++----------- 1 file changed, 351 insertions(+), 235 deletions(-) (limited to 'bitbake/lib/bb/ui/crumbs/hobeventhandler.py') diff --git a/bitbake/lib/bb/ui/crumbs/hobeventhandler.py b/bitbake/lib/bb/ui/crumbs/hobeventhandler.py index ddab987ca8..b071ad4503 100644 --- a/bitbake/lib/bb/ui/crumbs/hobeventhandler.py +++ b/bitbake/lib/bb/ui/crumbs/hobeventhandler.py @@ -4,6 +4,7 @@ # Copyright (C) 2011 Intel Corporation # # Authored by Joshua Lock +# Authored by Dongxiao Xu # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as @@ -20,10 +21,7 @@ import gobject import logging -import tempfile -import datetime - -progress_total = 0 +from bb.ui.crumbs.runningbuild import RunningBuild class HobHandler(gobject.GObject): @@ -31,147 +29,176 @@ class HobHandler(gobject.GObject): This object does BitBake event handling for the hob gui. """ __gsignals__ = { - "machines-updated" : (gobject.SIGNAL_RUN_LAST, - gobject.TYPE_NONE, - (gobject.TYPE_PYOBJECT,)), - "sdk-machines-updated": (gobject.SIGNAL_RUN_LAST, - gobject.TYPE_NONE, - (gobject.TYPE_PYOBJECT,)), - "distros-updated" : (gobject.SIGNAL_RUN_LAST, - gobject.TYPE_NONE, - (gobject.TYPE_PYOBJECT,)), - "package-formats-found" : (gobject.SIGNAL_RUN_LAST, - gobject.TYPE_NONE, - (gobject.TYPE_PYOBJECT,)), - "config-found" : (gobject.SIGNAL_RUN_LAST, - gobject.TYPE_NONE, - (gobject.TYPE_STRING,)), - "generating-data" : (gobject.SIGNAL_RUN_LAST, - gobject.TYPE_NONE, - ()), - "data-generated" : (gobject.SIGNAL_RUN_LAST, - gobject.TYPE_NONE, - ()), - "fatal-error" : (gobject.SIGNAL_RUN_LAST, - gobject.TYPE_NONE, - (gobject.TYPE_STRING, - gobject.TYPE_STRING,)), - "command-failed" : (gobject.SIGNAL_RUN_LAST, - gobject.TYPE_NONE, - (gobject.TYPE_STRING,)), - "reload-triggered" : (gobject.SIGNAL_RUN_LAST, - gobject.TYPE_NONE, - (gobject.TYPE_STRING, - gobject.TYPE_STRING,)), + "layers-updated" : (gobject.SIGNAL_RUN_LAST, + gobject.TYPE_NONE, + (gobject.TYPE_PYOBJECT,)), + "package-formats-updated" : (gobject.SIGNAL_RUN_LAST, + gobject.TYPE_NONE, + (gobject.TYPE_PYOBJECT,)), + "config-updated" : (gobject.SIGNAL_RUN_LAST, + gobject.TYPE_NONE, + (gobject.TYPE_STRING, gobject.TYPE_PYOBJECT,)), + "command-succeeded" : (gobject.SIGNAL_RUN_LAST, + gobject.TYPE_NONE, + (gobject.TYPE_INT,)), + "command-failed" : (gobject.SIGNAL_RUN_LAST, + gobject.TYPE_NONE, + (gobject.TYPE_STRING,)), + "generating-data" : (gobject.SIGNAL_RUN_LAST, + gobject.TYPE_NONE, + ()), + "data-generated" : (gobject.SIGNAL_RUN_LAST, + gobject.TYPE_NONE, + ()), + "parsing-started" : (gobject.SIGNAL_RUN_LAST, + gobject.TYPE_NONE, + (gobject.TYPE_PYOBJECT,)), + "parsing" : (gobject.SIGNAL_RUN_LAST, + gobject.TYPE_NONE, + (gobject.TYPE_PYOBJECT,)), + "parsing-completed" : (gobject.SIGNAL_RUN_LAST, + gobject.TYPE_NONE, + (gobject.TYPE_PYOBJECT,)), } - (CFG_PATH_LOCAL, CFG_PATH_PRE, CFG_PATH_POST, CFG_PATH_LAYERS, CFG_FILES_DISTRO, CFG_FILES_MACH, CFG_FILES_SDK, FILES_MATCH_CLASS, GENERATE_TGTS, REPARSE_FILES, BUILD_IMAGE) = range(11) + (CFG_AVAIL_LAYERS, CFG_PATH_LAYERS, CFG_FILES_DISTRO, CFG_FILES_MACH, CFG_FILES_SDKMACH, FILES_MATCH_CLASS, PARSE_CONFIG, PARSE_BBFILES, GENERATE_TGTS, GENERATE_PACKAGEINFO, BUILD_TARGET_RECIPES, BUILD_TARGET_IMAGE, CMD_END) = range(13) + (LAYERS_REFRESH, GENERATE_RECIPES, GENERATE_PACKAGES, GENERATE_IMAGE, POPULATE_PACKAGEINFO) = range(5) - def __init__(self, taskmodel, server): - gobject.GObject.__init__(self) + def __init__(self, server, server_addr, client_addr, recipe_model, package_model): + super(HobHandler, self).__init__() - self.current_command = None - self.building = False - self.build_toolchain = False - self.build_toolchain_headers = False + self.build = RunningBuild(sequential=True) + + self.recipe_model = recipe_model + self.package_model = package_model + + self.commands_async = [] self.generating = False - self.build_queue = [] self.current_phase = None - self.bbpath_ok = False - self.bbfiles_ok = False - self.build_type = "image" - self.image_dir = os.path.join(tempfile.gettempdir(), 'hob-images') + self.building = False + self.recipe_queue = [] + self.package_queue = [] - self.model = taskmodel self.server = server - - deploy_dir = self.server.runCommand(["getVariable", "DEPLOY_DIR"]) - self.image_out_dir = os.path.join(deploy_dir, "images") - self.image_output_types = self.server.runCommand(["getVariable", "IMAGE_FSTYPES"]).split(" ") - self.bbpath = self.server.runCommand(["getVariable", "BBPATH"]) - self.bbfiles = self.server.runCommand(["getVariable", "BBFILES"]) - - def run_next_command(self): - if self.current_command and not self.generating: + self.error_msg = "" + self.initcmd = None + + self.split_model = False + if server_addr and client_addr: + self.split_model = (server_addr != client_addr) + self.reset_server() # reset server if server was found just now + self.server_addr = server_addr + + def kick(self): + import xmlrpclib + try: + # kick the while thing off + if self.split_model: + self.commands_async.append(self.CFG_AVAIL_LAYERS) + else: + self.commands_async.append(self.CFG_PATH_LAYERS) + self.commands_async.append(self.CFG_FILES_DISTRO) + self.commands_async.append(self.CFG_FILES_MACH) + self.commands_async.append(self.CFG_FILES_SDKMACH) + self.commands_async.append(self.FILES_MATCH_CLASS) + self.run_next_command() + return True + except xmlrpclib.Fault as x: + print("XMLRPC Fault getting commandline:\n %s" % x) + return False + + def set_busy(self): + if not self.generating: self.emit("generating-data") self.generating = True - if self.current_command == self.CFG_PATH_LOCAL: - self.current_command = self.CFG_PATH_PRE - self.server.runCommand(["findConfigFilePath", "hob-pre.conf"]) - elif self.current_command == self.CFG_PATH_PRE: - self.current_command = self.CFG_PATH_POST - self.server.runCommand(["findConfigFilePath", "hob-post.conf"]) - elif self.current_command == self.CFG_PATH_POST: - self.current_command = self.CFG_PATH_LAYERS + def clear_busy(self): + if self.generating: + self.emit("data-generated") + self.generating = False + + def run_next_command(self, initcmd=None): + if initcmd != None: + self.initcmd = initcmd + + if self.commands_async: + self.set_busy() + next_command = self.commands_async.pop(0) + else: + self.clear_busy() + if self.initcmd != None: + self.emit("command-succeeded", self.initcmd) + return + + if next_command == self.CFG_AVAIL_LAYERS: + self.server.runCommand(["findCoreBaseFiles", "layers", "conf/layer.conf"]) + elif next_command == self.CFG_PATH_LAYERS: self.server.runCommand(["findConfigFilePath", "bblayers.conf"]) - elif self.current_command == self.CFG_PATH_LAYERS: - self.current_command = self.CFG_FILES_DISTRO + elif next_command == self.CFG_FILES_DISTRO: self.server.runCommand(["findConfigFiles", "DISTRO"]) - elif self.current_command == self.CFG_FILES_DISTRO: - self.current_command = self.CFG_FILES_MACH + elif next_command == self.CFG_FILES_MACH: self.server.runCommand(["findConfigFiles", "MACHINE"]) - elif self.current_command == self.CFG_FILES_MACH: - self.current_command = self.CFG_FILES_SDK + elif next_command == self.CFG_FILES_SDKMACH: self.server.runCommand(["findConfigFiles", "MACHINE-SDK"]) - elif self.current_command == self.CFG_FILES_SDK: - self.current_command = self.FILES_MATCH_CLASS + elif next_command == self.FILES_MATCH_CLASS: self.server.runCommand(["findFilesMatchingInDir", "rootfs_", "classes"]) - elif self.current_command == self.FILES_MATCH_CLASS: - self.current_command = self.GENERATE_TGTS - self.server.runCommand(["generateTargetsTree", "classes/image.bbclass"]) - elif self.current_command == self.GENERATE_TGTS: - if self.generating: - self.emit("data-generated") - self.generating = False - self.current_command = None - elif self.current_command == self.REPARSE_FILES: - if self.build_queue: - self.current_command = self.BUILD_IMAGE - else: - self.current_command = self.CFG_PATH_LAYERS - self.server.runCommand(["resetCooker"]) - self.server.runCommand(["reparseFiles"]) - elif self.current_command == self.BUILD_IMAGE: - if self.generating: - self.emit("data-generated") - self.generating = False + elif next_command == self.PARSE_CONFIG: + self.server.runCommand(["parseConfigurationFiles", "", ""]) + elif next_command == self.PARSE_BBFILES: + self.server.runCommand(["parseFiles"]) + elif next_command == self.GENERATE_TGTS: + self.server.runCommand(["generateTargetsTree", "classes/image.bbclass", [], True]) + elif next_command == self.GENERATE_PACKAGEINFO: + self.server.runCommand(["triggerEvent", "bb.event.RequestPackageInfo()"]) + elif next_command == self.BUILD_TARGET_RECIPES: + self.clear_busy() self.building = True - self.server.runCommand(["buildTargets", self.build_queue, "build"]) - self.build_queue = [] - self.current_command = None - - def handle_event(self, event, running_build, pbar): + self.server.runCommand(["buildTargets", self.recipe_queue, "build"]) + self.recipe_queue = [] + elif next_command == self.BUILD_TARGET_IMAGE: + self.clear_busy() + self.building = True + targets = ["hob-image"] + self.server.runCommand(["setVariable", "LINGUAS_INSTALL", ""]) + self.server.runCommand(["setVariable", "PACKAGE_INSTALL", " ".join(self.package_queue)]) + if self.toolchain_build: + pkgs = self.package_queue + [i+'-dev' for i in self.package_queue] + [i+'-dbg' for i in self.package_queue] + self.server.runCommand(["setVariable", "TOOLCHAIN_TARGET_TASK", " ".join(pkgs)]) + targets.append("hob-toolchain") + self.server.runCommand(["buildTargets", targets, "build"]) + + def handle_event(self, event): if not event: - return + return - # If we're running a build, use the RunningBuild event handler if self.building: self.current_phase = "building" - running_build.handle_event(event) + self.build.handle_event(event) + + if isinstance(event, bb.event.PackageInfo): + self.package_model.populate(event._pkginfolist) + self.run_next_command() + + elif(isinstance(event, logging.LogRecord)): + if event.levelno >= logging.ERROR: + self.error_msg += event.msg + '\n' + elif isinstance(event, bb.event.TargetsTreeGenerated): self.current_phase = "data generation" if event._model: - self.model.populate(event._model) + self.recipe_model.populate(event._model) + elif isinstance(event, bb.event.CoreBaseFilesFound): + self.current_phase = "configuration lookup" + paths = event._paths + self.emit('layers-updated', paths) elif isinstance(event, bb.event.ConfigFilesFound): self.current_phase = "configuration lookup" var = event._variable - if var == "distro": - distros = event._values - distros.sort() - self.emit("distros-updated", distros) - elif var == "machine": - machines = event._values - machines.sort() - self.emit("machines-updated", machines) - elif var == "machine-sdk": - sdk_machines = event._values - sdk_machines.sort() - self.emit("sdk-machines-updated", sdk_machines) + values = event._values + values.sort() + self.emit("config-updated", var, values) elif isinstance(event, bb.event.ConfigFilePathFound): self.current_phase = "configuration lookup" - path = event._path - self.emit("config-found", path) elif isinstance(event, bb.event.FilesMatchingFound): self.current_phase = "configuration lookup" # FIXME: hard coding, should at least be a variable shared between @@ -183,48 +210,84 @@ class HobHandler(gobject.GObject): fs, sep, format = classname.rpartition("_") formats.append(format) formats.sort() - self.emit("package-formats-found", formats) + self.emit("package-formats-updated", formats) elif isinstance(event, bb.command.CommandCompleted): self.current_phase = None self.run_next_command() + + elif isinstance(event, bb.event.NoProvider): + if event._runtime: + r = "R" + else: + r = "" + if event._dependees: + self.error_msg += " Nothing %sPROVIDES '%s' (but %s %sDEPENDS on or otherwise requires it)" % (r, event._item, ", ".join(event._dependees), r) + else: + self.error_msg += " Nothing %sPROVIDES '%s'" % (r, event._item) + if event._reasons: + for reason in event._reasons: + self.error_msg += " %s" % reason + + self.commands_async = [] + self.emit("command-failed", self.error_msg) + self.error_msg = "" + elif isinstance(event, bb.command.CommandFailed): - self.emit("command-failed", event.error) - elif isinstance(event, bb.event.CacheLoadStarted): - self.current_phase = "cache loading" - bb.ui.crumbs.hobeventhandler.progress_total = event.total - pbar.set_text("Loading cache: %s/%s" % (0, bb.ui.crumbs.hobeventhandler.progress_total)) - elif isinstance(event, bb.event.CacheLoadProgress): - self.current_phase = "cache loading" - pbar.set_text("Loading cache: %s/%s" % (event.current, bb.ui.crumbs.hobeventhandler.progress_total)) - elif isinstance(event, bb.event.CacheLoadCompleted): - self.current_phase = None - pbar.set_text("Loading...") - elif isinstance(event, bb.event.ParseStarted): - self.current_phase = "recipe parsing" - if event.total == 0: - return - bb.ui.crumbs.hobeventhandler.progress_total = event.total - pbar.set_text("Processing recipes: %s/%s" % (0, bb.ui.crumbs.hobeventhandler.progress_total)) - elif isinstance(event, bb.event.ParseProgress): - self.current_phase = "recipe parsing" - pbar.set_text("Processing recipes: %s/%s" % (event.current, bb.ui.crumbs.hobeventhandler.progress_total)) - elif isinstance(event, bb.event.ParseCompleted): - self.current_phase = None - pbar.set_fraction(1.0) - pbar.set_text("Loading...") - elif isinstance(event, logging.LogRecord): - format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s") - if event.levelno >= format.CRITICAL: - self.emit("fatal-error", event.getMessage(), self.current_phase) + self.commands_async = [] + if self.error_msg: + self.emit("command-failed", self.error_msg) + self.error_msg = "" + elif isinstance(event, (bb.event.ParseStarted, + bb.event.CacheLoadStarted, + bb.event.TreeDataPreparationStarted, + )): + message = {} + message["eventname"] = bb.event.getName(event) + message["current"] = 0 + message["total"] = None + message["title"] = "Parsing recipes: " + self.emit("parsing-started", message) + elif isinstance(event, (bb.event.ParseProgress, + bb.event.CacheLoadProgress, + bb.event.TreeDataPreparationProgress)): + message = {} + message["eventname"] = bb.event.getName(event) + message["current"] = event.current + message["total"] = event.total + message["title"] = "Parsing recipes: " + self.emit("parsing", message) + elif isinstance(event, (bb.event.ParseCompleted, + bb.event.CacheLoadCompleted, + bb.event.TreeDataPreparationCompleted)): + message = {} + message["eventname"] = bb.event.getName(event) + message["current"] = event.total + message["total"] = event.total + message["title"] = "Parsing recipes: " + self.emit("parsing-completed", message) + return - def event_handle_idle_func (self, eventHandler, running_build, pbar): - # Consume as many messages as we can in the time available to us - event = eventHandler.getEvent() - while event: - self.handle_event(event, running_build, pbar) - event = eventHandler.getEvent() - return True + def init_cooker(self): + self.server.runCommand(["initCooker"]) + + def refresh_layers(self, bblayers): + self.server.runCommand(["initCooker"]) + self.server.runCommand(["setVariable", "BBLAYERS", " ".join(bblayers)]) + self.commands_async.append(self.PARSE_CONFIG) + self.commands_async.append(self.CFG_FILES_DISTRO) + self.commands_async.append(self.CFG_FILES_MACH) + self.commands_async.append(self.CFG_FILES_SDKMACH) + self.commands_async.append(self.FILES_MATCH_CLASS) + self.run_next_command(self.LAYERS_REFRESH) + + def set_extra_inherit(self, bbclass): + inherits = self.server.runCommand(["getVariable", "INHERIT"]) or "" + inherits = inherits + " " + bbclass + self.server.runCommand(["setVariable", "INHERIT", inherits]) + + def set_bblayers(self, bblayers): + self.server.runCommand(["setVariable", "BBLAYERS", " ".join(bblayers)]) def set_machine(self, machine): self.server.runCommand(["setVariable", "MACHINE", machine]) @@ -232,62 +295,78 @@ class HobHandler(gobject.GObject): def set_sdk_machine(self, sdk_machine): self.server.runCommand(["setVariable", "SDKMACHINE", sdk_machine]) + def set_image_fstypes(self, image_fstypes): + self.server.runCommand(["setVariable", "IMAGE_FSTYPES", " ".join(image_fstypes).lstrip(" ")]) + def set_distro(self, distro): self.server.runCommand(["setVariable", "DISTRO", distro]) def set_package_format(self, format): - self.server.runCommand(["setVariable", "PACKAGE_CLASSES", "package_%s" % format]) - - def reload_data(self, config=None): - img = self.model.selected_image - selected_packages, _ = self.model.get_selected_packages() - self.emit("reload-triggered", img, " ".join(selected_packages)) - self.current_command = self.REPARSE_FILES - self.run_next_command() + package_classes = "" + for pkgfmt in format.split(): + package_classes += ("package_%s" % pkgfmt + " ") + self.server.runCommand(["setVariable", "PACKAGE_CLASSES", package_classes]) def set_bbthreads(self, threads): self.server.runCommand(["setVariable", "BB_NUMBER_THREADS", threads]) def set_pmake(self, threads): pmake = "-j %s" % threads - self.server.runCommand(["setVariable", "BB_NUMBER_THREADS", pmake]) + self.server.runCommand(["setVariable", "PARALLEL_MAKE", pmake]) - def build_targets(self, tgts, configurator, build_type="image"): - self.build_type = build_type - targets = [] - nbbp = None - nbbf = None - targets.extend(tgts) - if self.build_toolchain and self.build_toolchain_headers: - targets.append("meta-toolchain-sdk") - elif self.build_toolchain: - targets.append("meta-toolchain") - self.build_queue = targets - - if not self.bbpath_ok: - if self.image_dir in self.bbpath.split(":"): - self.bbpath_ok = True - else: - nbbp = self.image_dir + def set_dl_dir(self, directory): + self.server.runCommand(["setVariable", "DL_DIR", directory]) + + def set_sstate_dir(self, directory): + self.server.runCommand(["setVariable", "SSTATE_DIR", directory]) - if not self.bbfiles_ok: - import re - pattern = "%s/\*.bb" % self.image_dir + def set_sstate_mirror(self, url): + self.server.runCommand(["setVariable", "SSTATE_MIRROR", url]) - for files in self.bbfiles.split(" "): - if re.match(pattern, files): - self.bbfiles_ok = True + def set_extra_size(self, image_extra_size): + self.server.runCommand(["setVariable", "IMAGE_ROOTFS_EXTRA_SPACE", str(image_extra_size)]) - if not self.bbfiles_ok: - nbbf = "%s/*.bb" % self.image_dir + def set_rootfs_size(self, image_rootfs_size): + self.server.runCommand(["setVariable", "IMAGE_ROOTFS_SIZE", str(image_rootfs_size)]) - if nbbp or nbbf: - configurator.insertTempBBPath(nbbp, nbbf) - self.bbpath_ok = True - self.bbfiles_ok = True + def set_incompatible_license(self, incompat_license): + self.server.runCommand(["setVariable", "INCOMPATIBLE_LICENSE", incompat_license]) - self.current_command = self.REPARSE_FILES - self.run_next_command() + def set_extra_config(self, extra_setting): + for key in extra_setting.keys(): + value = extra_setting[key] + self.server.runCommand(["setVariable", key, value]) + + def request_package_info_async(self): + self.commands_async.append(self.GENERATE_PACKAGEINFO) + self.run_next_command(self.POPULATE_PACKAGEINFO) + + def generate_recipes(self): + self.commands_async.append(self.PARSE_CONFIG) + self.commands_async.append(self.GENERATE_TGTS) + self.run_next_command(self.GENERATE_RECIPES) + + def generate_packages(self, tgts): + targets = [] + targets.extend(tgts) + self.recipe_queue = targets + self.commands_async.append(self.PARSE_CONFIG) + self.commands_async.append(self.PARSE_BBFILES) + self.commands_async.append(self.BUILD_TARGET_RECIPES) + self.run_next_command(self.GENERATE_PACKAGES) + + def generate_image(self, tgts, toolchain_build=False): + self.package_queue = tgts + self.toolchain_build = toolchain_build + self.commands_async.append(self.PARSE_CONFIG) + self.commands_async.append(self.PARSE_BBFILES) + self.commands_async.append(self.BUILD_TARGET_IMAGE) + self.run_next_command(self.GENERATE_IMAGE) + + def build_failed_async(self): + self.initcmd = None + self.commands_async = [] + self.building = False def cancel_build(self, force=False): if force: @@ -298,46 +377,83 @@ class HobHandler(gobject.GObject): # leave the workdir in a usable state self.server.runCommand(["stateShutdown"]) - def set_incompatible_license(self, incompatible): - self.server.runCommand(["setVariable", "INCOMPATIBLE_LICENSE", incompatible]) - - def toggle_toolchain(self, enabled): - if self.build_toolchain != enabled: - self.build_toolchain = enabled - - def toggle_toolchain_headers(self, enabled): - if self.build_toolchain_headers != enabled: - self.build_toolchain_headers = enabled - - def set_fstypes(self, fstypes): - self.server.runCommand(["setVariable", "IMAGE_FSTYPES", fstypes]) - - def add_image_output_type(self, output_type): - if output_type not in self.image_output_types: - self.image_output_types.append(output_type) - fstypes = " ".join(self.image_output_types).lstrip(" ") - self.set_fstypes(fstypes) - return self.image_output_types - - def remove_image_output_type(self, output_type): - if output_type in self.image_output_types: - ind = self.image_output_types.index(output_type) - self.image_output_types.pop(ind) - fstypes = " ".join(self.image_output_types).lstrip(" ") - self.set_fstypes(fstypes) - return self.image_output_types - - def get_image_deploy_dir(self): - return self.image_out_dir - - def make_temp_dir(self): - bb.utils.mkdirhier(self.image_dir) - - def remove_temp_dir(self): - bb.utils.remove(self.image_dir, True) - - def get_temp_recipe_path(self, name): - timestamp = datetime.date.today().isoformat() - image_file = "hob-%s-variant-%s.bb" % (name, timestamp) - recipepath = os.path.join(self.image_dir, image_file) - return recipepath + def reset_server(self): + self.server.runCommand(["resetCooker"]) + + def reset_build(self): + self.build.reset() + + def get_parameters(self): + # retrieve the parameters from bitbake + params = {} + params["core_base"] = self.server.runCommand(["getVariable", "COREBASE"]) or "" + hob_layer = params["core_base"] + "/meta-hob" + params["layer"] = (self.server.runCommand(["getVariable", "BBLAYERS"]) or "") + " " + hob_layer + params["dldir"] = self.server.runCommand(["getVariable", "DL_DIR"]) or "" + params["machine"] = self.server.runCommand(["getVariable", "MACHINE"]) or "" + params["distro"] = self.server.runCommand(["getVariable", "DISTRO"]) or "defaultsetup" + params["pclass"] = self.server.runCommand(["getVariable", "PACKAGE_CLASSES"]) or "" + params["sstatedir"] = self.server.runCommand(["getVariable", "SSTATE_DIR"]) or "" + params["sstatemirror"] = self.server.runCommand(["getVariable", "SSTATE_MIRROR"]) or "" + + num_threads = self.server.runCommand(["getCpuCount"]) + if not num_threads: + num_threads = 1 + max_threads = 65536 + else: + num_threads = int(num_threads) + max_threads = 16 * num_threads + params["max_threads"] = max_threads + + bbthread = self.server.runCommand(["getVariable", "BB_NUMBER_THREADS"]) + if not bbthread: + bbthread = num_threads + else: + bbthread = int(bbthread) + params["bbthread"] = bbthread + + pmake = self.server.runCommand(["getVariable", "PARALLEL_MAKE"]) + if not pmake: + pmake = num_threads + elif isinstance(pmake, int): + pass + else: + pmake = int(pmake.lstrip("-j ")) + params["pmake"] = pmake + + image_addr = self.server.runCommand(["getVariable", "DEPLOY_DIR_IMAGE"]) or "" + if self.server_addr: + image_addr = "http://" + self.server_addr + ":" + image_addr + params["image_addr"] = image_addr + + image_extra_size = self.server.runCommand(["getVariable", "IMAGE_ROOTFS_EXTRA_SPACE"]) + if not image_extra_size: + image_extra_size = 0 + else: + image_extra_size = int(image_extra_size) + params["image_extra_size"] = image_extra_size + + image_rootfs_size = self.server.runCommand(["getVariable", "IMAGE_ROOTFS_SIZE"]) + if not image_rootfs_size: + image_rootfs_size = 0 + else: + image_rootfs_size = int(image_rootfs_size) + params["image_rootfs_size"] = image_rootfs_size + + image_overhead_factor = self.server.runCommand(["getVariable", "IMAGE_OVERHEAD_FACTOR"]) + if not image_overhead_factor: + image_overhead_factor = 1 + else: + image_overhead_factor = float(image_overhead_factor) + params['image_overhead_factor'] = image_overhead_factor + + params["incompat_license"] = self.server.runCommand(["getVariable", "INCOMPATIBLE_LICENSE"]) or "" + params["sdk_machine"] = self.server.runCommand(["getVariable", "SDKMACHINE"]) or self.server.runCommand(["getVariable", "SDK_ARCH"]) or "" + + #params["image_types"] = self.server.runCommand(["getVariable", "IMAGE_TYPES"]) or "" + params["image_fstypes"] = self.server.runCommand(["getVariable", "IMAGE_FSTYPES"]) or "" + """ + A workaround + """ + params["image_types"] = "jffs2 sum.jffs2 cramfs ext2 ext2.gz ext2.bz2 ext3 ext3.gz ext2.lzma btrfs live squashfs squashfs-lzma ubi tar tar.gz tar.bz2 tar.xz cpio cpio.gz cpio.xz cpio.lzma" + return params -- cgit v1.2.3-54-g00ecf