diff options
Diffstat (limited to 'bitbake/lib/bb/ui/crumbs/hobeventhandler.py')
| -rw-r--r-- | bitbake/lib/bb/ui/crumbs/hobeventhandler.py | 645 |
1 files changed, 645 insertions, 0 deletions
diff --git a/bitbake/lib/bb/ui/crumbs/hobeventhandler.py b/bitbake/lib/bb/ui/crumbs/hobeventhandler.py new file mode 100644 index 000000000..b71fb33d3 --- /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 |
