Squashed 'yocto-poky/' content from commit ea562de
git-subtree-dir: yocto-poky
git-subtree-split: ea562de57590c966cd5a75fda8defecd397e6436
diff --git a/bitbake/lib/bb/ui/crumbs/hobeventhandler.py b/bitbake/lib/bb/ui/crumbs/hobeventhandler.py
new file mode 100644
index 0000000..b71fb33
--- /dev/null
+++ b/bitbake/lib/bb/ui/crumbs/hobeventhandler.py
@@ -0,0 +1,645 @@
+#
+# BitBake Graphical GTK User Interface
+#
+# Copyright (C) 2011 Intel Corporation
+#
+# Authored by Joshua Lock <josh@linux.intel.com>
+# Authored by Dongxiao Xu <dongxiao.xu@intel.com>
+#
+# 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
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import gobject
+import logging
+import ast
+from bb.ui.crumbs.runningbuild import RunningBuild
+
+class HobHandler(gobject.GObject):
+
+ """
+ This object does BitBake event handling for the hob gui.
+ """
+ __gsignals__ = {
+ "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,)),
+ "parsing-warning" : (gobject.SIGNAL_RUN_LAST,
+ gobject.TYPE_NONE,
+ (gobject.TYPE_STRING,)),
+ "sanity-failed" : (gobject.SIGNAL_RUN_LAST,
+ gobject.TYPE_NONE,
+ (gobject.TYPE_STRING, gobject.TYPE_INT)),
+ "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,)),
+ "recipe-populated" : (gobject.SIGNAL_RUN_LAST,
+ gobject.TYPE_NONE,
+ ()),
+ "package-populated" : (gobject.SIGNAL_RUN_LAST,
+ gobject.TYPE_NONE,
+ ()),
+ "network-passed" : (gobject.SIGNAL_RUN_LAST,
+ gobject.TYPE_NONE,
+ ()),
+ "network-failed" : (gobject.SIGNAL_RUN_LAST,
+ gobject.TYPE_NONE,
+ ()),
+ }
+
+ (GENERATE_CONFIGURATION, GENERATE_RECIPES, GENERATE_PACKAGES, GENERATE_IMAGE, POPULATE_PACKAGEINFO, SANITY_CHECK, NETWORK_TEST) = range(7)
+ (SUB_PATH_LAYERS, SUB_FILES_DISTRO, SUB_FILES_MACH, SUB_FILES_SDKMACH, SUB_MATCH_CLASS, SUB_PARSE_CONFIG, SUB_SANITY_CHECK,
+ SUB_GNERATE_TGTS, SUB_GENERATE_PKGINFO, SUB_BUILD_RECIPES, SUB_BUILD_IMAGE, SUB_NETWORK_TEST) = range(12)
+
+ def __init__(self, server, recipe_model, package_model):
+ super(HobHandler, self).__init__()
+
+ self.build = RunningBuild(sequential=True)
+
+ self.recipe_model = recipe_model
+ self.package_model = package_model
+
+ self.commands_async = []
+ self.generating = False
+ self.current_phase = None
+ self.building = False
+ self.recipe_queue = []
+ self.package_queue = []
+
+ self.server = server
+ self.error_msg = ""
+ self.initcmd = None
+ self.parsing = False
+
+ def set_busy(self):
+ if not self.generating:
+ self.emit("generating-data")
+ self.generating = True
+
+ def clear_busy(self):
+ if self.generating:
+ self.emit("data-generated")
+ self.generating = False
+
+ def runCommand(self, commandline):
+ try:
+ result, error = self.server.runCommand(commandline)
+ if error:
+ raise Exception("Error running command '%s': %s" % (commandline, error))
+ return result
+ except Exception as e:
+ self.commands_async = []
+ self.clear_busy()
+ self.emit("command-failed", "Hob Exception - %s" % (str(e)))
+ return None
+
+ 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.SUB_PATH_LAYERS:
+ self.runCommand(["findConfigFilePath", "bblayers.conf"])
+ elif next_command == self.SUB_FILES_DISTRO:
+ self.runCommand(["findConfigFiles", "DISTRO"])
+ elif next_command == self.SUB_FILES_MACH:
+ self.runCommand(["findConfigFiles", "MACHINE"])
+ elif next_command == self.SUB_FILES_SDKMACH:
+ self.runCommand(["findConfigFiles", "MACHINE-SDK"])
+ elif next_command == self.SUB_MATCH_CLASS:
+ self.runCommand(["findFilesMatchingInDir", "rootfs_", "classes"])
+ elif next_command == self.SUB_PARSE_CONFIG:
+ self.runCommand(["resetCooker"])
+ elif next_command == self.SUB_GNERATE_TGTS:
+ self.runCommand(["generateTargetsTree", "classes/image.bbclass", []])
+ elif next_command == self.SUB_GENERATE_PKGINFO:
+ self.runCommand(["triggerEvent", "bb.event.RequestPackageInfo()"])
+ elif next_command == self.SUB_SANITY_CHECK:
+ self.runCommand(["triggerEvent", "bb.event.SanityCheck()"])
+ elif next_command == self.SUB_NETWORK_TEST:
+ self.runCommand(["triggerEvent", "bb.event.NetworkTest()"])
+ elif next_command == self.SUB_BUILD_RECIPES:
+ self.clear_busy()
+ self.building = True
+ self.runCommand(["buildTargets", self.recipe_queue, self.default_task])
+ self.recipe_queue = []
+ elif next_command == self.SUB_BUILD_IMAGE:
+ self.clear_busy()
+ self.building = True
+ target = self.image
+
+ if self.base_image:
+ # Request the build of a custom image
+ self.generate_hob_base_image(target)
+ self.set_var_in_file("LINGUAS_INSTALL", "", "local.conf")
+ hobImage = self.runCommand(["matchFile", target + ".bb"])
+ if self.base_image != self.recipe_model.__custom_image__:
+ baseImage = self.runCommand(["matchFile", self.base_image + ".bb"])
+ version = self.runCommand(["generateNewImage", hobImage, baseImage, self.package_queue, True, ""])
+ target += version
+ self.recipe_model.set_custom_image_version(version)
+
+ targets = [target]
+ if self.toolchain_packages:
+ self.set_var_in_file("TOOLCHAIN_TARGET_TASK", " ".join(self.toolchain_packages), "local.conf")
+ targets.append(target + ":do_populate_sdk")
+
+ self.runCommand(["buildTargets", targets, self.default_task])
+
+ def display_error(self):
+ self.clear_busy()
+ self.emit("command-failed", self.error_msg)
+ self.error_msg = ""
+ if self.building:
+ self.building = False
+
+ def handle_event(self, event):
+ if not event:
+ return
+ if self.building:
+ self.current_phase = "building"
+ self.build.handle_event(event)
+
+ if isinstance(event, bb.event.PackageInfo):
+ self.package_model.populate(event._pkginfolist)
+ self.emit("package-populated")
+ self.run_next_command()
+
+ elif isinstance(event, bb.event.SanityCheckPassed):
+ reparse = self.runCommand(["getVariable", "BB_INVALIDCONF"]) or None
+ if reparse is True:
+ self.set_var_in_file("BB_INVALIDCONF", False, "local.conf")
+ self.runCommand(["setPrePostConfFiles", "conf/.hob.conf", ""])
+ self.commands_async.prepend(self.SUB_PARSE_CONFIG)
+ self.run_next_command()
+
+ elif isinstance(event, bb.event.SanityCheckFailed):
+ self.emit("sanity-failed", event._msg, event._network_error)
+
+ elif isinstance(event, logging.LogRecord):
+ if not self.building:
+ if event.levelno >= logging.ERROR:
+ formatter = bb.msg.BBLogFormatter()
+ msg = formatter.format(event)
+ self.error_msg += msg + '\n'
+ elif event.levelno >= logging.WARNING and self.parsing == True:
+ formatter = bb.msg.BBLogFormatter()
+ msg = formatter.format(event)
+ warn_msg = msg + '\n'
+ self.emit("parsing-warning", warn_msg)
+
+ elif isinstance(event, bb.event.TargetsTreeGenerated):
+ self.current_phase = "data generation"
+ if event._model:
+ self.recipe_model.populate(event._model)
+ self.emit("recipe-populated")
+ elif isinstance(event, bb.event.ConfigFilesFound):
+ self.current_phase = "configuration lookup"
+ var = event._variable
+ values = event._values
+ values.sort()
+ self.emit("config-updated", var, values)
+ elif isinstance(event, bb.event.ConfigFilePathFound):
+ self.current_phase = "configuration lookup"
+ elif isinstance(event, bb.event.FilesMatchingFound):
+ self.current_phase = "configuration lookup"
+ # FIXME: hard coding, should at least be a variable shared between
+ # here and the caller
+ if event._pattern == "rootfs_":
+ formats = []
+ for match in event._matches:
+ classname, sep, cls = match.rpartition(".")
+ fs, sep, format = classname.rpartition("_")
+ formats.append(format)
+ formats.sort()
+ self.emit("package-formats-updated", formats)
+ elif isinstance(event, bb.command.CommandCompleted):
+ self.current_phase = None
+ self.run_next_command()
+ elif isinstance(event, bb.command.CommandFailed):
+ if event.error not in ("Forced shutdown", "Stopped build"):
+ self.error_msg += event.error
+ self.commands_async = []
+ self.display_error()
+ 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)
+ if isinstance(event, bb.event.ParseStarted):
+ self.parsing = True
+ 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)
+ if isinstance(event, bb.event.ParseCompleted):
+ self.parsing = False
+ elif isinstance(event, bb.event.NetworkTestFailed):
+ self.emit("network-failed")
+ self.run_next_command()
+ elif isinstance(event, bb.event.NetworkTestPassed):
+ self.emit("network-passed")
+ self.run_next_command()
+
+ if self.error_msg and not self.commands_async:
+ self.display_error()
+
+ return
+
+ def init_cooker(self):
+ self.runCommand(["createConfigFile", ".hob.conf"])
+
+ def set_extra_inherit(self, bbclass):
+ self.append_var_in_file("INHERIT", bbclass, ".hob.conf")
+
+ def set_bblayers(self, bblayers):
+ self.set_var_in_file("BBLAYERS", " ".join(bblayers), "bblayers.conf")
+
+ def set_machine(self, machine):
+ if machine:
+ self.early_assign_var_in_file("MACHINE", machine, "local.conf")
+
+ def set_sdk_machine(self, sdk_machine):
+ self.set_var_in_file("SDKMACHINE", sdk_machine, "local.conf")
+
+ def set_image_fstypes(self, image_fstypes):
+ self.set_var_in_file("IMAGE_FSTYPES", image_fstypes, "local.conf")
+
+ def set_distro(self, distro):
+ self.set_var_in_file("DISTRO", distro, "local.conf")
+
+ def set_package_format(self, format):
+ package_classes = ""
+ for pkgfmt in format.split():
+ package_classes += ("package_%s" % pkgfmt + " ")
+ self.set_var_in_file("PACKAGE_CLASSES", package_classes, "local.conf")
+
+ def set_bbthreads(self, threads):
+ self.set_var_in_file("BB_NUMBER_THREADS", threads, "local.conf")
+
+ def set_pmake(self, threads):
+ pmake = "-j %s" % threads
+ self.set_var_in_file("PARALLEL_MAKE", pmake, "local.conf")
+
+ def set_dl_dir(self, directory):
+ self.set_var_in_file("DL_DIR", directory, "local.conf")
+
+ def set_sstate_dir(self, directory):
+ self.set_var_in_file("SSTATE_DIR", directory, "local.conf")
+
+ def set_sstate_mirrors(self, url):
+ self.set_var_in_file("SSTATE_MIRRORS", url, "local.conf")
+
+ def set_extra_size(self, image_extra_size):
+ self.set_var_in_file("IMAGE_ROOTFS_EXTRA_SPACE", str(image_extra_size), "local.conf")
+
+ def set_rootfs_size(self, image_rootfs_size):
+ self.set_var_in_file("IMAGE_ROOTFS_SIZE", str(image_rootfs_size), "local.conf")
+
+ def set_incompatible_license(self, incompat_license):
+ self.set_var_in_file("INCOMPATIBLE_LICENSE", incompat_license, "local.conf")
+
+ def set_extra_setting(self, extra_setting):
+ self.set_var_in_file("EXTRA_SETTING", extra_setting, "local.conf")
+
+ def set_extra_config(self, extra_setting):
+ old_extra_setting = self.runCommand(["getVariable", "EXTRA_SETTING"]) or {}
+ old_extra_setting = str(old_extra_setting)
+
+ old_extra_setting = ast.literal_eval(old_extra_setting)
+ if not type(old_extra_setting) == dict:
+ old_extra_setting = {}
+
+ # settings not changed
+ if old_extra_setting == extra_setting:
+ return
+
+ # remove the old EXTRA SETTING variable
+ self.remove_var_from_file("EXTRA_SETTING")
+
+ # remove old settings from conf
+ for key in old_extra_setting.keys():
+ if key not in extra_setting:
+ self.remove_var_from_file(key)
+
+ # add new settings
+ for key, value in extra_setting.iteritems():
+ self.set_var_in_file(key, value, "local.conf")
+
+ if extra_setting:
+ self.set_var_in_file("EXTRA_SETTING", extra_setting, "local.conf")
+
+ def set_http_proxy(self, http_proxy):
+ self.set_var_in_file("http_proxy", http_proxy, "local.conf")
+
+ def set_https_proxy(self, https_proxy):
+ self.set_var_in_file("https_proxy", https_proxy, "local.conf")
+
+ def set_ftp_proxy(self, ftp_proxy):
+ self.set_var_in_file("ftp_proxy", ftp_proxy, "local.conf")
+
+ def set_socks_proxy(self, socks_proxy):
+ self.set_var_in_file("all_proxy", socks_proxy, "local.conf")
+
+ def set_cvs_proxy(self, host, port):
+ self.set_var_in_file("CVS_PROXY_HOST", host, "local.conf")
+ self.set_var_in_file("CVS_PROXY_PORT", port, "local.conf")
+
+ def request_package_info(self):
+ self.commands_async.append(self.SUB_GENERATE_PKGINFO)
+ self.run_next_command(self.POPULATE_PACKAGEINFO)
+
+ def trigger_sanity_check(self):
+ self.commands_async.append(self.SUB_SANITY_CHECK)
+ self.run_next_command(self.SANITY_CHECK)
+
+ def trigger_network_test(self):
+ self.commands_async.append(self.SUB_NETWORK_TEST)
+ self.run_next_command(self.NETWORK_TEST)
+
+ def generate_configuration(self):
+ self.runCommand(["setPrePostConfFiles", "conf/.hob.conf", ""])
+ self.commands_async.append(self.SUB_PARSE_CONFIG)
+ self.commands_async.append(self.SUB_PATH_LAYERS)
+ self.commands_async.append(self.SUB_FILES_DISTRO)
+ self.commands_async.append(self.SUB_FILES_MACH)
+ self.commands_async.append(self.SUB_FILES_SDKMACH)
+ self.commands_async.append(self.SUB_MATCH_CLASS)
+ self.run_next_command(self.GENERATE_CONFIGURATION)
+
+ def generate_recipes(self):
+ self.runCommand(["setPrePostConfFiles", "conf/.hob.conf", ""])
+ self.commands_async.append(self.SUB_PARSE_CONFIG)
+ self.commands_async.append(self.SUB_GNERATE_TGTS)
+ self.run_next_command(self.GENERATE_RECIPES)
+
+ def generate_packages(self, tgts, default_task="build"):
+ targets = []
+ targets.extend(tgts)
+ self.recipe_queue = targets
+ self.default_task = default_task
+ self.runCommand(["setPrePostConfFiles", "conf/.hob.conf", ""])
+ self.commands_async.append(self.SUB_PARSE_CONFIG)
+ self.commands_async.append(self.SUB_BUILD_RECIPES)
+ self.run_next_command(self.GENERATE_PACKAGES)
+
+ def generate_image(self, image, base_image, image_packages=None, toolchain_packages=None, default_task="build"):
+ self.image = image
+ self.base_image = base_image
+ if image_packages:
+ self.package_queue = image_packages
+ else:
+ self.package_queue = []
+ if toolchain_packages:
+ self.toolchain_packages = toolchain_packages
+ else:
+ self.toolchain_packages = []
+ self.default_task = default_task
+ self.runCommand(["setPrePostConfFiles", "conf/.hob.conf", ""])
+ self.commands_async.append(self.SUB_PARSE_CONFIG)
+ self.commands_async.append(self.SUB_BUILD_IMAGE)
+ self.run_next_command(self.GENERATE_IMAGE)
+
+ def generate_new_image(self, image, base_image, package_queue, description):
+ if base_image:
+ base_image = self.runCommand(["matchFile", self.base_image + ".bb"])
+ self.runCommand(["generateNewImage", image, base_image, package_queue, False, description])
+
+ def generate_hob_base_image(self, hob_image):
+ image_dir = self.get_topdir() + "/recipes/images/"
+ recipe_name = hob_image + ".bb"
+ self.ensure_dir(image_dir)
+ self.generate_new_image(image_dir + recipe_name, None, [], "")
+
+ def ensure_dir(self, directory):
+ self.runCommand(["ensureDir", directory])
+
+ def build_succeeded_async(self):
+ self.building = False
+
+ def build_failed_async(self):
+ self.initcmd = None
+ self.commands_async = []
+ self.building = False
+
+ def cancel_parse(self):
+ self.runCommand(["stateForceShutdown"])
+
+ def cancel_build(self, force=False):
+ if force:
+ # Force the cooker to stop as quickly as possible
+ self.runCommand(["stateForceShutdown"])
+ else:
+ # Wait for tasks to complete before shutting down, this helps
+ # leave the workdir in a usable state
+ self.runCommand(["stateShutdown"])
+
+ def reset_build(self):
+ self.build.reset()
+
+ def get_logfile(self):
+ return self.server.runCommand(["getVariable", "BB_CONSOLELOG"])[0]
+
+ def get_topdir(self):
+ return self.runCommand(["getVariable", "TOPDIR"]) or ""
+
+ def _remove_redundant(self, string):
+ ret = []
+ for i in string.split():
+ if i not in ret:
+ ret.append(i)
+ return " ".join(ret)
+
+ def set_var_in_file(self, var, val, default_file=None):
+ self.runCommand(["enableDataTracking"])
+ self.server.runCommand(["setVarFile", var, val, default_file, "set"])
+ self.runCommand(["disableDataTracking"])
+
+ def early_assign_var_in_file(self, var, val, default_file=None):
+ self.runCommand(["enableDataTracking"])
+ self.server.runCommand(["setVarFile", var, val, default_file, "earlyAssign"])
+ self.runCommand(["disableDataTracking"])
+
+ def remove_var_from_file(self, var):
+ self.server.runCommand(["removeVarFile", var])
+
+ def append_var_in_file(self, var, val, default_file=None):
+ self.server.runCommand(["setVarFile", var, val, default_file, "append"])
+
+ def append_to_bbfiles(self, val):
+ bbfiles = self.runCommand(["getVariable", "BBFILES", "False"]) or ""
+ bbfiles = bbfiles.split()
+ if val not in bbfiles:
+ self.append_var_in_file("BBFILES", val, "bblayers.conf")
+
+ def get_parameters(self):
+ # retrieve the parameters from bitbake
+ params = {}
+ params["core_base"] = self.runCommand(["getVariable", "COREBASE"]) or ""
+ params["layer"] = self.runCommand(["getVariable", "BBLAYERS"]) or ""
+ params["layers_non_removable"] = self.runCommand(["getVariable", "BBLAYERS_NON_REMOVABLE"]) or ""
+ params["dldir"] = self.runCommand(["getVariable", "DL_DIR"]) or ""
+ params["machine"] = self.runCommand(["getVariable", "MACHINE"]) or ""
+ params["distro"] = self.runCommand(["getVariable", "DISTRO"]) or "defaultsetup"
+ params["pclass"] = self.runCommand(["getVariable", "PACKAGE_CLASSES"]) or ""
+ params["sstatedir"] = self.runCommand(["getVariable", "SSTATE_DIR"]) or ""
+ params["sstatemirror"] = self.runCommand(["getVariable", "SSTATE_MIRRORS"]) or ""
+
+ num_threads = self.runCommand(["getCpuCount"])
+ if not num_threads:
+ num_threads = 1
+ max_threads = 65536
+ else:
+ try:
+ num_threads = int(num_threads)
+ max_threads = 16 * num_threads
+ except:
+ num_threads = 1
+ max_threads = 65536
+ params["max_threads"] = max_threads
+
+ bbthread = self.runCommand(["getVariable", "BB_NUMBER_THREADS"])
+ if not bbthread:
+ bbthread = num_threads
+ else:
+ try:
+ bbthread = int(bbthread)
+ except:
+ bbthread = num_threads
+ params["bbthread"] = bbthread
+
+ pmake = self.runCommand(["getVariable", "PARALLEL_MAKE"])
+ if not pmake:
+ pmake = num_threads
+ elif isinstance(pmake, int):
+ pass
+ else:
+ try:
+ pmake = int(pmake.lstrip("-j "))
+ except:
+ pmake = num_threads
+ params["pmake"] = "-j %s" % pmake
+
+ params["image_addr"] = self.runCommand(["getVariable", "DEPLOY_DIR_IMAGE"]) or ""
+
+ image_extra_size = self.runCommand(["getVariable", "IMAGE_ROOTFS_EXTRA_SPACE"])
+ if not image_extra_size:
+ image_extra_size = 0
+ else:
+ try:
+ image_extra_size = int(image_extra_size)
+ except:
+ image_extra_size = 0
+ params["image_extra_size"] = image_extra_size
+
+ image_rootfs_size = self.runCommand(["getVariable", "IMAGE_ROOTFS_SIZE"])
+ if not image_rootfs_size:
+ image_rootfs_size = 0
+ else:
+ try:
+ image_rootfs_size = int(image_rootfs_size)
+ except:
+ image_rootfs_size = 0
+ params["image_rootfs_size"] = image_rootfs_size
+
+ image_overhead_factor = self.runCommand(["getVariable", "IMAGE_OVERHEAD_FACTOR"])
+ if not image_overhead_factor:
+ image_overhead_factor = 1
+ else:
+ try:
+ image_overhead_factor = float(image_overhead_factor)
+ except:
+ image_overhead_factor = 1
+ params['image_overhead_factor'] = image_overhead_factor
+
+ params["incompat_license"] = self._remove_redundant(self.runCommand(["getVariable", "INCOMPATIBLE_LICENSE"]) or "")
+ params["sdk_machine"] = self.runCommand(["getVariable", "SDKMACHINE"]) or self.runCommand(["getVariable", "SDK_ARCH"]) or ""
+
+ params["image_fstypes"] = self._remove_redundant(self.runCommand(["getVariable", "IMAGE_FSTYPES"]) or "")
+
+ params["image_types"] = self._remove_redundant(self.runCommand(["getVariable", "IMAGE_TYPES"]) or "")
+
+ params["conf_version"] = self.runCommand(["getVariable", "CONF_VERSION"]) or ""
+ params["lconf_version"] = self.runCommand(["getVariable", "LCONF_VERSION"]) or ""
+
+ params["runnable_image_types"] = self._remove_redundant(self.runCommand(["getVariable", "RUNNABLE_IMAGE_TYPES"]) or "")
+ params["runnable_machine_patterns"] = self._remove_redundant(self.runCommand(["getVariable", "RUNNABLE_MACHINE_PATTERNS"]) or "")
+ params["deployable_image_types"] = self._remove_redundant(self.runCommand(["getVariable", "DEPLOYABLE_IMAGE_TYPES"]) or "")
+ params["kernel_image_type"] = self.runCommand(["getVariable", "KERNEL_IMAGETYPE"]) or ""
+ params["tmpdir"] = self.runCommand(["getVariable", "TMPDIR"]) or ""
+ params["distro_version"] = self.runCommand(["getVariable", "DISTRO_VERSION"]) or ""
+ params["target_os"] = self.runCommand(["getVariable", "TARGET_OS"]) or ""
+ params["target_arch"] = self.runCommand(["getVariable", "TARGET_ARCH"]) or ""
+ params["tune_pkgarch"] = self.runCommand(["getVariable", "TUNE_PKGARCH"]) or ""
+ params["bb_version"] = self.runCommand(["getVariable", "BB_MIN_VERSION"]) or ""
+
+ params["default_task"] = self.runCommand(["getVariable", "BB_DEFAULT_TASK"]) or "build"
+
+ params["socks_proxy"] = self.runCommand(["getVariable", "all_proxy"]) or ""
+ params["http_proxy"] = self.runCommand(["getVariable", "http_proxy"]) or ""
+ params["ftp_proxy"] = self.runCommand(["getVariable", "ftp_proxy"]) or ""
+ params["https_proxy"] = self.runCommand(["getVariable", "https_proxy"]) or ""
+
+ params["cvs_proxy_host"] = self.runCommand(["getVariable", "CVS_PROXY_HOST"]) or ""
+ params["cvs_proxy_port"] = self.runCommand(["getVariable", "CVS_PROXY_PORT"]) or ""
+
+ params["image_white_pattern"] = self.runCommand(["getVariable", "BBUI_IMAGE_WHITE_PATTERN"]) or ""
+ params["image_black_pattern"] = self.runCommand(["getVariable", "BBUI_IMAGE_BLACK_PATTERN"]) or ""
+ return params