systemd: don't install quotaon.service twice

If the same file is installed twice there's a race which can lead to "make
install" failing.  Remove the redundant installation of quotaon.service to
eliminate the race.

(From OE-Core master rev: c6c5c2285e1b6cb3598ccba08aee3dfd090e7129)

(From OE-Core rev: 7b8dd3b5547b501e94a6887d3be5c2bbb8845ec8)

Signed-off-by: Ross Burton <ross.burton@intel.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>

README.hardware

@@ -59,7 +59,7 @@ Consumer Devices
 
 The following consumer devices are supported by the meta-yocto-bsp layer:
 
-  * Intel x86 based PCs and devices (genericx86)
+  * Intel Atom based PCs and devices (atom-pc)
 
 For more information see the device's section below. The appropriate MACHINE
 variable value corresponding to the device is given in brackets.
@@ -70,37 +70,19 @@ variable value corresponding to the device is given in brackets.
                       ===============================
 
 
-Intel x86 based PCs and devices (genericx86)
+Intel Atom based PCs and devices (atom-pc)
 ==========================================
 
-The genericx86 MACHINE is tested on the following platforms:
+The atom-pc MACHINE is tested on the following platforms:
 
-Intel Xeon/Core i-Series:
-  + Intel Romley Server: Sandy Bridge Xeon processor, C600 PCH (Patsburg), (Canoe Pass CRB)
-  + Intel Romley Server: Ivy Bridge Xeon processor, C600 PCH (Patsburg), (Intel SDP S2R3)
-  + Intel Crystal Forest Server: Sandy Bridge Xeon processor, DH89xx PCH (Cave Creek), (Stargo CRB)
-  + Intel Chief River Mobile: Ivy Bridge Mobile processor, QM77 PCH (Panther Point-M), (Emerald Lake II CRB, Sabino Canyon CRB)
-  + Intel Huron River Mobile: Sandy Bridge processor, QM67 PCH (Cougar Point), (Emerald Lake CRB, EVOC EC7-1817LNAR board)
-  + Intel Calpella Platform: Core i7 processor, QM57 PCH (Ibex Peak-M), (Red Fort CRB, Emerson MATXM CORE-411-B)
-  + Intel Nehalem/Westmere-EP Server: Xeon 56xx/55xx processors, 5520 chipset, ICH10R IOH (82801), (Hanlan Creek CRB)
-  + Intel Nehalem Workstation: Xeon 56xx/55xx processors, System SC5650SCWS (Greencity CRB)
-  + Intel Picket Post Server: Xeon 56xx/55xx processors (Jasper Forest), 3420 chipset (Ibex Peak), (Osage CRB)
-  + Intel Storage Platform: Sandy Bridge Xeon processor, C600 PCH (Patsburg), (Oak Creek Canyon CRB)
-  + Intel Shark Bay Client Platform: Haswell processor, LynxPoint PCH, (Walnut Canyon CRB, Lava Canyon CRB, Basking Ridge CRB, Flathead Creek CRB)
-  + Intel Shark Bay Ultrabook Platform: Haswell ULT processor, Lynx Point-LP PCH, (WhiteTip Mountain 1 CRB)
+  o Asus EeePC 901
+  o Acer Aspire One
+  o Toshiba NB305
+  o Intel Embedded Development Board 1-N450 (Black Sand)
 
-Intel Atom platforms:
-  + Intel embedded Menlow: Intel Atom Z510/530 CPU, System Controller Hub US15W (Portwell NANO-8044)
-  + Intel Luna Pier: Intel Atom N4xx/D5xx series CPU (aka: Pineview-D & -M), 82801HM I/O Hub (ICH8M), (Advantech AIMB-212, Moon Creek CRB)
-  + Intel Queens Bay platform: Intel Atom E6xx CPU (aka: Tunnel Creek), Topcliff EG20T I/O Hub (Emerson NITX-315, Crown Bay CRB, Minnow Board)
-  + Intel Fish River Island platform: Intel Atom E6xx CPU (aka: Tunnel Creek), Topcliff EG20T I/O Hub (Kontron KM2M806)
-  + Intel Cedar Trail platform: Intel Atom N2000 & D2000 series CPU (aka: Cedarview), NM10 Express Chipset (Norco kit BIS-6630, Cedar Rock CRB)
-
-and is likely to work on many unlisted Atom/Core/Xeon based devices. The MACHINE
-type supports ethernet, wifi, sound, and Intel/vesa graphics by default in
-addition to common PC input devices, busses, and so on.  Note that it does not
-included the binary-only graphic drivers used on some Atom platforms, for
-accelerated graphics on these machines please refer to meta-intel.
+and is likely to work on many unlisted Atom based devices. The MACHINE type
+supports ethernet, wifi, sound, and i915 graphics by default in addition to
+common PC input devices, busses, and so on.
 
 Depending on the device, it can boot from a traditional hard-disk, a USB device,
 or over the network. Writing generated images to physical media is
@@ -111,7 +93,7 @@ device as the following commands are run as root and are not reversable.
 USB Device:
   1. Build a live image. This image type consists of a simple filesystem
      without a partition table, which is suitable for USB keys, and with the
-     default setup for the genericx86 machine, this image type is built
+     default setup for the atom-pc machine, this image type is built
      automatically for any image you build. For example:
 
      $ bitbake core-image-minimal
@@ -119,7 +101,7 @@ USB Device:
   2. Use the "dd" utility to write the image to the raw block device. For
      example:
 
-     # dd if=core-image-minimal-genericx86.hddimg of=/dev/sdb
+     # dd if=core-image-minimal-atom-pc.hddimg of=/dev/sdb
 
   If the device fails to boot with "Boot error" displayed, or apparently
   stops just after the SYSLINUX version banner, it is likely the BIOS cannot
@@ -160,7 +142,7 @@ USB Device:
 
      # mkdir /tmp/image
      # mkdir /tmp/usbkey
-     # mount -o loop core-image-minimal-genericx86.hddimg  /tmp/image
+     # mount -o loop core-image-minimal-atom-pc.hddimg  /tmp/image
      # mount /dev/sdb4 /tmp/usbkey
      # cp -rf /tmp/image/* /tmp/usbkey
 

bitbake/LICENSE

@@ -1,10 +0,0 @@
-BitBake is licensed under the GNU General Public License version 2.0. See COPYING for further details.
-
-The following external components are distributed with this software:
-
-* The Toaster Simple UI application is based upon the Django project template, the files of which are covered by the BSD license and are copyright (c) Django Software
-Foundation and individual contributors.
-
-* Twitter Bootstrap (including Glyphicons), redistributed under the Apache License 2.0.
-
-* jQuery is redistributed under the MIT license.

bitbake/bin/bitbake

@@ -39,15 +39,10 @@ import bb.msg
 from bb import cooker
 from bb import ui
 from bb import server
-from bb import cookerdata
 
-__version__ = "1.20.0"
+__version__ = "1.18.0"
 logger = logging.getLogger("BitBake")
 
-# Python multiprocessing requires /dev/shm
-if not os.access('/dev/shm', os.W_OK | os.X_OK):
-    sys.exit("FATAL: /dev/shm does not exist or is not writable")
-
 # Unbuffer stdout to avoid log truncation in the event
 # of an unorderly exit as well as to provide timely
 # updates to log files for use with tail
@@ -57,6 +52,16 @@ try:
 except:
     pass
 
+class BBConfiguration(object):
+    """
+    Manages build options and configurations for one run
+    """
+
+    def __init__(self, options):
+        for key, val in options.__dict__.items():
+            setattr(self, key, val)
+        self.pkgs_to_build = []
+
 
 def get_ui(config):
     if not config.ui:
@@ -70,7 +75,7 @@ def get_ui(config):
         # suggest a fixed set this allows you to have flexibility in which
         # ones are available.
         module = __import__("bb.ui", fromlist = [interface])
-        return getattr(module, interface)
+        return getattr(module, interface).main
     except AttributeError:
         sys.exit("FATAL: Invalid user interface '%s' specified.\n"
                  "Valid interfaces: depexp, goggle, ncurses, hob, knotty [default]." % interface)
@@ -95,240 +100,182 @@ warnings.filterwarnings("ignore", category=ImportWarning)
 warnings.filterwarnings("ignore", category=DeprecationWarning, module="<string>$")
 warnings.filterwarnings("ignore", message="With-statements now directly support multiple context managers")
 
-class BitBakeConfigParameters(cookerdata.ConfigParameters):
-
-    def parseCommandLine(self):
-        parser = optparse.OptionParser(
-            version = "BitBake Build Tool Core version %s, %%prog version %s" % (bb.__version__, __version__),
-            usage = """%prog [options] [recipename/target ...]
-
-    Executes the specified task (default is 'build') for a given set of target recipes (.bb files).
-    It is assumed there is a conf/bblayers.conf available in cwd or in BBPATH which
-    will provide the layer, BBFILES and other configuration information.""")
-
-        parser.add_option("-b", "--buildfile", help = "Execute tasks from a specific .bb recipe directly. WARNING: Does not handle any dependencies from other recipes.",
-                   action = "store", dest = "buildfile", default = None)
-
-        parser.add_option("-k", "--continue", help = "Continue as much as possible after an error. While the target that failed and anything depending on it cannot be built, as much as possible will be built before stopping.",
-                   action = "store_false", dest = "abort", default = True)
-
-        parser.add_option("-a", "--tryaltconfigs", help = "Continue with builds by trying to use alternative providers where possible.",
-                   action = "store_true", dest = "tryaltconfigs", default = False)
-
-        parser.add_option("-f", "--force", help = "Force the specified targets/task to run (invalidating any existing stamp file).",
-                   action = "store_true", dest = "force", default = False)
-
-        parser.add_option("-c", "--cmd", help = "Specify the task to execute. The exact options available depend on the metadata. Some examples might be 'compile' or 'populate_sysroot' or 'listtasks' may give a list of the tasks available.",
-                   action = "store", dest = "cmd")
-
-        parser.add_option("-C", "--clear-stamp", help = "Invalidate the stamp for the specified task such as 'compile' and then run the default task for the specified target(s).",
-                    action = "store", dest = "invalidate_stamp")
-
-        parser.add_option("-r", "--read", help = "Read the specified file before bitbake.conf.",
-                   action = "append", dest = "prefile", default = [])
-
-        parser.add_option("-R", "--postread", help = "Read the specified file after bitbake.conf.",
-                          action = "append", dest = "postfile", default = [])
-
-        parser.add_option("-v", "--verbose", help = "Output more log message data to the terminal.",
-                   action = "store_true", dest = "verbose", default = False)
-
-        parser.add_option("-D", "--debug", help = "Increase the debug level. You can specify this more than once.",
-                   action = "count", dest="debug", default = 0)
-
-        parser.add_option("-n", "--dry-run", help = "Don't execute, just go through the motions.",
-                   action = "store_true", dest = "dry_run", default = False)
-
-        parser.add_option("-S", "--dump-signatures", help = "Don't execute, just dump out the signature construction information.",
-                   action = "store_true", dest = "dump_signatures", default = False)
-
-        parser.add_option("-p", "--parse-only", help = "Quit after parsing the BB recipes.",
-                   action = "store_true", dest = "parse_only", default = False)
-
-        parser.add_option("-s", "--show-versions", help = "Show current and preferred versions of all recipes.",
-                   action = "store_true", dest = "show_versions", default = False)
-
-        parser.add_option("-e", "--environment", help = "Show the global or per-package environment complete with information about where variables were set/changed.",
-                   action = "store_true", dest = "show_environment", default = False)
-
-        parser.add_option("-g", "--graphviz", help = "Save dependency tree information for the specified targets in the dot syntax.",
-                    action = "store_true", dest = "dot_graph", default = False)
-
-        parser.add_option("-I", "--ignore-deps", help = """Assume these dependencies don't exist and are already provided (equivalent to ASSUME_PROVIDED). Useful to make dependency graphs more appealing""",
-                    action = "append", dest = "extra_assume_provided", default = [])
-
-        parser.add_option("-l", "--log-domains", help = """Show debug logging for the specified logging domains""",
-                    action = "append", dest = "debug_domains", default = [])
-
-        parser.add_option("-P", "--profile", help = "Profile the command and save reports.",
-                   action = "store_true", dest = "profile", default = False)
-
-        parser.add_option("-u", "--ui", help = "The user interface to use (e.g. knotty, hob, depexp).",
-                   action = "store", dest = "ui")
-
-        parser.add_option("-t", "--servertype", help = "Choose which server to use, process or xmlrpc.",
-                   action = "store", dest = "servertype")
-
-        parser.add_option("", "--revisions-changed", help = "Set the exit code depending on whether upstream floating revisions have changed or not.",
-                   action = "store_true", dest = "revisions_changed", default = False)
-
-        parser.add_option("", "--server-only", help = "Run bitbake without a UI, only starting a server (cooker) process.",
-                   action = "store_true", dest = "server_only", default = False)
-
-        parser.add_option("-B", "--bind", help = "The name/address for the bitbake server to bind to.",
-                   action = "store", dest = "bind", default = False)
-
-        parser.add_option("", "--no-setscene", help = "Do not run any setscene tasks. sstate will be ignored and everything needed, built.",
-                   action = "store_true", dest = "nosetscene", default = False)
-
-        parser.add_option("", "--remote-server", help = "Connect to the specified server.",
-                   action = "store", dest = "remote_server", default = False)
-
-        parser.add_option("-m", "--kill-server", help = "Terminate the remote server.",
-                    action = "store_true", dest = "kill_server", default = False)
-
-        parser.add_option("", "--observe-only", help = "Connect to a server as an observing-only client.",
-                   action = "store_true", dest = "observe_only", default = False)
-
-        options, targets = parser.parse_args(sys.argv)
-
-        # some environmental variables set also configuration options
-        if "BBSERVER" in os.environ:
-            options.servertype = "xmlrpc"
-            options.remote_server = os.environ["BBSERVER"]
-
-        return options, targets[1:]
-
-
-def start_server(servermodule, configParams, configuration):
-    server = servermodule.BitBakeServer()
-    if configParams.bind:
-        (host, port) = configParams.bind.split(':')
-        server.initServer((host, int(port)))
-    else:
-        server.initServer()
-
-    try:
-        configuration.setServerRegIdleCallback(server.getServerIdleCB())
-
-        cooker = bb.cooker.BBCooker(configuration)
-
-        server.addcooker(cooker)
-        server.saveConnectionDetails()
-    except Exception as e:
-        exc_info = sys.exc_info()
-        while True:
-            try:
-                import queue
-            except ImportError:
-                import Queue as queue
-            try:
-                event = server.event_queue.get(block=False)
-            except (queue.Empty, IOError):
-                break
-            if isinstance(event, logging.LogRecord):
-                logger.handle(event)
-        raise exc_info[1], None, exc_info[2]
-    server.detach()
-    return server
-
-
 
 def main():
+    parser = optparse.OptionParser(
+        version = "BitBake Build Tool Core version %s, %%prog version %s" % (bb.__version__, __version__),
+        usage = """%prog [options] [package ...]
 
-    configParams = BitBakeConfigParameters()
-    configuration = cookerdata.CookerConfiguration()
-    configuration.setConfigParameters(configParams)
+Executes the specified task (default is 'build') for a given set of BitBake files.
+It expects that BBFILES is defined, which is a space separated list of files to
+be executed.  BBFILES does support wildcards.
+Default BBFILES are the .bb files in the current directory.""")
 
-    ui_module = get_ui(configParams)
+    parser.add_option("-b", "--buildfile", help = "execute the task against this .bb file, rather than a package from BBFILES. Does not handle any dependencies.",
+               action = "store", dest = "buildfile", default = None)
 
-    # Server type can be xmlrpc or process currently, if nothing is specified,
+    parser.add_option("-k", "--continue", help = "continue as much as possible after an error. While the target that failed, and those that depend on it, cannot be remade, the other dependencies of these targets can be processed all the same.",
+               action = "store_false", dest = "abort", default = True)
+
+    parser.add_option("-a", "--tryaltconfigs", help = "continue with builds by trying to use alternative providers where possible.",
+               action = "store_true", dest = "tryaltconfigs", default = False)
+
+    parser.add_option("-f", "--force", help = "force run of specified cmd, regardless of stamp status",
+               action = "store_true", dest = "force", default = False)
+
+    parser.add_option("-c", "--cmd", help = "Specify task to execute. Note that this only executes the specified task for the providee and the packages it depends on, i.e. 'compile' does not implicitly call stage for the dependencies (IOW: use only if you know what you are doing). Depending on the base.bbclass a listtasks tasks is defined and will show available tasks",
+               action = "store", dest = "cmd")
+
+    parser.add_option("-C", "--clear-stamp", help = "Invalidate the stamp for the specified cmd such as 'compile' and run the default task for the specified target(s)",
+                action = "store", dest = "invalidate_stamp")
+
+    parser.add_option("-r", "--read", help = "read the specified file before bitbake.conf",
+               action = "append", dest = "prefile", default = [])
+
+    parser.add_option("-R", "--postread", help = "read the specified file after bitbake.conf",
+                      action = "append", dest = "postfile", default = [])
+
+    parser.add_option("-v", "--verbose", help = "output more chit-chat to the terminal",
+               action = "store_true", dest = "verbose", default = False)
+
+    parser.add_option("-D", "--debug", help = "Increase the debug level. You can specify this more than once.",
+               action = "count", dest="debug", default = 0)
+
+    parser.add_option("-n", "--dry-run", help = "don't execute, just go through the motions",
+               action = "store_true", dest = "dry_run", default = False)
+
+    parser.add_option("-S", "--dump-signatures", help = "don't execute, just dump out the signature construction information",
+               action = "store_true", dest = "dump_signatures", default = False)
+
+    parser.add_option("-p", "--parse-only", help = "quit after parsing the BB files (developers only)",
+               action = "store_true", dest = "parse_only", default = False)
+
+    parser.add_option("-s", "--show-versions", help = "show current and preferred versions of all recipes",
+               action = "store_true", dest = "show_versions", default = False)
+
+    parser.add_option("-e", "--environment", help = "show the global or per-package environment (this is what used to be bbread)",
+               action = "store_true", dest = "show_environment", default = False)
+
+    parser.add_option("-g", "--graphviz", help = "emit the dependency trees of the specified packages in the dot syntax, and the pn-buildlist to show the build list",
+                action = "store_true", dest = "dot_graph", default = False)
+
+    parser.add_option("-I", "--ignore-deps", help = """Assume these dependencies don't exist and are already provided (equivalent to ASSUME_PROVIDED). Useful to make dependency graphs more appealing""",
+                action = "append", dest = "extra_assume_provided", default = [])
+
+    parser.add_option("-l", "--log-domains", help = """Show debug logging for the specified logging domains""",
+                action = "append", dest = "debug_domains", default = [])
+
+    parser.add_option("-P", "--profile", help = "profile the command and print a report",
+               action = "store_true", dest = "profile", default = False)
+
+    parser.add_option("-u", "--ui", help = "userinterface to use",
+               action = "store", dest = "ui")
+
+    parser.add_option("-t", "--servertype", help = "Choose which server to use, none, process or xmlrpc",
+               action = "store", dest = "servertype")
+
+    parser.add_option("", "--revisions-changed", help = "Set the exit code depending on whether upstream floating revisions have changed or not",
+               action = "store_true", dest = "revisions_changed", default = False)
+
+    parser.add_option("", "--server-only", help = "Run bitbake without UI,  the frontend can connect with bitbake server itself",
+               action = "store_true", dest = "server_only", default = False)
+
+    parser.add_option("-B", "--bind", help = "The name/address for the bitbake server to bind to",
+               action = "store", dest = "bind", default = False)
+    parser.add_option("", "--no-setscene", help = "Do not run any setscene tasks, forces builds",
+               action = "store_true", dest = "nosetscene", default = False)
+    options, args = parser.parse_args(sys.argv)
+
+    configuration = BBConfiguration(options)
+    configuration.pkgs_to_build.extend(args[1:])
+
+    ui_main = get_ui(configuration)
+
+    # Server type can be xmlrpc, process or none currently, if nothing is specified,
     # the default server is process
-    if configParams.servertype:
-        server_type = configParams.servertype
+    if configuration.servertype:
+        server_type = configuration.servertype
     else:
         server_type = 'process'
 
     try:
         module = __import__("bb.server", fromlist = [server_type])
-        servermodule = getattr(module, server_type)
+        server = getattr(module, server_type)
     except AttributeError:
         sys.exit("FATAL: Invalid server type '%s' specified.\n"
-                 "Valid interfaces: xmlrpc, process [default]." % servertype)
+                 "Valid interfaces: xmlrpc, process [default], none." % servertype)
 
-    if configParams.server_only:
-        if configParams.servertype != "xmlrpc":
+    if configuration.server_only:
+        if configuration.servertype != "xmlrpc":
             sys.exit("FATAL: If '--server-only' is defined, we must set the servertype as 'xmlrpc'.\n")
-        if not configParams.bind:
+        if not configuration.bind:
             sys.exit("FATAL: The '--server-only' option requires a name/address to bind to with the -B option.\n")
-        if configParams.remote_server:
-            sys.exit("FATAL: The '--server-only' option conflicts with %s.\n" % 
-                ("the BBSERVER environment variable" if "BBSERVER" in os.environ else "the '--remote-server' option" ))
 
-    if configParams.bind and configParams.servertype != "xmlrpc":
+    if configuration.bind and configuration.servertype != "xmlrpc":
         sys.exit("FATAL: If '-B' or '--bind' is defined, we must set the servertype as 'xmlrpc'.\n")
 
-    if configParams.remote_server and configParams.servertype != "xmlrpc":
-        sys.exit("FATAL: If '--remote-server' is defined, we must set the servertype as 'xmlrpc'.\n")
-
-    if configParams.observe_only and (not configParams.remote_server or configParams.bind):
-        sys.exit("FATAL: '--observe-only' can only be used by UI clients connecting to a server.\n")
-
     if "BBDEBUG" in os.environ:
         level = int(os.environ["BBDEBUG"])
         if level > configuration.debug:
             configuration.debug = level
 
-    bb.msg.init_msgconfig(configParams.verbose, configuration.debug,
+    bb.msg.init_msgconfig(configuration.verbose, configuration.debug,
                          configuration.debug_domains)
 
     # Ensure logging messages get sent to the UI as events
     handler = bb.event.LogHandler()
     logger.addHandler(handler)
 
+    # Before we start modifying the environment we should take a pristine
+    # copy for possible later use
+    initialenv = os.environ.copy()
     # Clear away any spurious environment variables while we stoke up the cooker
     cleanedvars = bb.utils.clean_environment()
 
-    if not configParams.remote_server:
-        # we start a server with a given configuration
-        server = start_server(servermodule, configParams, configuration)
-        bb.event.ui_queue = []
+    server = server.BitBakeServer()
+    if configuration.bind:
+        server.initServer((configuration.bind, 0))
     else:
-        # we start a stub server that is actually a XMLRPClient that connects to a real server
-        server = servermodule.BitBakeXMLRPCClient(configParams.observe_only)
-        server.saveConnectionDetails(configParams.remote_server)
+        server.initServer()
 
-    if not configParams.server_only:
-        # Collect the feature set for the UI
-        featureset = getattr(ui_module, "featureSet", [])
+    idle = server.getServerIdleCB()
 
+    cooker = bb.cooker.BBCooker(configuration, idle, initialenv)
+    cooker.parseCommandLine()
+
+    server.addcooker(cooker)
+    server.saveConnectionDetails()
+    server.detach()
+
+    # Should no longer need to ever reference cooker
+    del cooker
+
+    logger.removeHandler(handler)
+
+    if not configuration.server_only:
         # Setup a connection to the server (cooker)
-        server_connection = server.establishConnection(featureset)
+        server_connection = server.establishConnection()
 
         # Restore the environment in case the UI needs it
         for k in cleanedvars:
             os.environ[k] = cleanedvars[k]
 
-        logger.removeHandler(handler)
-
         try:
-            return ui_module.main(server_connection.connection, server_connection.events, configParams)
+            return server.launchUI(ui_main, server_connection.connection, server_connection.events)
         finally:
             bb.event.ui_queue = []
             server_connection.terminate()
     else:
-        print("server address: %s, server port: %s" % (server.serverImpl.host, server.serverImpl.port))
+        print("server address: %s, server port: %s" % (server.serverinfo.host, server.serverinfo.port))
 
     return 1
 
 if __name__ == "__main__":
     try:
         ret = main()
-    except bb.BBHandledException:
-        ret = 1
     except Exception:
         ret = 1
         import traceback
-        traceback.print_exc()
+        traceback.print_exc(5)
     sys.exit(ret)
 

bitbake/bin/bitbake-diffsigs

@@ -3,7 +3,7 @@
 # bitbake-diffsigs
 # BitBake task signature data comparison utility
 #
-# Copyright (C) 2012-2013 Intel Corporation
+# Copyright (C) 2012 Intel Corporation
 #
 # 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
@@ -30,18 +30,7 @@ sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), '
 import bb.tinfoil
 import bb.siggen
 
-def logger_create(name, output=sys.stderr):
-    logger = logging.getLogger(name)
-    console = logging.StreamHandler(output)
-    format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s")
-    if output.isatty():
-        format.enable_color()
-    console.setFormatter(format)
-    logger.addHandler(console)
-    logger.setLevel(logging.INFO)
-    return logger
-
-logger = logger_create('bitbake-diffsigs')
+logger = logging.getLogger('BitBake')
 
 def find_compare_task(bbhandler, pn, taskname):
     """ Find the most recent signature files for the specified PN/task and compare them """
@@ -50,9 +39,6 @@ def find_compare_task(bbhandler, pn, taskname):
         logger.error('Metadata does not support finding signature data files')
         sys.exit(1)
 
-    if not taskname.startswith('do_'):
-        taskname = 'do_%s' % taskname
-
     filedates = bb.siggen.find_siginfo(pn, taskname, None, bbhandler.config_data)
     latestfiles = sorted(filedates.keys(), key=lambda f: filedates[f])[-2:]
     if not latestfiles:
@@ -85,7 +71,6 @@ def find_compare_task(bbhandler, pn, taskname):
 
 
 parser = optparse.OptionParser(
-    description = "Compares siginfo/sigdata files written out by BitBake",
     usage = """
   %prog -t recipename taskname
   %prog sigdatafile1 sigdatafile2
@@ -93,30 +78,25 @@ parser = optparse.OptionParser(
 
 parser.add_option("-t", "--task",
         help = "find the signature data files for last two runs of the specified task and compare them",
-        action="store", dest="taskargs", nargs=2, metavar='recipename taskname')
+        action="store_true", dest="taskmode")
 
 options, args = parser.parse_args(sys.argv)
 
-if options.taskargs:
-    tinfoil = bb.tinfoil.Tinfoil()
-    tinfoil.prepare(config_only = True)
-    find_compare_task(tinfoil, options.taskargs[0], options.taskargs[1])
+if len(args) == 1:
+    parser.print_help()
 else:
-    if len(args) == 1:
-        parser.print_help()
+    if options.taskmode:
+        tinfoil = bb.tinfoil.Tinfoil()
+        if len(args) < 3:
+            logger.error("Please specify a recipe and task name")
+            sys.exit(1)
+        tinfoil.prepare(config_only = True)
+        find_compare_task(tinfoil, args[1], args[2])
     else:
-        import cPickle
-        try:
-            if len(args) == 2:
-                output = bb.siggen.dump_sigfile(sys.argv[1])
-            else:
-                output = bb.siggen.compare_sigfiles(sys.argv[1], sys.argv[2])
-        except IOError as e:
-            logger.error(str(e))
-            sys.exit(1)
-        except cPickle.UnpicklingError, EOFError:
-            logger.error('Invalid signature data - ensure you are specifying sigdata/siginfo files')
-            sys.exit(1)
+        if len(args) == 2:
+            output = bb.siggen.dump_sigfile(sys.argv[1])
+        else:
+            output = bb.siggen.compare_sigfiles(sys.argv[1], sys.argv[2])
 
-    if output:
-        print '\n'.join(output)
+        if output:
+            print '\n'.join(output)

bitbake/bin/bitbake-dumpsig

@@ -1,65 +1,11 @@
 #!/usr/bin/env python
-
-# bitbake-dumpsig
-# BitBake task signature dump utility
-#
-# Copyright (C) 2013 Intel Corporation
-#
-# 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 os
 import sys
 import warnings
-import optparse
-import logging
-
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
 
 import bb.siggen
 
-def logger_create(name, output=sys.stderr):
-    logger = logging.getLogger(name)
-    console = logging.StreamHandler(output)
-    format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s")
-    if output.isatty():
-        format.enable_color()
-    console.setFormatter(format)
-    logger.addHandler(console)
-    logger.setLevel(logging.INFO)
-    return logger
-
-logger = logger_create('bitbake-dumpsig')
-
-parser = optparse.OptionParser(
-    description = "Dumps siginfo/sigdata files written out by BitBake",
-    usage = """
-  %prog sigdatafile""")
-
-options, args = parser.parse_args(sys.argv)
-
-if len(args) == 1:
-    parser.print_help()
-else:
-    import cPickle
-    try:
-        output = bb.siggen.dump_sigfile(args[1])
-    except IOError as e:
-        logger.error(str(e))
-        sys.exit(1)
-    except cPickle.UnpicklingError, EOFError:
-        logger.error('Invalid signature data - ensure you are specifying a sigdata/siginfo file')
-        sys.exit(1)
-
-    if output:
-        print '\n'.join(output)
+output = bb.siggen.dump_sigfile(sys.argv[1])
+if output:
+    print '\n'.join(output)

bitbake/bin/bitbake-layers

@@ -89,7 +89,7 @@ class Commands(cmd.Cmd):
         for layerdir in self.bblayers:
             layername = self.get_layer_name(layerdir)
             layerpri = 0
-            for layer, _, regex, pri in self.bbhandler.cooker.recipecache.bbfile_config_priorities:
+            for layer, _, regex, pri in self.bbhandler.cooker.status.bbfile_config_priorities:
                 if regex.match(os.path.join(layerdir, 'test')):
                     layerpri = pri
                     break
@@ -225,15 +225,15 @@ Options:
 
 
     def list_recipes(self, title, pnspec, show_overlayed_only, show_same_ver_only, show_filenames, show_multi_provider_only):
-        pkg_pn = self.bbhandler.cooker.recipecache.pkg_pn
-        (latest_versions, preferred_versions) = bb.providers.findProviders(self.bbhandler.config_data, self.bbhandler.cooker.recipecache, pkg_pn)
-        allproviders = bb.providers.allProviders(self.bbhandler.cooker.recipecache)
+        pkg_pn = self.bbhandler.cooker.status.pkg_pn
+        (latest_versions, preferred_versions) = bb.providers.findProviders(self.bbhandler.cooker.configuration.data, self.bbhandler.cooker.status, pkg_pn)
+        allproviders = bb.providers.allProviders(self.bbhandler.cooker.status)
 
         # Ensure we list skipped recipes
         # We are largely guessing about PN, PV and the preferred version here,
         # but we have no choice since skipped recipes are not fully parsed
         skiplist = self.bbhandler.cooker.skiplist.keys()
-        skiplist.sort( key=lambda fileitem: self.bbhandler.cooker.collection.calc_bbfile_priority(fileitem) )
+        skiplist.sort( key=lambda fileitem: self.bbhandler.cooker.calc_bbfile_priority(fileitem) )
         skiplist.reverse()
         for fn in skiplist:
             recipe_parts = os.path.splitext(os.path.basename(fn))[0].split('_')
@@ -371,8 +371,8 @@ build results (as the layer priority order has effectively changed).
         appended_recipes = []
         for layer in layers:
             overlayed = []
-            for f in self.bbhandler.cooker.collection.overlayed.iterkeys():
-                for of in self.bbhandler.cooker.collection.overlayed[f]:
+            for f in self.bbhandler.cooker.overlayed.iterkeys():
+                for of in self.bbhandler.cooker.overlayed[f]:
                     if of.startswith(layer):
                         overlayed.append(of)
 
@@ -396,8 +396,8 @@ build results (as the layer priority order has effectively changed).
                                     logger.warn('Overwriting file %s', fdest)
                             bb.utils.copyfile(f1full, fdest)
                             if ext == '.bb':
-                                if f1 in self.bbhandler.cooker.collection.appendlist:
-                                    appends = self.bbhandler.cooker.collection.appendlist[f1]
+                                if f1 in self.bbhandler.cooker.appendlist:
+                                    appends = self.bbhandler.cooker.appendlist[f1]
                                     if appends:
                                         logger.plain('  Applying appends to %s' % fdest )
                                         for appendname in appends:
@@ -406,9 +406,9 @@ build results (as the layer priority order has effectively changed).
                                     appended_recipes.append(f1)
 
         # Take care of when some layers are excluded and yet we have included bbappends for those recipes
-        for recipename in self.bbhandler.cooker.collection.appendlist.iterkeys():
+        for recipename in self.bbhandler.cooker.appendlist.iterkeys():
             if recipename not in appended_recipes:
-                appends = self.bbhandler.cooker.collection.appendlist[recipename]
+                appends = self.bbhandler.cooker.appendlist[recipename]
                 first_append = None
                 for appendname in appends:
                     layer = layer_path_match(appendname)
@@ -426,7 +426,7 @@ build results (as the layer priority order has effectively changed).
         # have come from)
         first_regex = None
         layerdir = layers[0]
-        for layername, pattern, regex, _ in self.bbhandler.cooker.recipecache.bbfile_config_priorities:
+        for layername, pattern, regex, _ in self.bbhandler.cooker.status.bbfile_config_priorities:
             if regex.match(os.path.join(layerdir, 'test')):
                 first_regex = regex
                 break
@@ -456,7 +456,7 @@ build results (as the layer priority order has effectively changed).
                                 logger.warning("File %s does not match the flattened layer's BBFILES setting, you may need to edit conf/layer.conf or move the file elsewhere" % f1full)
 
     def get_file_layer(self, filename):
-        for layer, _, regex, _ in self.bbhandler.cooker.recipecache.bbfile_config_priorities:
+        for layer, _, regex, _ in self.bbhandler.cooker.status.bbfile_config_priorities:
             if regex.match(filename):
                 for layerdir in self.bblayers:
                     if regex.match(os.path.join(layerdir, 'test')) and re.match(layerdir, filename):
@@ -464,7 +464,7 @@ build results (as the layer priority order has effectively changed).
         return "?"
 
     def get_file_layerdir(self, filename):
-        for layer, _, regex, _ in self.bbhandler.cooker.recipecache.bbfile_config_priorities:
+        for layer, _, regex, _ in self.bbhandler.cooker.status.bbfile_config_priorities:
             if regex.match(filename):
                 for layerdir in self.bblayers:
                     if regex.match(os.path.join(layerdir, 'test')) and re.match(layerdir, filename):
@@ -498,7 +498,7 @@ usage: show-appends
 Recipes are listed with the bbappends that apply to them as subitems.
 """
         self.bbhandler.prepare()
-        if not self.bbhandler.cooker.collection.appendlist:
+        if not self.bbhandler.cooker.appendlist:
             logger.plain('No append files found')
             return
 
@@ -515,7 +515,7 @@ Recipes are listed with the bbappends that apply to them as subitems.
         filenames = self.bbhandler.cooker_data.pkg_pn[pn]
 
         best = bb.providers.findBestProvider(pn,
-                                             self.bbhandler.config_data,
+                                             self.bbhandler.cooker.configuration.data,
                                              self.bbhandler.cooker_data,
                                              self.bbhandler.cooker_data.pkg_pn)
         best_filename = os.path.basename(best[3])
@@ -550,7 +550,7 @@ Recipes are listed with the bbappends that apply to them as subitems.
                 continue
 
             basename = os.path.basename(filename)
-            appends = self.bbhandler.cooker.collection.appendlist.get(basename)
+            appends = self.bbhandler.cooker.appendlist.get(basename)
             if appends:
                 appended.append((basename, list(appends)))
             else:
@@ -598,7 +598,7 @@ The .bbappend file can impact the dependency.
             for pn in deps:
                 if pn in self.bbhandler.cooker_data.pkg_pn:
                     best = bb.providers.findBestProvider(pn,
-                            self.bbhandler.config_data,
+                            self.bbhandler.cooker.configuration.data,
                             self.bbhandler.cooker_data,
                             self.bbhandler.cooker_data.pkg_pn)
                     self.check_cross_depends("DEPENDS", layername, f, best[3], show_filenames)
@@ -616,7 +616,7 @@ The .bbappend file can impact the dependency.
                 all_p = bb.providers.getRuntimeProviders(self.bbhandler.cooker_data, rdep)
                 if all_p:
                     best = bb.providers.filterProvidersRunTime(all_p, rdep,
-                                    self.bbhandler.config_data,
+                                    self.bbhandler.cooker.configuration.data,
                                     self.bbhandler.cooker_data)[0][0]
                     self.check_cross_depends("RDEPENDS", layername, f, best, show_filenames)
 

bitbake/bin/bitbake-runtask

@@ -0,0 +1,119 @@
+#!/usr/bin/env python
+
+import os
+import sys
+import warnings
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
+from bb import fetch2
+import logging
+
+logger = logging.getLogger("BitBake")
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+    bb.msg.note(1, bb.msg.domain.Cache, "Importing cPickle failed. Falling back to a very slow implementation.")
+
+class BBConfiguration(object):
+    """
+    Manages build options and configurations for one run
+    """
+
+    def __init__(self, **options):
+        self.data = {}
+        self.file = []
+        self.cmd = None
+        self.dump_signatures = True
+        self.prefile = []
+        self.postfile = []
+        self.parse_only = True
+
+    def __getattr__(self, attribute):
+        try:
+            return super(BBConfiguration, self).__getattribute__(attribute)
+        except AttributeError:
+            return None
+
+_warnings_showwarning = warnings.showwarning
+def _showwarning(message, category, filename, lineno, file=None, line=None):
+    """Display python warning messages using bb.msg"""
+    if file is not None:
+        if _warnings_showwarning is not None:
+            _warnings_showwarning(message, category, filename, lineno, file, line)
+    else:
+        s = warnings.formatwarning(message, category, filename, lineno)
+        s = s.split("\n")[0]
+        bb.msg.warn(None, s)
+
+warnings.showwarning = _showwarning
+warnings.simplefilter("ignore", DeprecationWarning)
+
+import bb.event
+import bb.cooker
+
+buildfile = sys.argv[1]
+taskname = sys.argv[2]
+if len(sys.argv) >= 4:
+    dryrun = sys.argv[3]    
+else:
+    dryrun = False
+if len(sys.argv) >= 5:
+    hashfile = sys.argv[4]
+    p = pickle.Unpickler(file(hashfile, "rb"))
+    hashdata = p.load()
+else:
+    hashdata = None
+
+handler = bb.event.LogHandler()
+logger.addHandler(handler)
+
+#An example to make debug log messages show up
+#bb.msg.init_msgconfig(True, 3, [])
+
+console = logging.StreamHandler(sys.stdout)
+format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s")
+bb.msg.addDefaultlogFilter(console)
+console.setFormatter(format)
+
+def worker_fire(event, d):
+    if isinstance(event, logging.LogRecord):
+        console.handle(event)
+bb.event.worker_fire = worker_fire
+bb.event.worker_pid = os.getpid()
+
+initialenv = os.environ.copy()
+config = BBConfiguration()
+
+def register_idle_function(self, function, data):
+    pass
+
+cooker = bb.cooker.BBCooker(config, register_idle_function, initialenv)
+config_data = cooker.configuration.data
+cooker.status = config_data
+cooker.handleCollections(config_data.getVar("BBFILE_COLLECTIONS", 1))
+
+fn, cls = bb.cache.Cache.virtualfn2realfn(buildfile)
+buildfile = cooker.matchFile(fn)
+fn = bb.cache.Cache.realfn2virtual(buildfile, cls)
+
+cooker.buildSetVars()
+
+# Load data into the cache for fn and parse the loaded cache data
+the_data = bb.cache.Cache.loadDataFull(fn, cooker.get_file_appends(fn), cooker.configuration.data)
+
+if taskname.endswith("_setscene"):
+    the_data.setVarFlag(taskname, "quieterrors", "1")
+
+if hashdata:
+    bb.parse.siggen.set_taskdata(hashdata["hashes"], hashdata["deps"])
+    for h in hashdata["hashes"]:
+        the_data.setVar("BBHASH_%s" % h, hashdata["hashes"][h])
+    for h in hashdata["deps"]:
+        the_data.setVar("BBHASHDEPS_%s" % h, hashdata["deps"][h])
+
+ret = 0
+if dryrun != "True":
+    ret = bb.build.exec_task(fn, taskname, the_data)
+sys.exit(ret)
+

bitbake/bin/bitbake-worker

@@ -1,363 +0,0 @@
-#!/usr/bin/env python
-
-import os
-import sys
-import warnings
-sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
-from bb import fetch2
-import logging
-import bb
-import select
-import errno
-import signal
-
-# Users shouldn't be running this code directly
-if len(sys.argv) != 2 or sys.argv[1] != "decafbad":
-    print("bitbake-worker is meant for internal execution by bitbake itself, please don't use it standalone.")
-    sys.exit(1)
-
-logger = logging.getLogger("BitBake")
-
-try:
-    import cPickle as pickle
-except ImportError:
-    import pickle
-    bb.msg.note(1, bb.msg.domain.Cache, "Importing cPickle failed. Falling back to a very slow implementation.")
-
-
-worker_pipe = sys.stdout.fileno()
-bb.utils.nonblockingfd(worker_pipe)
-
-handler = bb.event.LogHandler()
-logger.addHandler(handler)
-
-if 0:
-    # Code to write out a log file of all events passing through the worker
-    logfilename = "/tmp/workerlogfile"
-    format_str = "%(levelname)s: %(message)s"
-    conlogformat = bb.msg.BBLogFormatter(format_str)
-    consolelog = logging.FileHandler(logfilename)
-    bb.msg.addDefaultlogFilter(consolelog)
-    consolelog.setFormatter(conlogformat)
-    logger.addHandler(consolelog)
-
-worker_queue = ""
-
-def worker_fire(event, d):
-    data = "<event>" + pickle.dumps(event) + "</event>"
-    worker_fire_prepickled(data)
-
-def worker_fire_prepickled(event):
-    global worker_queue
-
-    worker_queue = worker_queue + event
-    worker_flush()
-
-def worker_flush():
-    global worker_queue, worker_pipe
-
-    if not worker_queue:
-        return
-
-    try:
-        written = os.write(worker_pipe, worker_queue)
-        worker_queue = worker_queue[written:]
-    except (IOError, OSError) as e:
-        if e.errno != errno.EAGAIN:
-            raise
-
-def worker_child_fire(event, d):
-    global worker_pipe
-
-    data = "<event>" + pickle.dumps(event) + "</event>"
-    worker_pipe.write(data)
-
-bb.event.worker_fire = worker_fire
-
-lf = None
-#lf = open("/tmp/workercommandlog", "w+")
-def workerlog_write(msg):
-    if lf:
-        lf.write(msg)
-        lf.flush()
-
-def fork_off_task(cfg, data, workerdata, fn, task, taskname, appends, quieterrors=False):
-    # We need to setup the environment BEFORE the fork, since
-    # a fork() or exec*() activates PSEUDO...
-
-    envbackup = {}
-    fakeenv = {}
-    umask = None
-
-    taskdep = workerdata["taskdeps"][fn]
-    if 'umask' in taskdep and taskname in taskdep['umask']:
-        # umask might come in as a number or text string..
-        try:
-             umask = int(taskdep['umask'][taskname],8)
-        except TypeError:
-             umask = taskdep['umask'][taskname]
-
-    if 'fakeroot' in taskdep and taskname in taskdep['fakeroot']:
-        envvars = (workerdata["fakerootenv"][fn] or "").split()
-        for key, value in (var.split('=') for var in envvars):
-            envbackup[key] = os.environ.get(key)
-            os.environ[key] = value
-            fakeenv[key] = value
-
-        fakedirs = (workerdata["fakerootdirs"][fn] or "").split()
-        for p in fakedirs:
-            bb.utils.mkdirhier(p)
-        logger.debug(2, 'Running %s:%s under fakeroot, fakedirs: %s' %
-                        (fn, taskname, ', '.join(fakedirs)))
-    else:
-        envvars = (workerdata["fakerootnoenv"][fn] or "").split()
-        for key, value in (var.split('=') for var in envvars):
-            envbackup[key] = os.environ.get(key)
-            os.environ[key] = value
-            fakeenv[key] = value
-
-    sys.stdout.flush()
-    sys.stderr.flush()
-
-    try:
-        pipein, pipeout = os.pipe()
-        pipein = os.fdopen(pipein, 'rb', 4096)
-        pipeout = os.fdopen(pipeout, 'wb', 0)
-        pid = os.fork()
-    except OSError as e:
-        bb.msg.fatal("RunQueue", "fork failed: %d (%s)" % (e.errno, e.strerror))
-
-    if pid == 0:
-            global worker_pipe
-            pipein.close()
-
-            # Save out the PID so that the event can include it the
-            # events
-            bb.event.worker_pid = os.getpid()
-            bb.event.worker_fire = worker_child_fire
-            worker_pipe = pipeout
-
-            # Make the child the process group leader
-            os.setpgid(0, 0)
-            # No stdin
-            newsi = os.open(os.devnull, os.O_RDWR)
-            os.dup2(newsi, sys.stdin.fileno())
-
-            if umask:
-                os.umask(umask)
-
-            data.setVar("BB_WORKERCONTEXT", "1")
-            data.setVar("BUILDNAME", workerdata["buildname"])
-            data.setVar("DATE", workerdata["date"])
-            data.setVar("TIME", workerdata["time"])
-            bb.parse.siggen.set_taskdata(workerdata["hashes"], workerdata["hash_deps"], workerdata["sigchecksums"])
-            ret = 0
-            try:
-                the_data = bb.cache.Cache.loadDataFull(fn, appends, data)
-                the_data.setVar('BB_TASKHASH', workerdata["runq_hash"][task])
-                for h in workerdata["hashes"]:
-                    the_data.setVar("BBHASH_%s" % h, workerdata["hashes"][h])
-                for h in workerdata["hash_deps"]:
-                    the_data.setVar("BBHASHDEPS_%s" % h, workerdata["hash_deps"][h])
-
-                # exported_vars() returns a generator which *cannot* be passed to os.environ.update() 
-                # successfully. We also need to unset anything from the environment which shouldn't be there 
-                exports = bb.data.exported_vars(the_data)
-                bb.utils.empty_environment()
-                for e, v in exports:
-                    os.environ[e] = v
-                for e in fakeenv:
-                    os.environ[e] = fakeenv[e]
-                    the_data.setVar(e, fakeenv[e])
-                    the_data.setVarFlag(e, 'export', "1")
-
-                if quieterrors:
-                    the_data.setVarFlag(taskname, "quieterrors", "1")
-
-            except Exception as exc:
-                if not quieterrors:
-                    logger.critical(str(exc))
-                os._exit(1)
-            try:
-                if not cfg.dry_run:
-                    ret = bb.build.exec_task(fn, taskname, the_data, cfg.profile)
-                os._exit(ret)
-            except:
-                os._exit(1)
-    else:
-        for key, value in envbackup.iteritems():
-            if value is None:
-                del os.environ[key]
-            else:
-                os.environ[key] = value
-
-    return pid, pipein, pipeout
-
-class runQueueWorkerPipe():
-    """
-    Abstraction for a pipe between a worker thread and the worker server
-    """
-    def __init__(self, pipein, pipeout):
-        self.input = pipein
-        if pipeout:
-            pipeout.close()
-        bb.utils.nonblockingfd(self.input)
-        self.queue = ""
-
-    def read(self):
-        start = len(self.queue)
-        try:
-            self.queue = self.queue + self.input.read(102400)
-        except (OSError, IOError) as e:
-            if e.errno != errno.EAGAIN:
-                raise
-
-        end = len(self.queue)
-        index = self.queue.find("</event>")
-        while index != -1:
-            worker_fire_prepickled(self.queue[:index+8])
-            self.queue = self.queue[index+8:]
-            index = self.queue.find("</event>")
-        return (end > start)
-
-    def close(self):
-        while self.read():
-            continue
-        if len(self.queue) > 0:
-            print("Warning, worker child left partial message: %s" % self.queue)
-        self.input.close()
-
-normalexit = False
-
-class BitbakeWorker(object):
-    def __init__(self, din):
-        self.input = din
-        bb.utils.nonblockingfd(self.input)
-        self.queue = ""
-        self.cookercfg = None
-        self.databuilder = None
-        self.data = None
-        self.build_pids = {}
-        self.build_pipes = {}
-    
-    def serve(self):        
-        while True:
-            (ready, _, _) = select.select([self.input] + [i.input for i in self.build_pipes.values()], [] , [], 1)
-            if self.input in ready or len(self.queue):
-                start = len(self.queue)
-                try:
-                    self.queue = self.queue + self.input.read()
-                except (OSError, IOError):
-                    pass
-                end = len(self.queue)
-                self.handle_item("cookerconfig", self.handle_cookercfg)
-                self.handle_item("workerdata", self.handle_workerdata)
-                self.handle_item("runtask", self.handle_runtask)
-                self.handle_item("finishnow", self.handle_finishnow)
-                self.handle_item("ping", self.handle_ping)
-                self.handle_item("quit", self.handle_quit)
-
-            for pipe in self.build_pipes:
-                self.build_pipes[pipe].read()
-            if len(self.build_pids):
-                self.process_waitpid()
-            worker_flush()
-
-
-    def handle_item(self, item, func):
-        if self.queue.startswith("<" + item + ">"):
-            index = self.queue.find("</" + item + ">")
-            while index != -1:
-                func(self.queue[(len(item) + 2):index])
-                self.queue = self.queue[(index + len(item) + 3):]
-                index = self.queue.find("</" + item + ">")
-
-    def handle_cookercfg(self, data):
-        self.cookercfg = pickle.loads(data)
-        self.databuilder = bb.cookerdata.CookerDataBuilder(self.cookercfg, worker=True)
-        self.databuilder.parseBaseConfiguration()
-        self.data = self.databuilder.data
-
-    def handle_workerdata(self, data):
-        self.workerdata = pickle.loads(data)
-        bb.msg.loggerDefaultDebugLevel = self.workerdata["logdefaultdebug"]
-        bb.msg.loggerDefaultVerbose = self.workerdata["logdefaultverbose"]
-        bb.msg.loggerVerboseLogs = self.workerdata["logdefaultverboselogs"]
-        bb.msg.loggerDefaultDomains = self.workerdata["logdefaultdomain"]
-        self.data.setVar("PRSERV_HOST", self.workerdata["prhost"])
-
-    def handle_ping(self, _):
-        workerlog_write("Handling ping\n")
-
-        logger.warn("Pong from bitbake-worker!")
-
-    def handle_quit(self, data):
-        workerlog_write("Handling quit\n")
-
-        global normalexit
-        normalexit = True
-        sys.exit(0)
-
-    def handle_runtask(self, data):
-        fn, task, taskname, quieterrors, appends = pickle.loads(data)
-        workerlog_write("Handling runtask %s %s %s\n" % (task, fn, taskname))
-
-        pid, pipein, pipeout = fork_off_task(self.cookercfg, self.data, self.workerdata, fn, task, taskname, appends, quieterrors)
-
-        self.build_pids[pid] = task
-        self.build_pipes[pid] = runQueueWorkerPipe(pipein, pipeout)
-
-    def process_waitpid(self):
-        """
-        Return none is there are no processes awaiting result collection, otherwise
-        collect the process exit codes and close the information pipe.
-        """
-        try:
-            pid, status = os.waitpid(-1, os.WNOHANG)
-            if pid == 0 or os.WIFSTOPPED(status):
-                return None
-        except OSError:
-            return None
-
-        workerlog_write("Exit code of %s for pid %s\n" % (status, pid))
-
-        if os.WIFEXITED(status):
-            status = os.WEXITSTATUS(status)
-        elif os.WIFSIGNALED(status):
-            # Per shell conventions for $?, when a process exits due to
-            # a signal, we return an exit code of 128 + SIGNUM
-            status = 128 + os.WTERMSIG(status)
-
-        task = self.build_pids[pid]
-        del self.build_pids[pid]
-
-        self.build_pipes[pid].close()
-        del self.build_pipes[pid]
-
-        worker_fire_prepickled("<exitcode>" + pickle.dumps((task, status)) + "</exitcode>")
-
-    def handle_finishnow(self, _):
-        if self.build_pids:
-            logger.info("Sending SIGTERM to remaining %s tasks", len(self.build_pids))
-            for k, v in self.build_pids.iteritems():
-                try:
-                    os.kill(-k, signal.SIGTERM)
-                    os.waitpid(-1, 0)
-                except:
-                    pass
-        for pipe in self.build_pipes:
-            self.build_pipes[pipe].read()
-
-try:
-    worker = BitbakeWorker(sys.stdin)
-    worker.serve()
-except BaseException as e:
-    if not normalexit:
-        import traceback
-        sys.stderr.write(traceback.format_exc())
-        sys.stderr.write(str(e))
-while len(worker_queue):
-    worker_flush()
-workerlog_write("exitting")
-sys.exit(0)
-

bitbake/bin/toaster

@@ -1,164 +0,0 @@
-#!/bin/bash
-# (c) 2013 Intel Corp.
-
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-
-# This script enables toaster event logging and
-# starts bitbake resident server
-# use as:  source toaster [start|stop]
-
-# Helper function to kill a background toaster development server
-
-function webserverKillAll()
-{
-	local pidfile
-	for pidfile in ${BUILDDIR}/.toastermain.pid; do
-		if [ -f ${pidfile} ]; then
-		while kill -0 $(< ${pidfile}) 2>/dev/null; do
-			kill -SIGTERM -$(< ${pidfile}) 2>/dev/null
-			sleep 1;
-		done;
-		rm  ${pidfile}
-		fi
-	done
-}
-
-function webserverStartAll()
-{
-        retval=0
-        python $BBBASEDIR/lib/toaster/manage.py syncdb || retval=1
-        if [ $retval -eq 1 ]; then
-                echo "Failed db sync, stopping system start" 1>&2
-        else
-            python $BBBASEDIR/lib/toaster/manage.py runserver 0.0.0.0:8000 </dev/null >${BUILDDIR}/toaster_web.log 2>&1 & echo $! >${BUILDDIR}/.toastermain.pid
-        fi
-        return $retval
-}
-
-# Helper functions to add a special configuration file
-
-function addtoConfiguration()
-{
-        echo "#Created by toaster start script" > ${BUILDDIR}/conf/$2
-        echo $1 >> ${BUILDDIR}/conf/$2
-}
-
-# define the stop command
-function stop_system()
-{
-    if [ -f ${BUILDDIR}/.toasterui.pid ]; then
-        kill $(< ${BUILDDIR}/.toasterui.pid )
-        rm ${BUILDDIR}/.toasterui.pid
-    fi
-    BBSERVER=localhost:8200 bitbake -m
-    unset BBSERVER
-    webserverKillAll
-    # force stop any misbehaving bitbake server
-    lsof bitbake.lock | awk '{print $2}' | grep "[0-9]\+" | xargs -n1 -r kill
-}
-
-# We make sure we're running in the current shell and in a good environment
-
-if [ -z "$ZSH_NAME" ] && [ `basename \"$0\"` = `basename \"$BASH_SOURCE\"` ]; then
-    echo "Error: This script needs to be sourced. Please run as 'source toaster [start|stop]'" 1>&2;
-    exit 1
-fi
-
-if [ -z "$BUILDDIR" ] || [ -z `which bitbake` ]; then
-    echo "Error: Build environment is not setup or bitbake is not in path." 1>&2;
-    return 2
-fi
-
-BBBASEDIR=`dirname ${BASH_SOURCE}`/..
-
-
-# Verify prerequisites
-
-if ! echo "import django; print (1,4,5) == django.VERSION[0:3]" | python 2>/dev/null | grep True >/dev/null; then
-    echo -e "This program needs Django 1.4.5. Please install with\n\nsudo pip install django==1.4.5"
-    return 2
-fi
-
-
-
-# Determine the action. If specified by arguments, fine, if not, toggle it
-if [ "x$1" == "xstart" ] || [ "x$1" == "xstop" ]; then
-    CMD="$1"
-else
-    if [ -z "$BBSERVER" ]; then
-        CMD="start"
-    else
-        CMD="stop"
-    fi;
-fi
-
-NOTOASTERUI=0
-if [ "x$2" == "xnoui" ]; then
-    NOTOASTERUI=1
-fi
-
-echo "The system will $CMD."
-
-# Make sure it's safe to run by checking bitbake lock
-
-lock=1
-if [ -e $BUILDDIR/bitbake.lock ]; then
-    (flock -n 200 ) 200<$BUILDDIR/bitbake.lock || lock=0
-fi
-
-if [ ${CMD} == "start" ] && ( [ $lock -eq 0 ] || [ -e $BUILDDIR/.toastermain.pid ] ); then
-    echo "Error: bitbake lock state error. System is already on." 2>&1
-    return 3
-elif [ ${CMD} == "stop" ] && ( [ $lock -eq 1 ] || ! [ -e $BUILDDIR/.toastermain.pid ] ) ; then
-    echo "Error: bitbake lock state error. Trying to stop a stopped system ?
-If you think the system is hanged up, you can try to manually stop system with the commands
-
-# BBSERVER=localhost:8200 bitbake -m
-
-and
-
-# webserverKillAll
-" 2>&1
-    return 3
-fi
-
-
-
-
-
-# Execute the commands
-
-case $CMD in
-    start )
-        addtoConfiguration "INHERIT+=\"toaster buildhistory\"" toaster.conf
-        webserverStartAll || return 4
-        unset BBSERVER
-        bitbake --postread conf/toaster.conf --server-only -t xmlrpc -B localhost:8200
-        export BBSERVER=localhost:8200
-        if [ $NOTOASTERUI == 0 ]; then        # we start the TOASTERUI only if not inhibited
-            bitbake --observe-only -u toasterui >${BUILDDIR}/toaster_ui.log 2>&1 & echo $! >${BUILDDIR}/.toasterui.pid
-        fi
-        # stop system on terminal exit
-        trap stop_system SIGHUP
-    ;;
-    stop )
-        stop_system
-        trap '' SIGHUP
-    ;;
-esac
-
-echo "Successful ${CMD}."
-

bitbake/contrib/vim/ftdetect/bitbake.vim

@@ -14,7 +14,7 @@ endif
 au BufNewFile,BufRead *.{bb,bbappend,bbclass}	set filetype=bitbake
 
 " .inc
-au BufNewFile,BufRead *.inc		set filetype=bitbake
+au BufNewFile,BufRead *.inc 		set filetype=bitbake
 
 " .conf
 au BufNewFile,BufRead *.conf

bitbake/contrib/vim/ftplugin/bitbake.vim

@@ -1,2 +1 @@
 set sts=4 sw=4 et
-set cms=#%s

bitbake/contrib/vim/plugin/newbb.vim

@@ -15,7 +15,7 @@ if &compatible || v:version < 600
 endif
 
 fun! <SID>GetUserName()
-    let l:user_name = system("git config --get user.name")
+    let l:user_name = system("git-config --get user.name")
     if v:shell_error
         return "Unknow User"
     else
@@ -23,7 +23,7 @@ fun! <SID>GetUserName()
 endfun
 
 fun! <SID>GetUserEmail()
-    let l:user_email = system("git config --get user.email")
+    let l:user_email = system("git-config --get user.email")
     if v:shell_error
         return "unknow@user.org"
     else

bitbake/contrib/vim/syntax/bitbake.vim

@@ -44,8 +44,8 @@ syn match bbArrayBrackets       "[\[\]]" contained
 
 " BitBake strings
 syn match bbContinue            "\\$"
-syn region bbString             matchgroup=bbQuote start=+"+ skip=+\\$+ end=+"+ contained contains=bbTodo,bbContinue,bbVarDeref,bbVarPyValue,@Spell
-syn region bbString             matchgroup=bbQuote start=+'+ skip=+\\$+ end=+'+ contained contains=bbTodo,bbContinue,bbVarDeref,bbVarPyValue,@Spell
+syn region bbString             matchgroup=bbQuote start=+"+ skip=+\\$+ excludenl end=+"+ contained keepend contains=bbTodo,bbContinue,bbVarDeref,bbVarPyValue,@Spell
+syn region bbString             matchgroup=bbQuote start=+'+ skip=+\\$+ excludenl end=+'+ contained keepend contains=bbTodo,bbContinue,bbVarDeref,bbVarPyValue,@Spell
 
 " Vars definition
 syn match bbExport            "^export" nextgroup=bbIdentifier skipwhite
@@ -55,11 +55,11 @@ syn match bbVarDeref            "${[a-zA-Z0-9\-_\.\/\+]\+}" contained
 syn match bbVarEq               "\(:=\|+=\|=+\|\.=\|=\.\|?=\|??=\|=\)" contained nextgroup=bbVarValue
 syn match bbVarDef              "^\(export\s*\)\?\([a-zA-Z0-9\-_\.\/\+]\+\(_[${}a-zA-Z0-9\-_\.\/\+]\+\)\?\)\s*\(:=\|+=\|=+\|\.=\|=\.\|?=\|??=\|=\)\@=" contains=bbExportFlag,bbIdentifier,bbVarDeref nextgroup=bbVarEq
 syn match bbVarValue            ".*$" contained contains=bbString,bbVarDeref,bbVarPyValue
-syn region bbVarPyValue         start=+${@+ skip=+\\$+ end=+}+ contained contains=@python
+syn region bbVarPyValue         start=+${@+ skip=+\\$+ excludenl end=+}+ contained contains=@python
 
 " Vars metadata flags
 syn match bbVarFlagDef          "^\([a-zA-Z0-9\-_\.]\+\)\(\[[a-zA-Z0-9\-_\.]\+\]\)\@=" contains=bbIdentifier nextgroup=bbVarFlagFlag
-syn region bbVarFlagFlag        matchgroup=bbArrayBrackets start="\[" end="\]\s*\(=\|+=\|=+\|?=\)\@=" contained contains=bbIdentifier nextgroup=bbVarEq
+syn region bbVarFlagFlag        matchgroup=bbArrayBrackets start="\[" end="\]\s*\(=\)\@=" keepend excludenl contained contains=bbIdentifier nextgroup=bbVarEq
 
 " Includes and requires
 syn keyword bbInclude           inherit include require contained 
@@ -83,16 +83,13 @@ if exists("b:current_syntax")
   unlet b:current_syntax
 endif
 syn keyword bbShFakeRootFlag    fakeroot contained
-syn match bbShFuncDef           "^\(fakeroot\s*\)\?\([0-9A-Za-z_${}-]\+\)\(python\)\@<!\(\s*()\s*\)\({\)\@=" contains=bbShFakeRootFlag,bbFunction,bbVarDeref,bbDelimiter nextgroup=bbShFuncRegion skipwhite
-syn region bbShFuncRegion       matchgroup=bbDelimiter start="{\s*$" end="^}\s*$" contained contains=@shell
-
-" Python value inside shell functions
-syn region shDeref         start=+${@+ skip=+\\$+ excludenl end=+}+ contained contains=@python
+syn match bbShFuncDef           "^\(fakeroot\s*\)\?\([0-9A-Za-z_-]\+\)\(python\)\@<!\(\s*()\s*\)\({\)\@=" contains=bbShFakeRootFlag,bbFunction,bbDelimiter nextgroup=bbShFuncRegion skipwhite
+syn region bbShFuncRegion       matchgroup=bbDelimiter start="{\s*$" end="^}\s*$" keepend contained contains=@shell
 
 " BitBake python metadata
 syn keyword bbPyFlag            python contained
-syn match bbPyFuncDef           "^\(python\s\+\)\([0-9A-Za-z_${}-]\+\)\?\(\s*()\s*\)\({\)\@=" contains=bbPyFlag,bbFunction,bbVarDeref,bbDelimiter nextgroup=bbPyFuncRegion skipwhite
-syn region bbPyFuncRegion       matchgroup=bbDelimiter start="{\s*$" end="^}\s*$" contained contains=@python
+syn match bbPyFuncDef           "^\(python\s\+\)\([0-9A-Za-z_-]\+\)\?\(\s*()\s*\)\({\)\@=" contains=bbPyFlag,bbFunction,bbDelimiter nextgroup=bbPyFuncRegion skipwhite 
+syn region bbPyFuncRegion       matchgroup=bbDelimiter start="{\s*$" end="^}\s*$" keepend contained contains=@python
 
 " BitBake 'def'd python functions
 syn keyword bbPyDef             def contained

bitbake/doc/manual/usermanual.xml

@@ -137,24 +137,6 @@ share common metadata between many packages.</para></listitem>
                 <para>In this example, <varname>B</varname> is now <literal>bvaladditionaldata</literal> and <varname>C</varname> is <literal>testcval</literal>. In contrast to the above appending and prepending operators, no additional space
 will be introduced.</para>
             </section>
-            <section>
-                <title>Appending and Prepending (override style syntax)</title>
-                    <para><screen><varname>B</varname> = "bval"
-<varname>B_append</varname> = " additional data"
-<varname>C</varname> = "cval"
-<varname>C_prepend</varname> = "additional data "</screen></para>
-                 <para>This example results in <varname>B</varname> becoming <literal>bval additional data</literal>
-and <varname>C</varname> becoming <literal>additional data cval</literal>. Note the spaces in the append.
-Unlike the += operator, additional space is not automatically added.  You must take steps to add space
-yourself.</para>
-            </section>
-            <section>
-                <title>Removing (override style syntax)</title>
-                <para><screen><varname>FOO</varname> = "123 456 789 123456 123 456 123 456"
-<varname>FOO_remove</varname> = "123"
-<varname>FOO_remove</varname> = "456"</screen></para>
-                <para>In this example, <varname>FOO</varname> is now <literal>789 123456</literal>.</para>
-            </section>
             <section>
                 <title>Conditional metadata set</title>
                 <para>OVERRIDES is a <quote>:</quote> separated variable containing each item you want to satisfy conditions.  So, if you have a variable which is conditional on <quote>arm</quote>, and <quote>arm</quote> is in OVERRIDES, then the <quote>arm</quote> specific version of the variable is used rather than the non-conditional version.  Example:</para>
@@ -554,7 +536,7 @@ options:
                 <example>
                     <title>Generating dependency graphs</title>
                     <para>BitBake is able to generate dependency graphs using the dot syntax. These graphs can be converted
-to images using the <application>dot</application> application from <ulink url="http://www.graphviz.org">Graphviz</ulink>.
+to images using the <application>dot</application> application from <ulink url="http://www.graphviz.org">Graphviz</ulink>. 
 Two files will be written into the current working directory, <emphasis>depends.dot</emphasis> containing dependency information at the package level and <emphasis>task-depends.dot</emphasis> containing a breakdown of the dependencies at the task level. To stop depending on common depends, one can use the <prompt>-I depend</prompt> to omit these from the graph. This can lead to more readable graphs.  This way, <varname>DEPENDS</varname> from inherited classes such as base.bbclass can be removed from the graph.</para>
                     <screen><prompt>$ </prompt>bitbake -g blah</screen>
                     <screen><prompt>$ </prompt>bitbake -g -I virtual/whatever -I bloom blah</screen>

bitbake/lib/bb/__init__.py

@@ -21,11 +21,11 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
-__version__ = "1.20.0"
+__version__ = "1.18.0"
 
 import sys
-if sys.version_info < (2, 7, 3):
-    raise RuntimeError("Sorry, python 2.7.3 or later is required for this version of bitbake")
+if sys.version_info < (2, 6, 0):
+    raise RuntimeError("Sorry, python 2.6.0 or later is required for this version of bitbake")
 
 
 class BBHandledException(Exception):

bitbake/lib/bb/build.py

@@ -34,7 +34,7 @@ import bb
 import bb.msg
 import bb.process
 from contextlib import nested
-from bb import event, utils
+from bb import data, event, utils
 
 bblogger = logging.getLogger('BitBake')
 logger = logging.getLogger('BitBake.Build')
@@ -60,7 +60,7 @@ class FuncFailed(Exception):
 
     def __str__(self):
         if self.logfile and os.path.exists(self.logfile):
-            msg = ("%s (log file is located at %s)" %
+            msg = ("%s (see %s for further information)" %
                    (self.msg, self.logfile))
         else:
             msg = self.msg
@@ -69,12 +69,9 @@ class FuncFailed(Exception):
 class TaskBase(event.Event):
     """Base class for task events"""
 
-    def __init__(self, t, logfile, d):
+    def __init__(self, t, d ):
         self._task = t
         self._package = d.getVar("PF", True)
-        self.taskfile = d.getVar("FILE", True)
-        self.taskname = self._task
-        self.logfile = logfile
         event.Event.__init__(self)
         self._message = "recipe %s: task %s: %s" % (d.getVar("PF", True), t, self.getDisplayName())
 
@@ -91,9 +88,6 @@ class TaskBase(event.Event):
 
 class TaskStarted(TaskBase):
     """Task execution started"""
-    def __init__(self, t, logfile, taskflags, d):
-        super(TaskStarted, self).__init__(t, logfile, d)
-        self.taskflags = taskflags
 
 class TaskSucceeded(TaskBase):
     """Task execution completed"""
@@ -102,11 +96,16 @@ class TaskFailed(TaskBase):
     """Task execution failed"""
 
     def __init__(self, task, logfile, metadata, errprinted = False):
+        self.logfile = logfile
         self.errprinted = errprinted
-        super(TaskFailed, self).__init__(task, logfile, metadata)
+        super(TaskFailed, self).__init__(task, metadata)
 
 class TaskFailedSilent(TaskBase):
     """Task execution failed (silently)"""
+    def __init__(self, task, logfile, metadata):
+        self.logfile = logfile
+        super(TaskFailedSilent, self).__init__(task, metadata)
+
     def getDisplayName(self):
         # Don't need to tell the user it was silent
         return "Failed"
@@ -114,7 +113,7 @@ class TaskFailedSilent(TaskBase):
 class TaskInvalid(TaskBase):
 
     def __init__(self, task, metadata):
-        super(TaskInvalid, self).__init__(task, None, metadata)
+        super(TaskInvalid, self).__init__(task, metadata)
         self._message = "No such task '%s'" % task
 
 
@@ -143,68 +142,54 @@ class LogTee(object):
 def exec_func(func, d, dirs = None):
     """Execute an BB 'function'"""
 
-    body = d.getVar(func)
+    body = data.getVar(func, d)
     if not body:
         if body is None:
             logger.warn("Function %s doesn't exist", func)
         return
 
-    flags = d.getVarFlags(func)
+    flags = data.getVarFlags(func, d)
     cleandirs = flags.get('cleandirs')
     if cleandirs:
-        for cdir in d.expand(cleandirs).split():
+        for cdir in data.expand(cleandirs, d).split():
             bb.utils.remove(cdir, True)
 
     if dirs is None:
         dirs = flags.get('dirs')
         if dirs:
-            dirs = d.expand(dirs).split()
+            dirs = data.expand(dirs, d).split()
 
     if dirs:
         for adir in dirs:
             bb.utils.mkdirhier(adir)
         adir = dirs[-1]
     else:
-        adir = d.getVar('B', True)
+        adir = data.getVar('B', d, 1)
         bb.utils.mkdirhier(adir)
 
     ispython = flags.get('python')
 
     lockflag = flags.get('lockfiles')
     if lockflag:
-        lockfiles = [d.expand(f) for f in lockflag.split()]
+        lockfiles = [data.expand(f, d) for f in lockflag.split()]
     else:
         lockfiles = None
 
-    tempdir = d.getVar('T', True)
+    tempdir = data.getVar('T', d, 1)
 
     # or func allows items to be executed outside of the normal
     # task set, such as buildhistory
-    task = d.getVar('BB_RUNTASK', True) or func
+    task = data.getVar('BB_RUNTASK', d, 1) or func
     if task == func:
         taskfunc = task
     else:
         taskfunc = "%s.%s" % (task, func)
 
-    runfmt = d.getVar('BB_RUNFMT', True) or "run.{func}.{pid}"
+    runfmt = data.getVar('BB_RUNFMT', d, 1) or "run.{func}.{pid}"
     runfn = runfmt.format(taskfunc=taskfunc, task=task, func=func, pid=os.getpid())
     runfile = os.path.join(tempdir, runfn)
     bb.utils.mkdirhier(os.path.dirname(runfile))
 
-    # Setup the courtesy link to the runfn, only for tasks
-    # we create the link 'just' before the run script is created
-    # if we create it after, and if the run script fails, then the
-    # link won't be created as an exception would be fired.
-    if task == func:
-        runlink = os.path.join(tempdir, 'run.{0}'.format(task))
-        if runlink:
-            bb.utils.remove(runlink)
-
-            try:
-                os.symlink(runfn, runlink)
-            except OSError:
-                pass
-
     with bb.utils.fileslocked(lockfiles):
         if ispython:
             exec_func_python(func, d, runfile, cwd=adir)
@@ -265,37 +250,14 @@ def exec_func_shell(func, d, runfile, cwd=None):
     d.delVarFlag('PWD', 'export')
 
     with open(runfile, 'w') as script:
-        script.write('''#!/bin/sh\n
-# Emit a useful diagnostic if something fails:
-bb_exit_handler() {
-    ret=$?
-    case $ret in
-    0)  ;;
-    *)  case $BASH_VERSION in
-        "")   echo "WARNING: exit code $ret from a shell command.";;
-        *)    echo "WARNING: ${BASH_SOURCE[0]}:${BASH_LINENO[0]} exit $ret from
-  \"$BASH_COMMAND\"";;
-        esac
-        exit $ret
-    esac
-}
-trap 'bb_exit_handler' 0
-set -e
-''')
-
-        bb.data.emit_func(func, script, d)
+        script.write('#!/bin/sh -e\n')
+        data.emit_func(func, script, d)
 
         if bb.msg.loggerVerboseLogs:
             script.write("set -x\n")
         if cwd:
             script.write("cd %s\n" % cwd)
         script.write("%s\n" % func)
-        script.write('''
-# cleanup
-ret=$?
-trap '' 0
-exit $?
-''')
 
     os.chmod(runfile, 0775)
 
@@ -313,8 +275,7 @@ exit $?
     bb.debug(2, "Executing shell function %s" % func)
 
     try:
-        with open(os.devnull, 'r+') as stdin:
-            bb.process.run(cmd, shell=False, stdin=stdin, log=logfile)
+        bb.process.run(cmd, shell=False, stdin=NULL, log=logfile)
     except bb.process.CmdError:
         logfn = d.getVar('BB_LOGFILE', True)
         raise FuncFailed(func, logfn)
@@ -322,13 +283,13 @@ exit $?
     bb.debug(2, "Shell function %s finished" % func)
 
 def _task_data(fn, task, d):
-    localdata = bb.data.createCopy(d)
+    localdata = data.createCopy(d)
     localdata.setVar('BB_FILENAME', fn)
     localdata.setVar('BB_CURRENTTASK', task[3:])
     localdata.setVar('OVERRIDES', 'task-%s:%s' %
                      (task[3:], d.getVar('OVERRIDES', False)))
     localdata.finalize()
-    bb.data.expandKeys(localdata)
+    data.expandKeys(localdata)
     return localdata
 
 def _exec_task(fn, task, d, quieterr):
@@ -337,7 +298,7 @@ def _exec_task(fn, task, d, quieterr):
     Execution of a task involves a bit more setup than executing a function,
     running it with its own local metadata, and with some useful variables set.
     """
-    if not d.getVarFlag(task, 'task'):
+    if not data.getVarFlag(task, 'task', d):
         event.fire(TaskInvalid(task, d), d)
         logger.error("No such task: %s" % task)
         return 1
@@ -349,14 +310,6 @@ def _exec_task(fn, task, d, quieterr):
     if not tempdir:
         bb.fatal("T variable not set, unable to build")
 
-    # Change nice level if we're asked to
-    nice = localdata.getVar("BB_TASK_NICE_LEVEL", True)
-    if nice:
-        curnice = os.nice(0)
-        nice = int(nice) - curnice
-        newnice = os.nice(nice)
-        logger.debug(1, "Renice to %s " % newnice)
-
     bb.utils.mkdirhier(tempdir)
 
     # Determine the logfile to generate
@@ -366,11 +319,12 @@ def _exec_task(fn, task, d, quieterr):
     # Document the order of the tasks...
     logorder = os.path.join(tempdir, 'log.task_order')
     try:
-        with open(logorder, 'a') as logorderfile:
-            logorderfile.write('{0} ({1}): {2}\n'.format(task, os.getpid(), logbase))
+        logorderfile = file(logorder, 'a')
     except OSError:
         logger.exception("Opening log file '%s'", logorder)
         pass
+    logorderfile.write('{0} ({1}): {2}\n'.format(task, os.getpid(), logbase))
+    logorderfile.close()
 
     # Setup the courtesy link to the logfn
     loglink = os.path.join(tempdir, 'log.{0}'.format(task))
@@ -394,10 +348,10 @@ def _exec_task(fn, task, d, quieterr):
             self.triggered = True
 
     # Handle logfiles
-    si = open('/dev/null', 'r')
+    si = file('/dev/null', 'r')
     try:
         bb.utils.mkdirhier(os.path.dirname(logfn))
-        logfile = open(logfn, 'w')
+        logfile = file(logfn, 'w')
     except OSError:
         logger.exception("Opening log file '%s'", logfn)
         pass
@@ -425,9 +379,7 @@ def _exec_task(fn, task, d, quieterr):
     localdata.setVar('BB_LOGFILE', logfn)
     localdata.setVar('BB_RUNTASK', task)
 
-    flags = localdata.getVarFlags(task)
-
-    event.fire(TaskStarted(task, logfn, flags, localdata), localdata)
+    event.fire(TaskStarted(task, localdata), localdata)
     try:
         for func in (prefuncs or '').split():
             exec_func(func, localdata)
@@ -464,7 +416,7 @@ def _exec_task(fn, task, d, quieterr):
             logger.debug(2, "Zero size logfn %s, removing", logfn)
             bb.utils.remove(logfn)
             bb.utils.remove(loglink)
-    event.fire(TaskSucceeded(task, logfn, localdata), localdata)
+    event.fire(TaskSucceeded(task, localdata), localdata)
 
     if not localdata.getVarFlag(task, 'nostamp') and not localdata.getVarFlag(task, 'selfstamp'):
         make_stamp(task, localdata)
@@ -478,7 +430,7 @@ def exec_task(fn, task, d, profile = False):
             quieterr = True
 
         if profile: 
-            profname = "profile-%s.log" % (d.getVar("PN", True) + "-" + task)
+            profname = "profile-%s.log" % (os.path.basename(fn) + "-" + task)
             try:
                 import cProfile as profile
             except:
@@ -581,7 +533,8 @@ def make_stamp(task, d, file_name = None):
     # change on broken NFS filesystems
     if stamp:
         bb.utils.remove(stamp)
-        open(stamp, "w").close()
+        f = open(stamp, "w")
+        f.close()
 
     # If we're in task context, write out a signature file for each task
     # as it completes
@@ -623,7 +576,7 @@ def stampfile(taskname, d, file_name = None):
     return stamp_internal(taskname, d, file_name)
 
 def add_tasks(tasklist, d):
-    task_deps = d.getVar('_task_deps')
+    task_deps = data.getVar('_task_deps', d)
     if not task_deps:
         task_deps = {}
     if not 'tasks' in task_deps:
@@ -632,25 +585,24 @@ def add_tasks(tasklist, d):
         task_deps['parents'] = {}
 
     for task in tasklist:
-        task = d.expand(task)
-        d.setVarFlag(task, 'task', 1)
+        task = data.expand(task, d)
+        data.setVarFlag(task, 'task', 1, d)
 
         if not task in task_deps['tasks']:
             task_deps['tasks'].append(task)
 
-        flags = d.getVarFlags(task)
+        flags = data.getVarFlags(task, d)
         def getTask(name):
             if not name in task_deps:
                 task_deps[name] = {}
             if name in flags:
-                deptask = d.expand(flags[name])
+                deptask = data.expand(flags[name], d)
                 task_deps[name][task] = deptask
         getTask('depends')
         getTask('rdepends')
         getTask('deptask')
         getTask('rdeptask')
         getTask('recrdeptask')
-        getTask('recideptask')
         getTask('nostamp')
         getTask('fakeroot')
         getTask('noexec')
@@ -658,15 +610,15 @@ def add_tasks(tasklist, d):
         task_deps['parents'][task] = []
         if 'deps' in flags:
             for dep in flags['deps']:
-                dep = d.expand(dep)
+                dep = data.expand(dep, d)
                 task_deps['parents'][task].append(dep)
 
     # don't assume holding a reference
-    d.setVar('_task_deps', task_deps)
+    data.setVar('_task_deps', task_deps, d)
 
 def remove_task(task, kill, d):
     """Remove an BB 'task'.
 
        If kill is 1, also remove tasks that depend on this task."""
 
-    d.delVarFlag(task, 'task')
+    data.delVarFlag(task, 'task', d)

bitbake/lib/bb/cache.py

@@ -43,7 +43,7 @@ except ImportError:
     logger.info("Importing cPickle failed. "
                 "Falling back to a very slow implementation.")
 
-__cache_version__ = "147"
+__cache_version__ = "145"
 
 def getCacheFile(path, filename, data_hash):
     return os.path.join(path, filename + "." + data_hash)
@@ -524,18 +524,9 @@ class Cache(object):
                     self.remove(fn)
                     return False
 
-        if hasattr(info_array[0], 'file_checksums'):
-            for _, fl in info_array[0].file_checksums.items():
-                for f in fl.split():
-                    if not os.path.exists(f):
-                        logger.debug(2, "Cache: %s's file checksum list file %s was removed",
-                                        fn, f)
-                        self.remove(fn)
-                        return False
-
         if appends != info_array[0].appends:
             logger.debug(2, "Cache: appends for %s changed", fn)
-            logger.debug(2, "%s to %s" % (str(appends), str(info_array[0].appends)))
+            bb.note("%s to %s" % (str(appends), str(info_array[0].appends)))
             self.remove(fn)
             return False
 
@@ -724,6 +715,7 @@ class CacheData(object):
         for info in info_array:
             info.add_cacheData(self, fn)
 
+
 class MultiProcessCache(object):
     """
     BitBake multi-process cache implementation
@@ -745,18 +737,12 @@ class MultiProcessCache(object):
         self.cachefile = os.path.join(cachedir, self.__class__.cache_file_name)
         logger.debug(1, "Using cache in '%s'", self.cachefile)
 
-        glf = bb.utils.lockfile(self.cachefile + ".lock")
-
         try:
-            with open(self.cachefile, "rb") as f:
-                p = pickle.Unpickler(f)
-                data, version = p.load()
+            p = pickle.Unpickler(file(self.cachefile, "rb"))
+            data, version = p.load()
         except:
-            bb.utils.unlockfile(glf)
             return
 
-        bb.utils.unlockfile(glf)
-
         if version != self.__class__.CACHE_VERSION:
             return
 
@@ -793,9 +779,8 @@ class MultiProcessCache(object):
                 i = i + 1
                 continue
 
-            with open(self.cachefile + "-" + str(i), "wb") as f:
-                p = pickle.Pickler(f, -1)
-                p.dump([self.cachedata_extras, self.__class__.CACHE_VERSION])
+            p = pickle.Pickler(file(self.cachefile + "-" + str(i), "wb"), -1)
+            p.dump([self.cachedata_extras, self.__class__.CACHE_VERSION])
 
         bb.utils.unlockfile(lf)
         bb.utils.unlockfile(glf)
@@ -813,9 +798,8 @@ class MultiProcessCache(object):
         glf = bb.utils.lockfile(self.cachefile + ".lock")
 
         try:
-            with open(self.cachefile, "rb") as f:
-                p = pickle.Unpickler(f)
-                data, version = p.load()
+            p = pickle.Unpickler(file(self.cachefile, "rb"))
+            data, version = p.load()
         except (IOError, EOFError):
             data, version = None, None
 
@@ -825,9 +809,8 @@ class MultiProcessCache(object):
         for f in [y for y in os.listdir(os.path.dirname(self.cachefile)) if y.startswith(os.path.basename(self.cachefile) + '-')]:
             f = os.path.join(os.path.dirname(self.cachefile), f)
             try:
-                with open(f, "rb") as fd:
-                    p = pickle.Unpickler(fd)
-                    extradata, version = p.load()
+                p = pickle.Unpickler(file(f, "rb"))
+                extradata, version = p.load()
             except (IOError, EOFError):
                 extradata, version = self.create_cachedata(), None
 
@@ -839,9 +822,8 @@ class MultiProcessCache(object):
 
         self.compress_keys(data)
 
-        with open(self.cachefile, "wb") as f:
-            p = pickle.Pickler(f, -1)
-            p.dump([data, self.__class__.CACHE_VERSION])
+        p = pickle.Pickler(file(self.cachefile, "wb"), -1)
+        p.dump([data, self.__class__.CACHE_VERSION])
 
         bb.utils.unlockfile(glf)
 

bitbake/lib/bb/cache_extra.py

@@ -35,12 +35,6 @@ class HobRecipeInfo(RecipeInfoCommon):
     # such as (bb_cache.dat, bb_extracache_hob.dat) 
     cachefile = "bb_extracache_" + classname +".dat"        
 
-    # override this member with the list of extra cache fields
-    # that this class will provide
-    cachefields = ['summary', 'license', 'section',
-            'description', 'homepage', 'bugtracker',
-            'prevision', 'files_info']
-
     def __init__(self, filename, metadata):
 
         self.summary = self.getvar('SUMMARY', metadata)

bitbake/lib/bb/command.py

@@ -59,14 +59,11 @@ class Command:
         # FIXME Add lock for this
         self.currentAsyncCommand = None
 
-    def runCommand(self, commandline, ro_only = False):
+    def runCommand(self, commandline):
         command = commandline.pop(0)
         if hasattr(CommandsSync, command):
             # Can run synchronous commands straight away
             command_method = getattr(self.cmds_sync, command)
-            if ro_only:
-                if not hasattr(command_method, 'readonly') or False == getattr(command_method, 'readonly'):
-                    return None, "Not able to execute not readonly commands in readonly mode"
             try:
                 result = command_method(self, commandline)
             except CommandError as exc:
@@ -81,7 +78,7 @@ class Command:
         if command not in CommandsAsync.__dict__:
             return None, "No such command"
         self.currentAsyncCommand = (command, commandline)
-        self.cooker.configuration.server_register_idlecallback(self.cooker.runCommands, self.cooker)
+        self.cooker.server_registration_cb(self.cooker.runCommands, self.cooker)
         return True, None
 
     def runAsyncCommand(self):
@@ -90,7 +87,8 @@ class Command:
                 (command, options) = self.currentAsyncCommand
                 commandmethod = getattr(CommandsAsync, command)
                 needcache = getattr( commandmethod, "needcache" )
-                if needcache and self.cooker.state != bb.cooker.state.running:
+                if (needcache and self.cooker.state in
+                    (bb.cooker.state.initial, bb.cooker.state.parsing)):
                     self.cooker.updateCache()
                     return True
                 else:
@@ -117,14 +115,14 @@ class Command:
             return False
 
     def finishAsyncCommand(self, msg=None, code=None):
-        if msg or msg == "":
-            bb.event.fire(CommandFailed(msg), self.cooker.event_data)
+        if msg:
+            bb.event.fire(CommandFailed(msg), self.cooker.configuration.event_data)
         elif code:
-            bb.event.fire(CommandExit(code), self.cooker.event_data)
+            bb.event.fire(CommandExit(code), self.cooker.configuration.event_data)
         else:
-            bb.event.fire(CommandCompleted(), self.cooker.event_data)
+            bb.event.fire(CommandCompleted(), self.cooker.configuration.event_data)
         self.currentAsyncCommand = None
-        self.cooker.finishcommand()
+
 
 class CommandsSync:
     """
@@ -137,50 +135,44 @@ class CommandsSync:
         """
         Trigger cooker 'shutdown' mode
         """
-        command.cooker.shutdown(False)
+        command.cooker.shutdown()
 
-    def stateForceShutdown(self, command, params):
+    def stateStop(self, command, params):
         """
         Stop the cooker
         """
-        command.cooker.shutdown(True)
+        command.cooker.stop()
 
-    def getAllKeysWithFlags(self, command, params):
+    def getCmdLineAction(self, command, params):
         """
-        Returns a dump of the global state. Call with
-        variable flags to be retrieved as params.
+        Get any command parsed from the commandline
         """
-        flaglist = params[0]
-        return command.cooker.getAllKeysWithFlags(flaglist)
-    getAllKeysWithFlags.readonly = True
+        cmd_action = command.cooker.commandlineAction
+        if cmd_action is None:
+            return None
+        elif 'msg' in cmd_action and cmd_action['msg']:
+            raise CommandError(cmd_action['msg'])
+        else:
+            return cmd_action['action']
 
     def getVariable(self, command, params):
         """
-        Read the value of a variable from data
+        Read the value of a variable from configuration.data
         """
         varname = params[0]
         expand = True
         if len(params) > 1:
-            expand = (params[1] == "True")
+            expand = params[1]
 
-        return command.cooker.data.getVar(varname, expand)
-    getVariable.readonly = True
+        return command.cooker.configuration.data.getVar(varname, expand)
 
     def setVariable(self, command, params):
         """
-        Set the value of variable in data
+        Set the value of variable in configuration.data
         """
         varname = params[0]
         value = str(params[1])
-        command.cooker.data.setVar(varname, value)
-
-    def setConfig(self, command, params):
-        """
-        Set the value of variable in configuration
-        """
-        varname = params[0]
-        value = str(params[1])
-        setattr(command.cooker.configuration, varname, value)
+        command.cooker.configuration.data.setVar(varname, value)
 
     def enableDataTracking(self, command, params):
         """
@@ -212,7 +204,6 @@ class CommandsSync:
         Get the CPU count on the bitbake server
         """
         return bb.utils.cpu_count()
-    getCpuCount.readonly = True
 
     def matchFile(self, command, params):
         fMatch = params[0]
@@ -222,45 +213,13 @@ class CommandsSync:
         image = params[0]
         base_image = params[1]
         package_queue = params[2]
-        timestamp = params[3]
-        description = params[4]
-        return command.cooker.generateNewImage(image, base_image,
-                        package_queue, timestamp, description)
-
-    def ensureDir(self, command, params):
-        directory = params[0]
-        bb.utils.mkdirhier(directory)
+        return command.cooker.generateNewImage(image, base_image, package_queue)
 
     def setVarFile(self, command, params):
-        """
-        Save a variable in a file; used for saving in a configuration file
-        """
         var = params[0]
         val = params[1]
         default_file = params[2]
-        op = params[3]
-        command.cooker.modifyConfigurationVar(var, val, default_file, op)
-
-    def removeVarFile(self, command, params):
-        """
-        Remove a variable declaration from a file
-        """
-        var = params[0]
-        command.cooker.removeConfigurationVar(var)
-
-    def createConfigFile(self, command, params):
-        """
-        Create an extra configuration file
-        """
-        name = params[0]
-        command.cooker.createConfigFile(name)
-
-    def setEventMask(self, command, params):
-        handlerNum = params[0]
-        llevel = params[1]
-        debug_domains = params[2]
-        mask = params[3]
-        return bb.event.set_UIHmask(handlerNum, llevel, debug_domains, mask)
+        command.cooker.saveConfigurationVar(var, val, default_file)
 
 class CommandsAsync:
     """
@@ -408,11 +367,19 @@ class CommandsAsync:
         command.finishAsyncCommand()
     parseFiles.needcache = True
 
+    def reparseFiles(self, command, params):
+        """
+        Reparse .bb files
+        """
+        command.cooker.reparseFiles()
+        command.finishAsyncCommand()
+    reparseFiles.needcache = True
+
     def compareRevisions(self, command, params):
         """
         Parse the .bb files
         """
-        if bb.fetch.fetcher_compare_revisions(command.cooker.data):
+        if bb.fetch.fetcher_compare_revisions(command.cooker.configuration.data):
             command.finishAsyncCommand(code=1)
         else:
             command.finishAsyncCommand()
@@ -422,11 +389,9 @@ class CommandsAsync:
         """
         Parse the configuration files
         """
-        prefiles = params[0].split()
-        postfiles = params[1].split()
-        command.cooker.configuration.prefile = prefiles
-        command.cooker.configuration.postfile = postfiles
-        command.cooker.loadConfigurationData()
+        prefiles = params[0]
+        postfiles = params[1]
+        command.cooker.parseConfigurationFiles(prefiles, postfiles)
         command.finishAsyncCommand()
     parseConfigurationFiles.needcache = False
 
@@ -435,7 +400,7 @@ class CommandsAsync:
         Trigger a certain event
         """
         event = params[0]
-        bb.event.fire(eval(event), command.cooker.data)
+        bb.event.fire(eval(event), command.cooker.configuration.data)
         command.currentAsyncCommand = None
     triggerEvent.needcache = False
 

bitbake/lib/bb/compat.py

@@ -1,6 +1,928 @@
 """Code pulled from future python versions, here for compatibility"""
 
-from collections import MutableMapping, KeysView, ValuesView, ItemsView, OrderedDict
-from functools import total_ordering
+from collections import MutableMapping, KeysView, ValuesView, ItemsView
+try:
+    from thread import get_ident as _get_ident
+except ImportError:
+    from dummy_thread import get_ident as _get_ident
+
+def total_ordering(cls):
+    """Class decorator that fills in missing ordering methods"""
+    convert = {
+        '__lt__': [('__gt__', lambda self, other: other < self),
+                   ('__le__', lambda self, other: not other < self),
+                   ('__ge__', lambda self, other: not self < other)],
+        '__le__': [('__ge__', lambda self, other: other <= self),
+                   ('__lt__', lambda self, other: not other <= self),
+                   ('__gt__', lambda self, other: not self <= other)],
+        '__gt__': [('__lt__', lambda self, other: other > self),
+                   ('__ge__', lambda self, other: not other > self),
+                   ('__le__', lambda self, other: not self > other)],
+        '__ge__': [('__le__', lambda self, other: other >= self),
+                   ('__gt__', lambda self, other: not other >= self),
+                   ('__lt__', lambda self, other: not self >= other)]
+    }
+    roots = set(dir(cls)) & set(convert)
+    if not roots:
+        raise ValueError('must define at least one ordering operation: < > <= >=')
+    root = max(roots)       # prefer __lt__ to __le__ to __gt__ to __ge__
+    for opname, opfunc in convert[root]:
+        if opname not in roots:
+            opfunc.__name__ = opname
+            opfunc.__doc__ = getattr(int, opname).__doc__
+            setattr(cls, opname, opfunc)
+    return cls
+
+class OrderedDict(dict):
+    'Dictionary that remembers insertion order'
+    # An inherited dict maps keys to values.
+    # The inherited dict provides __getitem__, __len__, __contains__, and get.
+    # The remaining methods are order-aware.
+    # Big-O running times for all methods are the same as regular dictionaries.
+
+    # The internal self.__map dict maps keys to links in a doubly linked list.
+    # The circular doubly linked list starts and ends with a sentinel element.
+    # The sentinel element never gets deleted (this simplifies the algorithm).
+    # Each link is stored as a list of length three:  [PREV, NEXT, KEY].
+
+    def __init__(self, *args, **kwds):
+        '''Initialize an ordered dictionary.  The signature is the same as
+        regular dictionaries, but keyword arguments are not recommended because
+        their insertion order is arbitrary.
+
+        '''
+        if len(args) > 1:
+            raise TypeError('expected at most 1 arguments, got %d' % len(args))
+        try:
+            self.__root
+        except AttributeError:
+            self.__root = root = []                     # sentinel node
+            root[:] = [root, root, None]
+            self.__map = {}
+        self.__update(*args, **kwds)
+
+    def __setitem__(self, key, value, PREV=0, NEXT=1, dict_setitem=dict.__setitem__):
+        'od.__setitem__(i, y) <==> od[i]=y'
+        # Setting a new item creates a new link at the end of the linked list,
+        # and the inherited dictionary is updated with the new key/value pair.
+        if key not in self:
+            root = self.__root
+            last = root[PREV]
+            last[NEXT] = root[PREV] = self.__map[key] = [last, root, key]
+        dict_setitem(self, key, value)
+
+    def __delitem__(self, key, PREV=0, NEXT=1, dict_delitem=dict.__delitem__):
+        'od.__delitem__(y) <==> del od[y]'
+        # Deleting an existing item uses self.__map to find the link which gets
+        # removed by updating the links in the predecessor and successor nodes.
+        dict_delitem(self, key)
+        link_prev, link_next, key = self.__map.pop(key)
+        link_prev[NEXT] = link_next
+        link_next[PREV] = link_prev
+
+    def __iter__(self):
+        'od.__iter__() <==> iter(od)'
+        # Traverse the linked list in order.
+        NEXT, KEY = 1, 2
+        root = self.__root
+        curr = root[NEXT]
+        while curr is not root:
+            yield curr[KEY]
+            curr = curr[NEXT]
+
+    def __reversed__(self):
+        'od.__reversed__() <==> reversed(od)'
+        # Traverse the linked list in reverse order.
+        PREV, KEY = 0, 2
+        root = self.__root
+        curr = root[PREV]
+        while curr is not root:
+            yield curr[KEY]
+            curr = curr[PREV]
+
+    def clear(self):
+        'od.clear() -> None.  Remove all items from od.'
+        for node in self.__map.itervalues():
+            del node[:]
+        root = self.__root
+        root[:] = [root, root, None]
+        self.__map.clear()
+        dict.clear(self)
+
+    # -- the following methods do not depend on the internal structure --
+
+    def keys(self):
+        'od.keys() -> list of keys in od'
+        return list(self)
+
+    def values(self):
+        'od.values() -> list of values in od'
+        return [self[key] for key in self]
+
+    def items(self):
+        'od.items() -> list of (key, value) pairs in od'
+        return [(key, self[key]) for key in self]
+
+    def iterkeys(self):
+        'od.iterkeys() -> an iterator over the keys in od'
+        return iter(self)
+
+    def itervalues(self):
+        'od.itervalues -> an iterator over the values in od'
+        for k in self:
+            yield self[k]
+
+    def iteritems(self):
+        'od.iteritems -> an iterator over the (key, value) pairs in od'
+        for k in self:
+            yield (k, self[k])
+
+    update = MutableMapping.update
+
+    __update = update # let subclasses override update without breaking __init__
+
+    __marker = object()
+
+    def pop(self, key, default=__marker):
+        '''od.pop(k[,d]) -> v, remove specified key and return the corresponding
+        value.  If key is not found, d is returned if given, otherwise KeyError
+        is raised.
+
+        '''
+        if key in self:
+            result = self[key]
+            del self[key]
+            return result
+        if default is self.__marker:
+            raise KeyError(key)
+        return default
+
+    def setdefault(self, key, default=None):
+        'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
+        if key in self:
+            return self[key]
+        self[key] = default
+        return default
+
+    def popitem(self, last=True):
+        '''od.popitem() -> (k, v), return and remove a (key, value) pair.
+        Pairs are returned in LIFO order if last is true or FIFO order if false.
+
+        '''
+        if not self:
+            raise KeyError('dictionary is empty')
+        key = next(reversed(self) if last else iter(self))
+        value = self.pop(key)
+        return key, value
+
+    def __repr__(self, _repr_running={}):
+        'od.__repr__() <==> repr(od)'
+        call_key = id(self), _get_ident()
+        if call_key in _repr_running:
+            return '...'
+        _repr_running[call_key] = 1
+        try:
+            if not self:
+                return '%s()' % (self.__class__.__name__,)
+            return '%s(%r)' % (self.__class__.__name__, self.items())
+        finally:
+            del _repr_running[call_key]
+
+    def __reduce__(self):
+        'Return state information for pickling'
+        items = [[k, self[k]] for k in self]
+        inst_dict = vars(self).copy()
+        for k in vars(OrderedDict()):
+            inst_dict.pop(k, None)
+        if inst_dict:
+            return (self.__class__, (items,), inst_dict)
+        return self.__class__, (items,)
+
+    def copy(self):
+        'od.copy() -> a shallow copy of od'
+        return self.__class__(self)
+
+    @classmethod
+    def fromkeys(cls, iterable, value=None):
+        '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
+        If not specified, the value defaults to None.
+
+        '''
+        self = cls()
+        for key in iterable:
+            self[key] = value
+        return self
+
+    def __eq__(self, other):
+        '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
+        while comparison to a regular mapping is order-insensitive.
+
+        '''
+        if isinstance(other, OrderedDict):
+            return len(self)==len(other) and self.items() == other.items()
+        return dict.__eq__(self, other)
+
+    def __ne__(self, other):
+        'od.__ne__(y) <==> od!=y'
+        return not self == other
+
+    # -- the following methods support python 3.x style dictionary views --
+
+    def viewkeys(self):
+        "od.viewkeys() -> a set-like object providing a view on od's keys"
+        return KeysView(self)
+
+    def viewvalues(self):
+        "od.viewvalues() -> an object providing a view on od's values"
+        return ValuesView(self)
+
+    def viewitems(self):
+        "od.viewitems() -> a set-like object providing a view on od's items"
+        return ItemsView(self)
+
+# Multiprocessing pool code imported from python 2.7.3. Previous versions of 
+# python have issues in this code which hang pool usage
+
+#
+# Module providing the `Pool` class for managing a process pool
+#
+# multiprocessing/pool.py
+#
+# Copyright (c) 2006-2008, R Oudkerk
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+# 3. Neither the name of author nor the names of any contributors may be
+#    used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+#
+import threading
+import Queue
+import itertools
+import collections
+import time
+
+import multiprocessing
+from multiprocessing import Process, cpu_count, TimeoutError, pool
+from multiprocessing.util import Finalize, debug
+
+#
+# Constants representing the state of a pool
+#
+
+RUN = 0
+CLOSE = 1
+TERMINATE = 2
+
+#
+# Miscellaneous
+#
+
+def mapstar(args):
+    return map(*args)
+
+class MaybeEncodingError(Exception):
+    """Wraps possible unpickleable errors, so they can be
+    safely sent through the socket."""
+
+    def __init__(self, exc, value):
+        self.exc = repr(exc)
+        self.value = repr(value)
+        super(MaybeEncodingError, self).__init__(self.exc, self.value)
+
+    def __str__(self):
+        return "Error sending result: '%s'. Reason: '%s'" % (self.value,
+                                                             self.exc)
+
+    def __repr__(self):
+        return "<MaybeEncodingError: %s>" % str(self)
+
+def worker(inqueue, outqueue, initializer=None, initargs=(), maxtasks=None):
+    assert maxtasks is None or (type(maxtasks) == int and maxtasks > 0)
+    put = outqueue.put
+    get = inqueue.get
+    if hasattr(inqueue, '_writer'):
+        inqueue._writer.close()
+        outqueue._reader.close()
+
+    if initializer is not None:
+        initializer(*initargs)
+
+    completed = 0
+    while maxtasks is None or (maxtasks and completed < maxtasks):
+        try:
+            task = get()
+        except (EOFError, IOError):
+            debug('worker got EOFError or IOError -- exiting')
+            break
+
+        if task is None:
+            debug('worker got sentinel -- exiting')
+            break
+
+        job, i, func, args, kwds = task
+        try:
+            result = (True, func(*args, **kwds))
+        except Exception, e:
+            result = (False, e)
+        try:
+            put((job, i, result))
+        except Exception as e:
+            wrapped = MaybeEncodingError(e, result[1])
+            debug("Possible encoding error while sending result: %s" % (
+                wrapped))
+            put((job, i, (False, wrapped)))
+        completed += 1
+    debug('worker exiting after %d tasks' % completed)
+
+
+class Pool(object):
+    '''
+    Class which supports an async version of the `apply()` builtin
+    '''
+    Process = Process
+
+    def __init__(self, processes=None, initializer=None, initargs=(),
+                 maxtasksperchild=None):
+        self._setup_queues()
+        self._taskqueue = Queue.Queue()
+        self._cache = {}
+        self._state = RUN
+        self._maxtasksperchild = maxtasksperchild
+        self._initializer = initializer
+        self._initargs = initargs
+
+        if processes is None:
+            try:
+                processes = cpu_count()
+            except NotImplementedError:
+                processes = 1
+        if processes < 1:
+            raise ValueError("Number of processes must be at least 1")
+
+        if initializer is not None and not hasattr(initializer, '__call__'):
+            raise TypeError('initializer must be a callable')
+
+        self._processes = processes
+        self._pool = []
+        self._repopulate_pool()
+
+        self._worker_handler = threading.Thread(
+            target=Pool._handle_workers,
+            args=(self, )
+            )
+        self._worker_handler.daemon = True
+        self._worker_handler._state = RUN
+        self._worker_handler.start()
+
+
+        self._task_handler = threading.Thread(
+            target=Pool._handle_tasks,
+            args=(self._taskqueue, self._quick_put, self._outqueue, self._pool)
+            )
+        self._task_handler.daemon = True
+        self._task_handler._state = RUN
+        self._task_handler.start()
+
+        self._result_handler = threading.Thread(
+            target=Pool._handle_results,
+            args=(self._outqueue, self._quick_get, self._cache)
+            )
+        self._result_handler.daemon = True
+        self._result_handler._state = RUN
+        self._result_handler.start()
+
+        self._terminate = Finalize(
+            self, self._terminate_pool,
+            args=(self._taskqueue, self._inqueue, self._outqueue, self._pool,
+                  self._worker_handler, self._task_handler,
+                  self._result_handler, self._cache),
+            exitpriority=15
+            )
+
+    def _join_exited_workers(self):
+        """Cleanup after any worker processes which have exited due to reaching
+        their specified lifetime.  Returns True if any workers were cleaned up.
+        """
+        cleaned = False
+        for i in reversed(range(len(self._pool))):
+            worker = self._pool[i]
+            if worker.exitcode is not None:
+                # worker exited
+                debug('cleaning up worker %d' % i)
+                worker.join()
+                cleaned = True
+                del self._pool[i]
+        return cleaned
+
+    def _repopulate_pool(self):
+        """Bring the number of pool processes up to the specified number,
+        for use after reaping workers which have exited.
+        """
+        for i in range(self._processes - len(self._pool)):
+            w = self.Process(target=worker,
+                             args=(self._inqueue, self._outqueue,
+                                   self._initializer,
+                                   self._initargs, self._maxtasksperchild)
+                            )
+            self._pool.append(w)
+            w.name = w.name.replace('Process', 'PoolWorker')
+            w.daemon = True
+            w.start()
+            debug('added worker')
+
+    def _maintain_pool(self):
+        """Clean up any exited workers and start replacements for them.
+        """
+        if self._join_exited_workers():
+            self._repopulate_pool()
+
+    def _setup_queues(self):
+        from multiprocessing.queues import SimpleQueue
+        self._inqueue = SimpleQueue()
+        self._outqueue = SimpleQueue()
+        self._quick_put = self._inqueue._writer.send
+        self._quick_get = self._outqueue._reader.recv
+
+    def apply(self, func, args=(), kwds={}):
+        '''
+        Equivalent of `apply()` builtin
+        '''
+        assert self._state == RUN
+        return self.apply_async(func, args, kwds).get()
+
+    def map(self, func, iterable, chunksize=None):
+        '''
+        Equivalent of `map()` builtin
+        '''
+        assert self._state == RUN
+        return self.map_async(func, iterable, chunksize).get()
+
+    def imap(self, func, iterable, chunksize=1):
+        '''
+        Equivalent of `itertools.imap()` -- can be MUCH slower than `Pool.map()`
+        '''
+        assert self._state == RUN
+        if chunksize == 1:
+            result = IMapIterator(self._cache)
+            self._taskqueue.put((((result._job, i, func, (x,), {})
+                         for i, x in enumerate(iterable)), result._set_length))
+            return result
+        else:
+            assert chunksize > 1
+            task_batches = Pool._get_tasks(func, iterable, chunksize)
+            result = IMapIterator(self._cache)
+            self._taskqueue.put((((result._job, i, mapstar, (x,), {})
+                     for i, x in enumerate(task_batches)), result._set_length))
+            return (item for chunk in result for item in chunk)
+
+    def imap_unordered(self, func, iterable, chunksize=1):
+        '''
+        Like `imap()` method but ordering of results is arbitrary
+        '''
+        assert self._state == RUN
+        if chunksize == 1:
+            result = IMapUnorderedIterator(self._cache)
+            self._taskqueue.put((((result._job, i, func, (x,), {})
+                         for i, x in enumerate(iterable)), result._set_length))
+            return result
+        else:
+            assert chunksize > 1
+            task_batches = Pool._get_tasks(func, iterable, chunksize)
+            result = IMapUnorderedIterator(self._cache)
+            self._taskqueue.put((((result._job, i, mapstar, (x,), {})
+                     for i, x in enumerate(task_batches)), result._set_length))
+            return (item for chunk in result for item in chunk)
+
+    def apply_async(self, func, args=(), kwds={}, callback=None):
+        '''
+        Asynchronous equivalent of `apply()` builtin
+        '''
+        assert self._state == RUN
+        result = ApplyResult(self._cache, callback)
+        self._taskqueue.put(([(result._job, None, func, args, kwds)], None))
+        return result
+
+    def map_async(self, func, iterable, chunksize=None, callback=None):
+        '''
+        Asynchronous equivalent of `map()` builtin
+        '''
+        assert self._state == RUN
+        if not hasattr(iterable, '__len__'):
+            iterable = list(iterable)
+
+        if chunksize is None:
+            chunksize, extra = divmod(len(iterable), len(self._pool) * 4)
+            if extra:
+                chunksize += 1
+        if len(iterable) == 0:
+            chunksize = 0
+
+        task_batches = Pool._get_tasks(func, iterable, chunksize)
+        result = MapResult(self._cache, chunksize, len(iterable), callback)
+        self._taskqueue.put((((result._job, i, mapstar, (x,), {})
+                              for i, x in enumerate(task_batches)), None))
+        return result
+
+    @staticmethod
+    def _handle_workers(pool):
+        thread = threading.current_thread()
+
+        # Keep maintaining workers until the cache gets drained, unless the pool
+        # is terminated.
+        while thread._state == RUN or (pool._cache and thread._state != TERMINATE):
+            pool._maintain_pool()
+            time.sleep(0.1)
+        # send sentinel to stop workers
+        pool._taskqueue.put(None)
+        debug('worker handler exiting')
+
+    @staticmethod
+    def _handle_tasks(taskqueue, put, outqueue, pool):
+        thread = threading.current_thread()
+
+        for taskseq, set_length in iter(taskqueue.get, None):
+            i = -1
+            for i, task in enumerate(taskseq):
+                if thread._state:
+                    debug('task handler found thread._state != RUN')
+                    break
+                try:
+                    put(task)
+                except IOError:
+                    debug('could not put task on queue')
+                    break
+            else:
+                if set_length:
+                    debug('doing set_length()')
+                    set_length(i+1)
+                continue
+            break
+        else:
+            debug('task handler got sentinel')
+
+
+        try:
+            # tell result handler to finish when cache is empty
+            debug('task handler sending sentinel to result handler')
+            outqueue.put(None)
+
+            # tell workers there is no more work
+            debug('task handler sending sentinel to workers')
+            for p in pool:
+                put(None)
+        except IOError:
+            debug('task handler got IOError when sending sentinels')
+
+        debug('task handler exiting')
+
+    @staticmethod
+    def _handle_results(outqueue, get, cache):
+        thread = threading.current_thread()
+
+        while 1:
+            try:
+                task = get()
+            except (IOError, EOFError):
+                debug('result handler got EOFError/IOError -- exiting')
+                return
+
+            if thread._state:
+                assert thread._state == TERMINATE
+                debug('result handler found thread._state=TERMINATE')
+                break
+
+            if task is None:
+                debug('result handler got sentinel')
+                break
+
+            job, i, obj = task
+            try:
+                cache[job]._set(i, obj)
+            except KeyError:
+                pass
+
+        while cache and thread._state != TERMINATE:
+            try:
+                task = get()
+            except (IOError, EOFError):
+                debug('result handler got EOFError/IOError -- exiting')
+                return
+
+            if task is None:
+                debug('result handler ignoring extra sentinel')
+                continue
+            job, i, obj = task
+            try:
+                cache[job]._set(i, obj)
+            except KeyError:
+                pass
+
+        if hasattr(outqueue, '_reader'):
+            debug('ensuring that outqueue is not full')
+            # If we don't make room available in outqueue then
+            # attempts to add the sentinel (None) to outqueue may
+            # block.  There is guaranteed to be no more than 2 sentinels.
+            try:
+                for i in range(10):
+                    if not outqueue._reader.poll():
+                        break
+                    get()
+            except (IOError, EOFError):
+                pass
+
+        debug('result handler exiting: len(cache)=%s, thread._state=%s',
+              len(cache), thread._state)
+
+    @staticmethod
+    def _get_tasks(func, it, size):
+        it = iter(it)
+        while 1:
+            x = tuple(itertools.islice(it, size))
+            if not x:
+                return
+            yield (func, x)
+
+    def __reduce__(self):
+        raise NotImplementedError(
+              'pool objects cannot be passed between processes or pickled'
+              )
+
+    def close(self):
+        debug('closing pool')
+        if self._state == RUN:
+            self._state = CLOSE
+            self._worker_handler._state = CLOSE
+
+    def terminate(self):
+        debug('terminating pool')
+        self._state = TERMINATE
+        self._worker_handler._state = TERMINATE
+        self._terminate()
+
+    def join(self):
+        debug('joining pool')
+        assert self._state in (CLOSE, TERMINATE)
+        self._worker_handler.join()
+        self._task_handler.join()
+        self._result_handler.join()
+        for p in self._pool:
+            p.join()
+
+    @staticmethod
+    def _help_stuff_finish(inqueue, task_handler, size):
+        # task_handler may be blocked trying to put items on inqueue
+        debug('removing tasks from inqueue until task handler finished')
+        inqueue._rlock.acquire()
+        while task_handler.is_alive() and inqueue._reader.poll():
+            inqueue._reader.recv()
+            time.sleep(0)
+
+    @classmethod
+    def _terminate_pool(cls, taskqueue, inqueue, outqueue, pool,
+                        worker_handler, task_handler, result_handler, cache):
+        # this is guaranteed to only be called once
+        debug('finalizing pool')
+
+        worker_handler._state = TERMINATE
+        task_handler._state = TERMINATE
+
+        debug('helping task handler/workers to finish')
+        cls._help_stuff_finish(inqueue, task_handler, len(pool))
+
+        assert result_handler.is_alive() or len(cache) == 0
+
+        result_handler._state = TERMINATE
+        outqueue.put(None)                  # sentinel
+
+        # We must wait for the worker handler to exit before terminating
+        # workers because we don't want workers to be restarted behind our back.
+        debug('joining worker handler')
+        if threading.current_thread() is not worker_handler:
+            worker_handler.join(1e100)
+
+        # Terminate workers which haven't already finished.
+        if pool and hasattr(pool[0], 'terminate'):
+            debug('terminating workers')
+            for p in pool:
+                if p.exitcode is None:
+                    p.terminate()
+
+        debug('joining task handler')
+        if threading.current_thread() is not task_handler:
+            task_handler.join(1e100)
+
+        debug('joining result handler')
+        if threading.current_thread() is not result_handler:
+            result_handler.join(1e100)
+
+        if pool and hasattr(pool[0], 'terminate'):
+            debug('joining pool workers')
+            for p in pool:
+                if p.is_alive():
+                    # worker has not yet exited
+                    debug('cleaning up worker %d' % p.pid)
+                    p.join()
+
+class ApplyResult(object):
+
+    def __init__(self, cache, callback):
+        self._cond = threading.Condition(threading.Lock())
+        self._job = multiprocessing.pool.job_counter.next()
+        self._cache = cache
+        self._ready = False
+        self._callback = callback
+        cache[self._job] = self
+
+    def ready(self):
+        return self._ready
+
+    def successful(self):
+        assert self._ready
+        return self._success
+
+    def wait(self, timeout=None):
+        self._cond.acquire()
+        try:
+            if not self._ready:
+                self._cond.wait(timeout)
+        finally:
+            self._cond.release()
+
+    def get(self, timeout=None):
+        self.wait(timeout)
+        if not self._ready:
+            raise TimeoutError
+        if self._success:
+            return self._value
+        else:
+            raise self._value
+
+    def _set(self, i, obj):
+        self._success, self._value = obj
+        if self._callback and self._success:
+            self._callback(self._value)
+        self._cond.acquire()
+        try:
+            self._ready = True
+            self._cond.notify()
+        finally:
+            self._cond.release()
+        del self._cache[self._job]
+
+#
+# Class whose instances are returned by `Pool.map_async()`
+#
+
+class MapResult(ApplyResult):
+
+    def __init__(self, cache, chunksize, length, callback):
+        ApplyResult.__init__(self, cache, callback)
+        self._success = True
+        self._value = [None] * length
+        self._chunksize = chunksize
+        if chunksize <= 0:
+            self._number_left = 0
+            self._ready = True
+            del cache[self._job]
+        else:
+            self._number_left = length//chunksize + bool(length % chunksize)
+
+    def _set(self, i, success_result):
+        success, result = success_result
+        if success:
+            self._value[i*self._chunksize:(i+1)*self._chunksize] = result
+            self._number_left -= 1
+            if self._number_left == 0:
+                if self._callback:
+                    self._callback(self._value)
+                del self._cache[self._job]
+                self._cond.acquire()
+                try:
+                    self._ready = True
+                    self._cond.notify()
+                finally:
+                    self._cond.release()
+
+        else:
+            self._success = False
+            self._value = result
+            del self._cache[self._job]
+            self._cond.acquire()
+            try:
+                self._ready = True
+                self._cond.notify()
+            finally:
+                self._cond.release()
+
+#
+# Class whose instances are returned by `Pool.imap()`
+#
+
+class IMapIterator(object):
+
+    def __init__(self, cache):
+        self._cond = threading.Condition(threading.Lock())
+        self._job = multiprocessing.pool.job_counter.next()
+        self._cache = cache
+        self._items = collections.deque()
+        self._index = 0
+        self._length = None
+        self._unsorted = {}
+        cache[self._job] = self
+
+    def __iter__(self):
+        return self
+
+    def next(self, timeout=None):
+        self._cond.acquire()
+        try:
+            try:
+                item = self._items.popleft()
+            except IndexError:
+                if self._index == self._length:
+                    raise StopIteration
+                self._cond.wait(timeout)
+                try:
+                    item = self._items.popleft()
+                except IndexError:
+                    if self._index == self._length:
+                        raise StopIteration
+                    raise TimeoutError
+        finally:
+            self._cond.release()
+
+        success, value = item
+        if success:
+            return value
+        raise value
+
+    __next__ = next                    # XXX
+
+    def _set(self, i, obj):
+        self._cond.acquire()
+        try:
+            if self._index == i:
+                self._items.append(obj)
+                self._index += 1
+                while self._index in self._unsorted:
+                    obj = self._unsorted.pop(self._index)
+                    self._items.append(obj)
+                    self._index += 1
+                self._cond.notify()
+            else:
+                self._unsorted[i] = obj
+
+            if self._index == self._length:
+                del self._cache[self._job]
+        finally:
+            self._cond.release()
+
+    def _set_length(self, length):
+        self._cond.acquire()
+        try:
+            self._length = length
+            if self._index == self._length:
+                self._cond.notify()
+                del self._cache[self._job]
+        finally:
+            self._cond.release()
+
+#
+# Class whose instances are returned by `Pool.imap_unordered()`
+#
+
+class IMapUnorderedIterator(IMapIterator):
+
+    def _set(self, i, obj):
+        self._cond.acquire()
+        try:
+            self._items.append(obj)
+            self._index += 1
+            self._cond.notify()
+            if self._index == self._length:
+                del self._cache[self._job]
+        finally:
+            self._cond.release()
 
 

bitbake/lib/bb/cookerdata.py

@@ -1,304 +0,0 @@
-#!/usr/bin/env python
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# Copyright (C) 2003, 2004  Chris Larson
-# Copyright (C) 2003, 2004  Phil Blundell
-# Copyright (C) 2003 - 2005 Michael 'Mickey' Lauer
-# Copyright (C) 2005        Holger Hans Peter Freyther
-# Copyright (C) 2005        ROAD GmbH
-# Copyright (C) 2006        Richard Purdie
-#
-# 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 os, sys
-from functools import wraps
-import logging
-import bb
-from bb import data
-import bb.parse
-
-logger      = logging.getLogger("BitBake")
-parselog    = logging.getLogger("BitBake.Parsing")
-
-class ConfigParameters(object):
-    def __init__(self):
-        self.options, targets = self.parseCommandLine()
-        self.environment = self.parseEnvironment()
-
-        self.options.pkgs_to_build = targets or []
-
-        self.options.tracking = False
-        if hasattr(self.options, "show_environment") and self.options.show_environment:
-            self.options.tracking = True
-
-        for key, val in self.options.__dict__.items():
-            setattr(self, key, val)
-
-    def parseCommandLine(self):
-        raise Exception("Caller must implement commandline option parsing")
-
-    def parseEnvironment(self):
-        return os.environ.copy()
-
-    def updateFromServer(self, server):
-        if not self.options.cmd:
-            defaulttask, error = server.runCommand(["getVariable", "BB_DEFAULT_TASK"])
-            if error:
-                raise Exception("Unable to get the value of BB_DEFAULT_TASK from the server: %s" % error)
-            self.options.cmd = defaulttask or "build"
-        _, error = server.runCommand(["setConfig", "cmd", self.options.cmd])
-        if error:
-            raise Exception("Unable to set configuration option 'cmd' on the server: %s" % error)
-
-        if not self.options.pkgs_to_build:
-            bbpkgs, error = server.runCommand(["getVariable", "BBPKGS"])
-            if error:
-                raise Exception("Unable to get the value of BBPKGS from the server: %s" % error)
-            if bbpkgs:
-                self.options.pkgs_to_build.extend(bbpkgs.split())
-
-    def parseActions(self):
-        # Parse any commandline into actions
-        action = {'action':None, 'msg':None}
-        if self.options.show_environment:
-            if 'world' in self.options.pkgs_to_build:
-                action['msg'] = "'world' is not a valid target for --environment."
-            elif 'universe' in self.options.pkgs_to_build:
-                action['msg'] = "'universe' is not a valid target for --environment."
-            elif len(self.options.pkgs_to_build) > 1:
-                action['msg'] = "Only one target can be used with the --environment option."
-            elif self.options.buildfile and len(self.options.pkgs_to_build) > 0:
-                action['msg'] = "No target should be used with the --environment and --buildfile options."
-            elif len(self.options.pkgs_to_build) > 0:
-                action['action'] = ["showEnvironmentTarget", self.options.pkgs_to_build]
-            else:
-                action['action'] = ["showEnvironment", self.options.buildfile]
-        elif self.options.buildfile is not None:
-            action['action'] = ["buildFile", self.options.buildfile, self.options.cmd]
-        elif self.options.revisions_changed:
-            action['action'] = ["compareRevisions"]
-        elif self.options.show_versions:
-            action['action'] = ["showVersions"]
-        elif self.options.parse_only:
-            action['action'] = ["parseFiles"]
-        elif self.options.dot_graph:
-            if self.options.pkgs_to_build:
-                action['action'] = ["generateDotGraph", self.options.pkgs_to_build, self.options.cmd]
-            else:
-                action['msg'] = "Please specify a package name for dependency graph generation."
-        else:
-            if self.options.pkgs_to_build:
-                action['action'] = ["buildTargets", self.options.pkgs_to_build, self.options.cmd]
-            else:
-                #action['msg'] = "Nothing to do.  Use 'bitbake world' to build everything, or run 'bitbake --help' for usage information."
-                action = None
-        self.options.initialaction = action
-        return action
-
-class CookerConfiguration(object):
-    """
-    Manages build options and configurations for one run
-    """
-
-    def __init__(self):
-        self.debug_domains = []
-        self.extra_assume_provided = []
-        self.prefile = []
-        self.postfile = []
-        self.debug = 0
-        self.cmd = None
-        self.abort = True
-        self.force = False
-        self.profile = False
-        self.nosetscene = False
-        self.invalidate_stamp = False
-        self.dump_signatures = False
-        self.dry_run = False
-        self.tracking = False
-
-        self.env = {}
-
-    def setConfigParameters(self, parameters):
-        for key in self.__dict__.keys():
-            if key in parameters.options.__dict__:
-                setattr(self, key, parameters.options.__dict__[key])
-        self.env = parameters.environment.copy()
-        self.tracking = parameters.tracking
-
-    def setServerRegIdleCallback(self, srcb):
-        self.server_register_idlecallback = srcb
-
-    def __getstate__(self):
-        state = {}
-        for key in self.__dict__.keys():
-            if key == "server_register_idlecallback":
-                state[key] = None
-            else:
-                state[key] = getattr(self, key)
-        return state
-
-    def __setstate__(self,state):
-        for k in state:
-            setattr(self, k, state[k]) 
-
-
-def catch_parse_error(func):
-    """Exception handling bits for our parsing"""
-    @wraps(func)
-    def wrapped(fn, *args):
-        try:
-            return func(fn, *args)
-        except (IOError, bb.parse.ParseError, bb.data_smart.ExpansionError) as exc:
-            import traceback
-            parselog.critical( traceback.format_exc())
-            parselog.critical("Unable to parse %s: %s" % (fn, exc))
-            sys.exit(1)
-    return wrapped
-
-@catch_parse_error
-def parse_config_file(fn, data, include=True):
-    return bb.parse.handle(fn, data, include)
-
-@catch_parse_error
-def _inherit(bbclass, data):
-    bb.parse.BBHandler.inherit(bbclass, "configuration INHERITs", 0, data)
-    return data
-
-def findConfigFile(configfile, data):
-    search = []
-    bbpath = data.getVar("BBPATH", True)
-    if bbpath:
-        for i in bbpath.split(":"):
-            search.append(os.path.join(i, "conf", configfile))
-    path = os.getcwd()
-    while path != "/":
-        search.append(os.path.join(path, "conf", configfile))
-        path, _ = os.path.split(path)
-
-    for i in search:
-        if os.path.exists(i):
-            return i
-
-    return None
-
-class CookerDataBuilder(object):
-
-    def __init__(self, cookercfg, worker = False):
-
-        self.prefiles = cookercfg.prefile
-        self.postfiles = cookercfg.postfile
-        self.tracking = cookercfg.tracking
-
-        bb.utils.set_context(bb.utils.clean_context())
-        bb.event.set_class_handlers(bb.event.clean_class_handlers())
-        self.data = bb.data.init()
-        if self.tracking:
-            self.data.enableTracking()
-
-        # Keep a datastore of the initial environment variables and their
-        # values from when BitBake was launched to enable child processes
-        # to use environment variables which have been cleaned from the
-        # BitBake processes env
-        self.savedenv = bb.data.init()
-        for k in cookercfg.env:
-            self.savedenv.setVar(k, cookercfg.env[k])
-
-        filtered_keys = bb.utils.approved_variables()
-        bb.data.inheritFromOS(self.data, self.savedenv, filtered_keys)
-        self.data.setVar("BB_ORIGENV", self.savedenv)
-        
-        if worker:
-            self.data.setVar("BB_WORKERCONTEXT", "1")
-
-    def parseBaseConfiguration(self):
-        try:
-            self.parseConfigurationFiles(self.prefiles, self.postfiles)
-        except SyntaxError:
-            sys.exit(1)
-        except Exception:
-            logger.exception("Error parsing configuration files")
-            sys.exit(1)
-
-    def _findLayerConf(self, data):
-        return findConfigFile("bblayers.conf", data)
-
-    def parseConfigurationFiles(self, prefiles, postfiles):
-        data = self.data
-        bb.parse.init_parser(data)
-
-        # Parse files for loading *before* bitbake.conf and any includes
-        for f in prefiles:
-            data = parse_config_file(f, data)
-
-        layerconf = self._findLayerConf(data)
-        if layerconf:
-            parselog.debug(2, "Found bblayers.conf (%s)", layerconf)
-            # By definition bblayers.conf is in conf/ of TOPDIR.
-            # We may have been called with cwd somewhere else so reset TOPDIR
-            data.setVar("TOPDIR", os.path.dirname(os.path.dirname(layerconf)))
-            data = parse_config_file(layerconf, data)
-
-            layers = (data.getVar('BBLAYERS', True) or "").split()
-
-            data = bb.data.createCopy(data)
-            for layer in layers:
-                parselog.debug(2, "Adding layer %s", layer)
-                data.setVar('LAYERDIR', layer)
-                data = parse_config_file(os.path.join(layer, "conf", "layer.conf"), data)
-                data.expandVarref('LAYERDIR')
-
-            data.delVar('LAYERDIR')
-
-        if not data.getVar("BBPATH", True):
-            msg = "The BBPATH variable is not set"
-            if not layerconf:
-                msg += (" and bitbake did not find a conf/bblayers.conf file in"
-                        " the expected location.\nMaybe you accidentally"
-                        " invoked bitbake from the wrong directory?")
-            raise SystemExit(msg)
-
-        data = parse_config_file(os.path.join("conf", "bitbake.conf"), data)
-
-        # Parse files for loading *after* bitbake.conf and any includes
-        for p in postfiles:
-            data = parse_config_file(p, data)
-
-        # Handle any INHERITs and inherit the base class
-        bbclasses  = ["base"] + (data.getVar('INHERIT', True) or "").split()
-        for bbclass in bbclasses:
-            data = _inherit(bbclass, data)
-
-        # Nomally we only register event handlers at the end of parsing .bb files
-        # We register any handlers we've found so far here...
-        for var in data.getVar('__BBHANDLERS') or []:
-            bb.event.register(var, data.getVar(var),  (data.getVarFlag(var, "eventmask", True) or "").split())
-
-        if data.getVar("BB_WORKERCONTEXT", False) is None:
-            bb.fetch.fetcher_init(data)
-        bb.codeparser.parser_cache_init(data)
-        bb.event.fire(bb.event.ConfigParsed(), data)
-
-        if data.getVar("BB_INVALIDCONF") is True:
-            data.setVar("BB_INVALIDCONF", False)
-            self.parseConfigurationFiles(self.prefiles, self.postfiles)
-            return
-
-        bb.parse.init_parser(data)
-        data.setVar('BBINCLUDED',bb.parse.get_file_depends(data))
-        self.data = data
-        self.data_hash = data.get_hash()
-
-
-

bitbake/lib/bb/data.py

@@ -59,7 +59,7 @@ def init():
 def init_db(parent = None):
     """Return a new object representing the Bitbake data,
     optionally based on an existing object"""
-    if parent is not None:
+    if parent:
         return parent.createCopy()
     else:
         return _dict_type()
@@ -97,10 +97,6 @@ def delVar(var, d):
     """Removes a variable from the data set"""
     d.delVar(var)
 
-def appendVar(var, value, d):
-    """Append additional value to a variable"""
-    d.appendVar(var, value)
-
 def setVarFlag(var, flag, flagvalue, d):
     """Set a flag for a given variable to a given value"""
     d.setVarFlag(var, flag, flagvalue)
@@ -148,7 +144,7 @@ def expandKeys(alterdata, readdata = None):
         readdata = alterdata
 
     todolist = {}
-    for key in alterdata:
+    for key in keys(alterdata):
         if not '${' in key:
             continue
 
@@ -278,31 +274,26 @@ def emit_func(func, o=sys.__stdout__, d = init()):
             if d.getVarFlag(dep, "func"):
                emit_var(dep, o, d, False) and o.write('\n')
                newdeps |=  bb.codeparser.ShellParser(dep, logger).parse_shell(d.getVar(dep, True))
-               newdeps |= set((d.getVarFlag(dep, "vardeps", True) or "").split())
         newdeps -= seen
 
 def update_data(d):
     """Performs final steps upon the datastore, including application of overrides"""
     d.finalize(parent = True)
 
-def build_dependencies(key, keys, shelldeps, varflagsexcl, d):
+def build_dependencies(key, keys, shelldeps, vardepvals, d):
     deps = set()
+    vardeps = d.getVarFlag(key, "vardeps", True)
     try:
         if key[-1] == ']':
             vf = key[:-1].split('[')
             value = d.getVarFlag(vf[0], vf[1], False)
-            parser = d.expandWithRefs(value, key)
-            deps |= parser.references
-            deps = deps | (keys & parser.execs)
-            return deps, value
-        varflags = d.getVarFlags(key, ["vardeps", "vardepvalue", "vardepsexclude"]) or {}
-        vardeps = varflags.get("vardeps")
-        value = d.getVar(key, False)
+        else:
+            value = d.getVar(key, False)
 
-        if "vardepvalue" in varflags:
-           value = varflags.get("vardepvalue")
-        elif varflags.get("func"):
-            if varflags.get("python"):
+        if key in vardepvals:
+           value =  d.getVarFlag(key, "vardepvalue", True)
+        elif d.getVarFlag(key, "func"):
+            if d.getVarFlag(key, "python"):
                 parsedvar = d.expandWithRefs(value, key)
                 parser = bb.codeparser.PythonParser(key, logger)
                 if parsedvar.value and "\t" in parsedvar.value:
@@ -324,16 +315,19 @@ def build_dependencies(key, keys, shelldeps, varflagsexcl, d):
             deps = deps | (keys & parser.execs)
 
         # Add varflags, assuming an exclusion list is set
+        varflagsexcl = d.getVar('BB_SIGNATURE_EXCLUDE_FLAGS', True)
         if varflagsexcl:
             varfdeps = []
-            for f in varflags:
-                if f not in varflagsexcl:
-                    varfdeps.append('%s[%s]' % (key, f))
+            varflags = d.getVarFlags(key)
+            if varflags:
+                for f in varflags:
+                    if f not in varflagsexcl:
+                        varfdeps.append('%s[%s]' % (key, f))
             if varfdeps:
                 deps |= set(varfdeps)
 
         deps |= set((vardeps or "").split())
-        deps -= set(varflags.get("vardepsexclude", "").split())
+        deps -= set((d.getVarFlag(key, "vardepsexclude", True) or "").split())
     except Exception as e:
         raise bb.data_smart.ExpansionError(key, None, e)
     return deps, value
@@ -342,16 +336,16 @@ def build_dependencies(key, keys, shelldeps, varflagsexcl, d):
 
 def generate_dependencies(d):
 
-    keys = set(key for key in d if not key.startswith("__"))
-    shelldeps = set(key for key in d.getVar("__exportlist", False) if d.getVarFlag(key, "export") and not d.getVarFlag(key, "unexport"))
-    varflagsexcl = d.getVar('BB_SIGNATURE_EXCLUDE_FLAGS', True)
+    keys = set(key for key in d.keys() if not key.startswith("__"))
+    shelldeps = set(key for key in keys if d.getVarFlag(key, "export") and not d.getVarFlag(key, "unexport"))
+    vardepvals = set(key for key in keys if d.getVarFlag(key, "vardepvalue"))
 
     deps = {}
     values = {}
 
     tasklist = d.getVar('__BBTASKS') or []
     for task in tasklist:
-        deps[task], values[task] = build_dependencies(task, keys, shelldeps, varflagsexcl, d)
+        deps[task], values[task] = build_dependencies(task, keys, shelldeps, vardepvals, d)
         newdeps = deps[task]
         seen = set()
         while newdeps:
@@ -360,7 +354,7 @@ def generate_dependencies(d):
             newdeps = set()
             for dep in nextdeps:
                 if dep not in deps:
-                    deps[dep], values[dep] = build_dependencies(dep, keys, shelldeps, varflagsexcl, d)
+                    deps[dep], values[dep] = build_dependencies(dep, keys, shelldeps, vardepvals, d)
                 newdeps |=  deps[dep]
             newdeps -= seen
         #print "For %s: %s" % (task, str(deps[task]))

bitbake/lib/bb/data_smart.py

@@ -38,9 +38,9 @@ from bb.COW  import COWDictBase
 
 logger = logging.getLogger("BitBake.Data")
 
-__setvar_keyword__ = ["_append", "_prepend", "_remove"]
-__setvar_regexp__ = re.compile('(?P<base>.*?)(?P<keyword>_append|_prepend|_remove)(_(?P<add>.*))?$')
-__expand_var_regexp__ = re.compile(r"\${[^{}@\n\t ]+}")
+__setvar_keyword__ = ["_append", "_prepend"]
+__setvar_regexp__ = re.compile('(?P<base>.*?)(?P<keyword>_append|_prepend)(_(?P<add>.*))?$')
+__expand_var_regexp__ = re.compile(r"\${[^{}]+}")
 __expand_python_regexp__ = re.compile(r"\${@.+?}")
 
 def infer_caller_details(loginfo, parent = False, varval = True):
@@ -94,13 +94,9 @@ class VariableParse:
             if self.varname and key:
                 if self.varname == key:
                     raise Exception("variable %s references itself!" % self.varname)
-            if key in self.d.expand_cache:
-                varparse = self.d.expand_cache[key]
-                var = varparse.value
-            else:
-                var = self.d.getVar(key, True)
-            self.references.add(key)
+            var = self.d.getVar(key, True)
             if var is not None:
+                self.references.add(key)
                 return var
             else:
                 return match.group()
@@ -281,13 +277,9 @@ class VariableHistory(object):
                 lines.append(line)
         return lines
 
-    def del_var_history(self, var, f=None, line=None):
-        """If file f and line are not given, the entire history of var is deleted"""
+    def del_var_history(self, var):
         if var in self.variables:
-            if f and line:
-                self.variables[var] = [ x for x in self.variables[var] if x['file']!=f and x['line']!=line]
-            else:
-                self.variables[var] = []
+            self.variables[var] = []
 
 class DataSmart(MutableMapping):
     def __init__(self, special = COWDictBase.copy(), seen = COWDictBase.copy() ):
@@ -365,8 +357,7 @@ class DataSmart(MutableMapping):
 
         #
         # First we apply all overrides
-        # Then we will handle _append and _prepend and store the _remove
-        # information for later.
+        # Then  we will handle _append and _prepend
         #
 
         # We only want to report finalization once per variable overridden.
@@ -401,7 +392,7 @@ class DataSmart(MutableMapping):
                 except Exception:
                     logger.info("Untracked delVar")
 
-        # now on to the appends and prepends, and stashing the removes
+        # now on to the appends and prepends
         for op in __setvar_keyword__:
             if op in self._special_values:
                 appends = self._special_values[op] or []
@@ -424,10 +415,6 @@ class DataSmart(MutableMapping):
                         elif op == "_prepend":
                             sval = a + (self.getVar(append, False) or "")
                             self.setVar(append, sval)
-                        elif op == "_remove":
-                            removes = self.getVarFlag(append, "_removeactive", False) or []
-                            removes.extend(a.split())
-                            self.setVarFlag(append, "_removeactive", removes, ignore=True)
 
                     # We save overrides that may be applied at some later stage
                     if keep:
@@ -498,22 +485,23 @@ class DataSmart(MutableMapping):
 
         # more cookies for the cookie monster
         if '_' in var:
-            self._setvar_update_overrides(var)
+            override = var[var.rfind('_')+1:]
+            if len(override) > 0:
+                if override not in self._seen_overrides:
+                    self._seen_overrides[override] = set()
+                self._seen_overrides[override].add( var )
 
         # setting var
         self.dict[var]["_content"] = value
         self.varhistory.record(**loginfo)
 
-    def _setvar_update_overrides(self, var):
-        # aka pay the cookie monster
-        override = var[var.rfind('_')+1:]
-        if len(override) > 0:
-            if override not in self._seen_overrides:
-                self._seen_overrides[override] = set()
-            self._seen_overrides[override].add( var )
-
     def getVar(self, var, expand=False, noweakdefault=False):
-        return self.getVarFlag(var, "_content", expand, noweakdefault)
+        value = self.getVarFlag(var, "_content", False, noweakdefault)
+
+        # Call expand() separately to make use of the expand cache
+        if expand and value:
+            return self.expand(value, var)
+        return value
 
     def renameVar(self, key, newkey, **loginfo):
         """
@@ -527,7 +515,7 @@ class DataSmart(MutableMapping):
             self.varhistory.record(**loginfo)
             self.setVar(newkey, val, ignore=True)
 
-        for i in (__setvar_keyword__):
+        for i in ('_append', '_prepend'):
             src = self.getVarFlag(key, i)
             if src is None:
                 continue
@@ -578,36 +566,16 @@ class DataSmart(MutableMapping):
             self._makeShadowCopy(var)
         self.dict[var][flag] = value
 
-        if flag == "defaultval" and '_' in var:
-            self._setvar_update_overrides(var)
-
-        if flag == "unexport" or flag == "export":
-            if not "__exportlist" in self.dict:
-                self._makeShadowCopy("__exportlist")
-            if not "_content" in self.dict["__exportlist"]:
-                self.dict["__exportlist"]["_content"] = set()
-            self.dict["__exportlist"]["_content"].add(var)
-
     def getVarFlag(self, var, flag, expand=False, noweakdefault=False):
         local_var = self._findVar(var)
         value = None
-        if local_var is not None:
+        if local_var:
             if flag in local_var:
                 value = copy.copy(local_var[flag])
             elif flag == "_content" and "defaultval" in local_var and not noweakdefault:
                 value = copy.copy(local_var["defaultval"])
         if expand and value:
-            # Only getvar (flag == _content) hits the expand cache
-            cachename = None
-            if flag == "_content":
-                cachename = var
-            else:
-                cachename = var + "[" + flag + "]"
-            value = self.expand(value, cachename)
-        if value is not None and flag == "_content" and local_var is not None and "_removeactive" in local_var:
-            filtered = filter(lambda v: v not in local_var["_removeactive"],
-                              value.split(" "))
-            value = " ".join(filtered)
+            value = self.expand(value, None)
         return value
 
     def delVarFlag(self, var, flag, **loginfo):
@@ -652,17 +620,16 @@ class DataSmart(MutableMapping):
             self.varhistory.record(**loginfo)
             self.dict[var][i] = flags[i]
 
-    def getVarFlags(self, var, expand = False, internalflags=False):
+    def getVarFlags(self, var):
         local_var = self._findVar(var)
         flags = {}
 
         if local_var:
             for i in local_var:
-                if i.startswith("_") and not internalflags:
+                if i.startswith("_"):
                     continue
                 flags[i] = local_var[i]
-                if expand and i in expand:
-                    flags[i] = self.expand(flags[i], var + "[" + i + "]")
+
         if len(flags) == 0:
             return None
         return flags
@@ -768,18 +735,9 @@ class DataSmart(MutableMapping):
         for key in keys:
             if key in config_whitelist:
                 continue
-
             value = d.getVar(key, False) or ""
             data.update({key:value})
 
-            varflags = d.getVarFlags(key, internalflags = True)
-            if not varflags:
-                continue
-            for f in varflags:
-                if f == "_content":
-                    continue
-                data.update({'%s[%s]' % (key, f):varflags[f]})
-
         for key in ["__BBTASKS", "__BBANONFUNCS", "__BBHANDLERS"]:
             bb_list = d.getVar(key, False) or []
             bb_list.sort()

bitbake/lib/bb/event.py

@@ -33,12 +33,11 @@ import atexit
 import traceback
 import bb.utils
 import bb.compat
-import bb.exceptions
 
 # This is the pid for which we should generate the event. This is set when
 # the runqueue forks off.
 worker_pid = 0
-worker_fire = None
+worker_pipe = None
 
 logger = logging.getLogger('BitBake.Event')
 
@@ -48,25 +47,20 @@ class Event(object):
     def __init__(self):
         self.pid = worker_pid
 
+NotHandled = 0
+Handled    = 1
+
 Registered        = 10
 AlreadyRegistered = 14
 
-def get_class_handlers():
-    return _handlers
-
-def set_class_handlers(h):
-    _handlers = h
-
-def clean_class_handlers():
-    return bb.compat.OrderedDict()
-
 # Internal
-_handlers = clean_class_handlers()
+_handlers = bb.compat.OrderedDict()
 _ui_handlers = {}
-_ui_logfilters = {}
 _ui_handler_seq = 0
-_event_handler_map = {}
-_catchall_handlers = {}
+
+# For compatibility
+bb.utils._context["NotHandled"] = NotHandled
+bb.utils._context["Handled"] = Handled
 
 def execute_handler(name, handler, event, d):
     event.data = d
@@ -86,18 +80,19 @@ def execute_handler(name, handler, event, d):
     finally:
         del event.data
 
+    if ret is not None:
+        warnings.warn("Using Handled/NotHandled in event handlers is deprecated",
+                        DeprecationWarning, stacklevel = 2)
+
 def fire_class_handlers(event, d):
     if isinstance(event, logging.LogRecord):
         return
 
-    eid = str(event.__class__)[8:-2]
-    evt_hmap = _event_handler_map.get(eid, {})
     for name, handler in _handlers.iteritems():
-        if name in _catchall_handlers or name in evt_hmap:
-            try:
-                execute_handler(name, handler, event, d)
-            except Exception:
-                continue
+        try:
+            execute_handler(name, handler, event, d)
+        except Exception:
+            continue
 
 ui_queue = []
 @atexit.register
@@ -136,8 +131,6 @@ def fire_ui_handlers(event, d):
     for h in _ui_handlers:
         #print "Sending event %s" % event
         try:
-             if not _ui_logfilters[h].filter(event):
-                 continue
              # We use pickle here since it better handles object instances
              # which xmlrpc's marshaller does not. Events *must* be serializable
              # by pickle.
@@ -159,16 +152,24 @@ def fire(event, d):
     # don't have a datastore so the datastore context isn't a problem.
 
     fire_class_handlers(event, d)
-    if worker_fire:
+    if worker_pid != 0:
         worker_fire(event, d)
     else:
         fire_ui_handlers(event, d)
 
+def worker_fire(event, d):
+    data = "<event>" + pickle.dumps(event) + "</event>"
+    worker_pipe.write(data)
+
 def fire_from_worker(event, d):
+    if not event.startswith("<event>") or not event.endswith("</event>"):
+        print("Error, not an event %s" % event)
+        return
+    event = pickle.loads(event[7:-8])
     fire_ui_handlers(event, d)
 
 noop = lambda _: None
-def register(name, handler, mask=[]):
+def register(name, handler):
     """Register an Event handler"""
 
     # already registered
@@ -193,14 +194,6 @@ def register(name, handler, mask=[]):
         else:
             _handlers[name] = handler
 
-        if not mask or '*' in mask:
-            _catchall_handlers[name] = True
-        else:
-            for m in mask:
-                if _event_handler_map.get(m, None) is None:
-                    _event_handler_map[m] = {}
-                _event_handler_map[m][name] = True
-
         return Registered
 
 def remove(name, handler):
@@ -210,8 +203,6 @@ def remove(name, handler):
 def register_UIHhandler(handler):
     bb.event._ui_handler_seq = bb.event._ui_handler_seq + 1
     _ui_handlers[_ui_handler_seq] = handler
-    level, debug_domains = bb.msg.constructLogOptions()
-    _ui_logfilters[_ui_handler_seq] = UIEventFilter(level, debug_domains)
     return _ui_handler_seq
 
 def unregister_UIHhandler(handlerNum):
@@ -219,37 +210,6 @@ def unregister_UIHhandler(handlerNum):
         del _ui_handlers[handlerNum]
     return
 
-# Class to allow filtering of events and specific filtering of LogRecords *before* we put them over the IPC
-class UIEventFilter(object):
-    def __init__(self, level, debug_domains):
-        self.update(None, level, debug_domains)
-
-    def update(self, eventmask, level, debug_domains):
-        self.eventmask = eventmask
-        self.stdlevel = level
-        self.debug_domains = debug_domains
-
-    def filter(self, event):
-        if isinstance(event, logging.LogRecord):
-            if event.levelno >= self.stdlevel:
-                return True
-            if event.name in self.debug_domains and event.levelno >= self.debug_domains[event.name]:
-                return True
-            return False
-        eid = str(event.__class__)[8:-2]
-        if self.eventmask and eid not in self.eventmask:
-            return False
-        return True
-
-def set_UIHmask(handlerNum, level, debug_domains, mask):
-    if not handlerNum in _ui_handlers:
-        return False
-    if '*' in mask:
-        _ui_logfilters[handlerNum].update(None, level, debug_domains)
-    else:
-        _ui_logfilters[handlerNum].update(mask, level, debug_domains)
-    return True
-
 def getName(e):
     """Returns the name of a class or class instance"""
     if getattr(e, "__name__", None) == None:
@@ -377,13 +337,12 @@ class DiskFull(Event):
 class NoProvider(Event):
     """No Provider for an Event"""
 
-    def __init__(self, item, runtime=False, dependees=None, reasons=[], close_matches=[]):
+    def __init__(self, item, runtime=False, dependees=None, reasons=[]):
         Event.__init__(self)
         self._item = item
         self._runtime = runtime
         self._dependees = dependees
         self._reasons = reasons
-        self._close_matches = close_matches
 
     def getItem(self):
         return self._item
@@ -589,16 +548,6 @@ class PackageInfo(Event):
         Event.__init__(self)
         self._pkginfolist = pkginfolist
 
-class MetadataEvent(Event):
-    """
-    Generic event that target for OE-Core classes
-    to report information during asynchrous execution
-    """
-    def __init__(self, eventtype, eventdata):
-        Event.__init__(self)
-        self.type = eventtype
-        self.data = eventdata
-
 class SanityCheck(Event):
     """
     Event to issue sanity check

bitbake/lib/bb/fetch2/__init__.py

@@ -28,8 +28,6 @@ BitBake build tools.
 from __future__ import absolute_import
 from __future__ import print_function
 import os, re
-import signal
-import glob
 import logging
 import urllib
 import urlparse
@@ -40,8 +38,6 @@ import operator
 import bb.persist_data, bb.utils
 import bb.checksum
 from bb import data
-import bb.process
-import subprocess
 
 __version__ = "2"
 _checksum_cache = bb.checksum.FileChecksumCache()
@@ -121,7 +117,7 @@ class ParameterError(BBFetchException):
 class NetworkAccess(BBFetchException):
     """Exception raised when network access is disabled but it is required."""
     def __init__(self, url, cmd):
-         msg = "Network access disabled through BB_NO_NETWORK (or set indirectly due to use of BB_FETCH_PREMIRRORONLY) but access requested with command %s (for url %s)" % (cmd, url)
+         msg = "Network access disabled through BB_NO_NETWORK but access requested with command %s (for url %s)" % (cmd, url)
          self.url = url
          self.cmd = cmd
          BBFetchException.__init__(self, msg)
@@ -588,6 +584,7 @@ def update_stamp(u, ud, d):
         open(ud.donestamp, 'w').close()
 
 def subprocess_setup():
+    import signal
     # Python installs a SIGPIPE handler by default. This is usually not what
     # non-Python subprocesses expect.
     # SIGPIPE errors are known issues with gzip/bash
@@ -619,12 +616,7 @@ def get_srcrev(d):
         raise FetchError("SRCREV was used yet no valid SCM was found in SRC_URI")
 
     if len(scms) == 1 and len(urldata[scms[0]].names) == 1:
-        autoinc, rev = urldata[scms[0]].method.sortable_revision(scms[0], urldata[scms[0]], d, urldata[scms[0]].names[0])
-        if len(rev) > 10:
-            rev = rev[:10]
-        if autoinc:
-            return "AUTOINC+" + rev
-        return rev
+        return urldata[scms[0]].method.sortable_revision(scms[0], urldata[scms[0]], d, urldata[scms[0]].names[0])
 
     #
     # Mutiple SCMs are in SRC_URI so we resort to SRCREV_FORMAT
@@ -633,17 +625,19 @@ def get_srcrev(d):
     if not format:
         raise FetchError("The SRCREV_FORMAT variable must be set when multiple SCMs are used.")
 
-    seenautoinc = False
+    autoinc = False
+    autoinc_templ = 'AUTOINC+'
     for scm in scms:
         ud = urldata[scm]
         for name in ud.names:
-            autoinc, rev = ud.method.sortable_revision(scm, ud, d, name)
-            seenautoinc = seenautoinc or autoinc
-            if len(rev) > 10:
-                rev = rev[:10]
+            rev = ud.method.sortable_revision(scm, ud, d, name)
+            if rev.startswith(autoinc_templ):
+                if not autoinc:
+                    autoinc = True
+                    format = "%s%s" % (autoinc_templ, format)
+                rev = rev[len(autoinc_templ):]
+
             format = format.replace(name, rev)
-    if seenautoinc:
-       format = "AUTOINC+" + format
 
     return format
 
@@ -659,6 +653,9 @@ def runfetchcmd(cmd, d, quiet = False, cleanup = []):
     Optionally remove the files/directories listed in cleanup upon failure
     """
 
+    import bb.process
+    import subprocess
+
     # Need to export PATH as binary could be in metadata paths
     # rather than host provided
     # Also include some other variables.
@@ -929,6 +926,7 @@ def get_file_checksums(filelist, pn):
         try:
             checksum = _checksum_cache.get_checksum(f)
         except OSError as e:
+            import traceback
             bb.warn("Unable to get checksum for %s SRC_URI entry %s: %s" % (pn, os.path.basename(f), e))
             return None
         return checksum
@@ -938,6 +936,7 @@ def get_file_checksums(filelist, pn):
         checksum = None
         if '*' in pth:
             # Handle globs
+            import glob
             for f in glob.glob(pth):
                 checksum = checksum_file(f)
                 if checksum:
@@ -990,13 +989,13 @@ class FetchData(object):
             self.sha256_name = "sha256sum"
         if self.md5_name in self.parm:
             self.md5_expected = self.parm[self.md5_name]
-        elif self.type not in ["http", "https", "ftp", "ftps", "sftp"]:
+        elif self.type not in ["http", "https", "ftp", "ftps"]:
             self.md5_expected = None
         else:
             self.md5_expected = d.getVarFlag("SRC_URI", self.md5_name)
         if self.sha256_name in self.parm:
             self.sha256_expected = self.parm[self.sha256_name]
-        elif self.type not in ["http", "https", "ftp", "ftps", "sftp"]:
+        elif self.type not in ["http", "https", "ftp", "ftps"]:
             self.sha256_expected = None
         else:
             self.sha256_expected = d.getVarFlag("SRC_URI", self.sha256_name)
@@ -1105,7 +1104,7 @@ class FetchMethod(object):
     def recommends_checksum(self, urldata):
         """
         Is the backend on where checksumming is recommended (should warnings 
-        be displayed if there is no checksum)?
+        by displayed if there is no checksum)?
         """
         return False
 
@@ -1147,6 +1146,7 @@ class FetchMethod(object):
         raise NoMethodError(url)
 
     def unpack(self, urldata, rootdir, data):
+        import subprocess
         iterate = False
         file = urldata.localpath
 
@@ -1157,7 +1157,7 @@ class FetchMethod(object):
                      (file, urldata.parm.get('unpack')))
 
         dots = file.split(".")
-        if dots[-1] in ['gz', 'bz2', 'Z', 'xz']:
+        if dots[-1] in ['gz', 'bz2', 'Z']:
             efile = os.path.join(rootdir, os.path.basename('.'.join(dots[0:-1])))
         else:
             efile = file
@@ -1293,8 +1293,14 @@ class FetchMethod(object):
             return rev
 
     def sortable_revision(self, url, ud, d, name):
+        """
+
+        """
+        if hasattr(self, "_sortable_revision"):
+            return self._sortable_revision(url, ud, d)
+
         latest_rev = self._build_revision(url, ud, d, name)
-        return True, str(latest_rev)
+        return 'AUTOINC+%s' % str(latest_rev)
 
     def generate_revision_key(self, url, ud, d, name):
         key = self._revision_key(url, ud, d, name)

bitbake/lib/bb/fetch2/bzr.py

@@ -132,12 +132,12 @@ class Bzr(FetchMethod):
 
         return output.strip()
 
-    def sortable_revision(self, url, ud, d, name):
+    def _sortable_revision(self, url, ud, d):
         """
         Return a sortable revision number which in our case is the revision number
         """
 
-        return False, self._build_revision(url, ud, d)
+        return self._build_revision(url, ud, d)
 
     def _build_revision(self, url, ud, d):
         return ud.revision

bitbake/lib/bb/fetch2/svn.py

@@ -81,8 +81,6 @@ class Svn(FetchMethod):
 
         options = []
 
-        options.append("--no-auth-cache")
-
         if ud.user:
             options.append("--username %s" % ud.user)
 
@@ -178,12 +176,12 @@ class Svn(FetchMethod):
 
         return revision
 
-    def sortable_revision(self, url, ud, d, name):
+    def _sortable_revision(self, url, ud, d):
         """
         Return a sortable revision number which in our case is the revision number
         """
 
-        return False, self._build_revision(url, ud, d)
+        return self._build_revision(url, ud, d)
 
     def _build_revision(self, url, ud, d):
         return ud.revision

bitbake/lib/bb/methodpool.py

@@ -17,7 +17,24 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
+
+"""
+    What is a method pool?
+
+    BitBake has a global method scope where .bb, .inc and .bbclass
+    files can install methods. These methods are parsed from strings.
+    To avoid recompiling and executing these string we introduce
+    a method pool to do this task.
+
+    This pool will be used to compile and execute the functions. It
+    will be smart enough to
+"""
+
 from bb.utils import better_compile, better_exec
+from bb       import error
+
+# A dict of function names we have seen
+_parsed_fns     = { }
 
 def insert_method(modulename, code, fn):
     """
@@ -27,3 +44,28 @@ def insert_method(modulename, code, fn):
     comp = better_compile(code, modulename, fn )
     better_exec(comp, None, code, fn)
 
+    # now some instrumentation
+    code = comp.co_names
+    for name in code:
+        if name in ['None', 'False']:
+            continue
+        elif name in _parsed_fns and not _parsed_fns[name] == modulename:
+            error("The function %s defined in %s was already declared in %s. BitBake has a global python function namespace so shared functions should be declared in a common include file rather than being duplicated, or if the functions are different, please use different function names." % (name, modulename, _parsed_fns[name]))
+        else:
+            _parsed_fns[name] = modulename
+
+# A dict of modules the parser has finished with
+_parsed_methods = {}
+
+def parsed_module(modulename):
+    """
+    Has module been parsed?
+    """
+    return modulename in _parsed_methods
+
+def set_parsed_module(modulename):
+    """
+    Set module as parsed
+    """
+    _parsed_methods[modulename] = True
+

bitbake/lib/bb/monitordisk.py

@@ -225,7 +225,7 @@ class diskMonitor:
                         self.preFreeS[k] = freeSpace
 
                     if action == "STOPTASKS" and not self.checked[k]:
-                        logger.error("No new tasks can be executed since the disk space monitor action is \"STOPTASKS\"!")
+                        logger.error("No new tasks can be excuted since the disk space monitor action is \"STOPTASKS\"!")
                         self.checked[k] = True
                         rq.finish_runqueue(False)
                         bb.event.fire(bb.event.DiskFull(dev, 'disk', freeSpace, path), self.configuration)
@@ -253,7 +253,7 @@ class diskMonitor:
                         self.preFreeI[k] = freeInode
 
                     if action  == "STOPTASKS" and not self.checked[k]:
-                        logger.error("No new tasks can be executed since the disk space monitor action is \"STOPTASKS\"!")
+                        logger.error("No new tasks can be excuted since the disk space monitor action is \"STOPTASKS\"!")
                         self.checked[k] = True
                         rq.finish_runqueue(False)
                         bb.event.fire(bb.event.DiskFull(dev, 'inode', freeInode, path), self.configuration)

bitbake/lib/bb/msg.py

@@ -146,7 +146,8 @@ def init_msgconfig(verbose, debug, debug_domains = []):
         bb.msg.loggerVerboseLogs = True
     bb.msg.loggerDefaultDomains = debug_domains
 
-def constructLogOptions():
+def addDefaultlogFilter(handler):
+
     debug = loggerDefaultDebugLevel
     verbose = loggerDefaultVerbose
     domains = loggerDefaultDomains
@@ -162,10 +163,6 @@ def constructLogOptions():
     for (domainarg, iterator) in groupby(domains):
         dlevel = len(tuple(iterator))
         debug_domains["BitBake.%s" % domainarg] = logging.DEBUG - dlevel + 1
-    return level, debug_domains
-
-def addDefaultlogFilter(handler):
-    level, debug_domains = constructLogOptions()
 
     BBLogFilter(handler, level, debug_domains)
 

bitbake/lib/bb/parse/__init__.py

@@ -107,9 +107,6 @@ def resolve_file(fn, d):
             raise IOError("file %s not found in %s" % (fn, bbpath))
         fn = newfn
 
-    if not os.path.isfile(fn):
-        raise IOError("file %s not found" % fn)
-
     logger.debug(2, "LOAD %s", fn)
     return fn
 

bitbake/lib/bb/parse/ast.py

@@ -147,9 +147,10 @@ class MethodNode(AstNode):
     def eval(self, data):
         text = '\n'.join(self.body)
         if self.func_name == "__anonymous":
-            funcname = ("__anon_%s_%s" % (self.lineno, self.filename.translate(string.maketrans('/.+-@', '_____'))))
-            text = "def %s(d):\n" % (funcname) + text
-            bb.methodpool.insert_method(funcname, text, self.filename)
+            funcname = ("__anon_%s_%s" % (self.lineno, self.filename.translate(string.maketrans('/.+-', '____'))))
+            if not funcname in bb.methodpool._parsed_fns:
+                text = "def %s(d):\n" % (funcname) + text
+                bb.methodpool.insert_method(funcname, text, self.filename)
             anonfuncs = data.getVar('__BBANONFUNCS') or []
             anonfuncs.append(funcname)
             data.setVar('__BBANONFUNCS', anonfuncs)
@@ -170,7 +171,8 @@ class PythonMethodNode(AstNode):
         # 'this' file. This means we will not parse methods from
         # bb classes twice
         text = '\n'.join(self.body)
-        bb.methodpool.insert_method(self.modulename, text, self.filename)
+        if not bb.methodpool.parsed_module(self.modulename):
+            bb.methodpool.insert_method(self.modulename, text, self.filename)
         data.setVarFlag(self.function, "func", 1)
         data.setVarFlag(self.function, "python", 1)
         data.setVar(self.function, text)
@@ -320,7 +322,8 @@ def finalize(fn, d, variant = None):
     all_handlers = {}
     for var in d.getVar('__BBHANDLERS') or []:
         # try to add the handler
-        bb.event.register(var, d.getVar(var), (d.getVarFlag(var, "eventmask", True) or "").split())
+        handler = d.getVar(var)
+        bb.event.register(var, handler)
 
     bb.event.fire(bb.event.RecipePreFinalise(fn), d)
 

bitbake/lib/bb/parse/parse_py/BBHandler.py

@@ -104,7 +104,6 @@ def get_statements(filename, absolute_filename, base_name):
             if not s: break
             s = s.rstrip()
             feeder(lineno, s, filename, base_name, statements)
-        file.close()
         if __inpython__:
             # add a blank line to close out any python definition
             feeder(IN_PYTHON_EOF, "", filename, base_name, statements)
@@ -167,6 +166,10 @@ def handle(fn, d, include):
     if oldfile:
         d.setVar("FILE", oldfile)
 
+    # we have parsed the bb class now
+    if ext == ".bbclass" or ext == ".inc":
+        bb.methodpool.set_parsed_module(base_name)
+
     return d
 
 def feeder(lineno, s, fn, root, statements):

bitbake/lib/bb/parse/parse_py/ConfHandler.py

@@ -89,7 +89,7 @@ def include(oldfn, fn, lineno, data, error_out):
     from bb.parse import handle
     try:
         ret = handle(fn, data, True)
-    except (IOError, OSError):
+    except IOError:
         if error_out:
             raise ParseError("Could not %(error_out)s file %(fn)s" % vars(), oldfn, lineno)
         logger.debug(2, "CONF file '%s' not found", fn)
@@ -145,8 +145,6 @@ def handle(fn, data, include):
     if oldfile:
         data.setVar('FILE', oldfile)
 
-    f.close()
-
     for f in confFilters:
         f(fn, data)
 

bitbake/lib/bb/process.py

@@ -85,7 +85,7 @@ def _logged_communicate(pipe, log, input):
             rlist = rin
             try:
                 r,w,e = select.select (rlist, [], [])
-            except OSError as e:
+            except OSError, e:
                 if e.errno != errno.EINTR:
                     raise
 
@@ -102,10 +102,6 @@ def _logged_communicate(pipe, log, input):
                     log.write(data)
     finally:    
         log.flush()
-    if pipe.stdout is not None:
-        pipe.stdout.close()
-    if pipe.stderr is not None:
-        pipe.stderr.close()
     return ''.join(outdata), ''.join(errdata)
 
 def run(cmd, input=None, log=None, **options):

bitbake/lib/bb/providers.py

@@ -92,9 +92,9 @@ def sortPriorities(pn, dataCache, pkg_pn = None):
             priorities[priority][preference] = []
         priorities[priority][preference].append(f)
     tmp_pn = []
-    for pri in sorted(priorities):
+    for pri in sorted(priorities, lambda a, b: a - b):
         tmp_pref = []
-        for pref in sorted(priorities[pri]):
+        for pref in sorted(priorities[pri], lambda a, b: b - a):
             tmp_pref.extend(priorities[pri][pref])
         tmp_pn = [tmp_pref] + tmp_pn
 
@@ -341,7 +341,7 @@ def filterProvidersRunTime(providers, item, cfgData, dataCache):
     if numberPreferred > 1:
         logger.error("Trying to resolve runtime dependency %s resulted in conflicting PREFERRED_PROVIDER entries being found.\nThe providers found were: %s\nThe PREFERRED_PROVIDER entries resulting in this conflict were: %s", item, preferred, preferred_vars)
 
-    logger.debug(1, "sorted runtime providers for %s are: %s", item, eligible)
+    logger.debug(1, "sorted providers for %s are: %s", item, eligible)
 
     return eligible, numberPreferred
 
@@ -376,6 +376,5 @@ def getRuntimeProviders(dataCache, rdepend):
             regexp_cache[pattern] = regexp
         if regexp.match(rdepend):
             rproviders += dataCache.packages_dynamic[pattern]
-            logger.debug(1, "Assuming %s is a dynamic package, but it may not exist" % rdepend)
 
     return rproviders

bitbake/lib/bb/pysh/pyshlex.py

@@ -292,7 +292,7 @@ class WordLexer:
         elif sep=='${':
             parsefunc = self._parse_parameter
         else:
-            raise NotImplementedError(sep)
+            raise NotImplementedError()
             
         pos, closed = parsefunc(buf, result, eof)
         return pos, closed

bitbake/lib/bb/runqueue.py

@@ -28,17 +28,10 @@ import sys
 import signal
 import stat
 import fcntl
-import errno
 import logging
 import bb
 from bb import msg, data, event
 from bb import monitordisk
-import subprocess
-
-try:
-    import cPickle as pickle
-except ImportError:
-    import pickle
 
 bblogger = logging.getLogger("BitBake")
 logger = logging.getLogger("BitBake.RunQueue")
@@ -84,6 +77,7 @@ runQueueRunning = 6
 runQueueFailed = 7
 runQueueCleanUp = 8
 runQueueComplete = 9
+runQueueChildProcess = 10
 
 class RunQueueScheduler(object):
     """
@@ -217,15 +211,6 @@ class RunQueueData:
             ret.extend([nam])
         return ret
 
-    def get_task_name(self, task):
-        return self.runq_task[task]
-
-    def get_task_file(self, task):
-        return self.taskData.fn_index[self.runq_fnid[task]]
-
-    def get_task_hash(self, task):
-        return self.runq_hash[task]
-
     def get_user_idstring(self, task, task_name_suffix = ""):
         fn = self.taskData.fn_index[self.runq_fnid[task]]
         taskname = self.runq_task[task] + task_name_suffix
@@ -391,7 +376,6 @@ class RunQueueData:
 
         runq_build = []
         recursivetasks = {}
-        recursiveitasks = {}
         recursivetasksselfref = set()
 
         taskData = self.taskData
@@ -514,12 +498,6 @@ class RunQueueData:
                     if taskData.tasks_name[task] in tasknames:
                         recursivetasksselfref.add(task)
 
-                    if 'recideptask' in task_deps and taskData.tasks_name[task] in task_deps['recideptask']:
-                        recursiveitasks[task] = []
-                        for t in task_deps['recideptask'][taskData.tasks_name[task]].split():
-                            newdep = taskData.gettask_id_fromfnid(fnid, t)
-                            recursiveitasks[task].append(newdep)
-
             self.runq_fnid.append(taskData.tasks_fnid[task])
             self.runq_task.append(taskData.tasks_name[task])
             self.runq_depends.append(depends)
@@ -552,10 +530,6 @@ class RunQueueData:
                             generate_recdeps(n)
             generate_recdeps(task)
 
-            if task in recursiveitasks:
-                for dep in recursiveitasks[task]:
-                    generate_recdeps(dep)
-
         # Remove circular references so that do_a[recrdeptask] = "do_a do_b" can work
         for task in recursivetasks:
             extradeps[task].difference_update(recursivetasksselfref)
@@ -610,13 +584,7 @@ class RunQueueData:
                 continue
 
             if target[1] not in taskData.tasks_lookup[fnid]:
-                import difflib
-                close_matches = difflib.get_close_matches(target[1], taskData.tasks_lookup[fnid], cutoff=0.7)
-                if close_matches:
-                    extra = ". Close matches:\n  %s" % "\n  ".join(close_matches)
-                else:
-                    extra = ""
-                bb.msg.fatal("RunQueue", "Task %s does not exist for target %s%s" % (target[1], target[0], extra))
+                bb.msg.fatal("RunQueue", "Task %s does not exist for target %s" % (target[1], target[0]))
 
             listid = taskData.tasks_lookup[fnid][target[1]]
 
@@ -705,14 +673,6 @@ class RunQueueData:
                     prov_list[prov].append(fn)
         for prov in prov_list:
             if len(prov_list[prov]) > 1 and prov not in self.multi_provider_whitelist:
-                seen_pn = []
-                # If two versions of the same PN are being built its fatal, we don't support it.
-                for fn in prov_list[prov]:
-                    pn = self.dataCache.pkg_fn[fn]
-                    if pn not in seen_pn:
-                        seen_pn.append(pn)
-                    else:
-                        bb.fatal("Multiple versions of %s are due to be built (%s). Only one version of a given PN should be built in any given build. You likely need to set PREFERRED_VERSION_%s to select the correct version or don't depend on multiple versions." % (pn, " ".join(prov_list[prov]), pn))
                 msg = "Multiple .bb files are due to be built which each provide %s (%s)." % (prov, " ".join(prov_list[prov]))
                 if self.warn_multi_bb:
                     logger.warn(msg)
@@ -720,6 +680,7 @@ class RunQueueData:
                     msg += "\n This usually means one provides something the other doesn't and should."
                     logger.error(msg)
 
+
         # Create a whitelist usable by the stamp checks
         stampfnwhitelist = []
         for entry in self.stampwhitelist.split():
@@ -742,9 +703,6 @@ class RunQueueData:
 
         def invalidate_task(fn, taskname, error_nostamp):
             taskdep = self.dataCache.task_deps[fn]
-            fnid = self.taskData.getfn_id(fn)
-            if taskname not in taskData.tasks_lookup[fnid]:
-                logger.warn("Task %s does not exist, invalidating this task will have no effect" % taskname)
             if 'nostamp' in taskdep and taskname in taskdep['nostamp']:
                 if error_nostamp:
                     bb.fatal("Task %s is marked nostamp, cannot invalidate this task" % taskname)
@@ -835,92 +793,6 @@ class RunQueue:
         self.dm = monitordisk.diskMonitor(cfgData)
 
         self.rqexe = None
-        self.worker = None
-        self.workerpipe = None
-        self.fakeworker = None
-        self.fakeworkerpipe = None
-
-    def _start_worker(self, fakeroot = False, rqexec = None):
-        logger.debug(1, "Starting bitbake-worker")
-        if fakeroot:
-            fakerootcmd = self.cfgData.getVar("FAKEROOTCMD", True)
-            fakerootenv = (self.cfgData.getVar("FAKEROOTBASEENV", True) or "").split()
-            env = os.environ.copy()
-            for key, value in (var.split('=') for var in fakerootenv):
-                env[key] = value
-            worker = subprocess.Popen([fakerootcmd, "bitbake-worker", "decafbad"], stdout=subprocess.PIPE, stdin=subprocess.PIPE, env=env)
-        else:
-            worker = subprocess.Popen(["bitbake-worker", "decafbad"], stdout=subprocess.PIPE, stdin=subprocess.PIPE)
-        bb.utils.nonblockingfd(worker.stdout)
-        workerpipe = runQueuePipe(worker.stdout, None, self.cfgData, rqexec)
-
-        workerdata = {
-            "taskdeps" : self.rqdata.dataCache.task_deps,
-            "fakerootenv" : self.rqdata.dataCache.fakerootenv,
-            "fakerootdirs" : self.rqdata.dataCache.fakerootdirs,
-            "fakerootnoenv" : self.rqdata.dataCache.fakerootnoenv,
-            "hashes" : self.rqdata.hashes,
-            "hash_deps" : self.rqdata.hash_deps,
-            "sigchecksums" : bb.parse.siggen.file_checksum_values,
-            "runq_hash" : self.rqdata.runq_hash,
-            "logdefaultdebug" : bb.msg.loggerDefaultDebugLevel,
-            "logdefaultverbose" : bb.msg.loggerDefaultVerbose,
-            "logdefaultverboselogs" : bb.msg.loggerVerboseLogs,
-            "logdefaultdomain" : bb.msg.loggerDefaultDomains,
-            "prhost" : self.cooker.prhost,
-            "buildname" : self.cfgData.getVar("BUILDNAME", True),
-            "date" : self.cfgData.getVar("DATE", True),
-            "time" : self.cfgData.getVar("TIME", True),
-        }
-
-        worker.stdin.write("<cookerconfig>" + pickle.dumps(self.cooker.configuration) + "</cookerconfig>")
-        worker.stdin.write("<workerdata>" + pickle.dumps(workerdata) + "</workerdata>")
-        worker.stdin.flush()
-
-        return worker, workerpipe
-
-    def _teardown_worker(self, worker, workerpipe):
-        if not worker:
-            return
-        logger.debug(1, "Teardown for bitbake-worker")
-        worker.stdin.write("<quit></quit>")
-        worker.stdin.flush()
-        while worker.returncode is None:
-            workerpipe.read()
-            worker.poll()
-        while workerpipe.read():
-            continue
-        workerpipe.close()
-
-    def start_worker(self):
-        if self.worker:
-            self.teardown_workers()
-        self.worker, self.workerpipe = self._start_worker()
-
-    def start_fakeworker(self, rqexec):
-        if not self.fakeworker:
-            self.fakeworker, self.fakeworkerpipe = self._start_worker(True, rqexec)
-
-    def teardown_workers(self):
-        self._teardown_worker(self.worker, self.workerpipe)
-        self.worker = None
-        self.workerpipe = None
-        self._teardown_worker(self.fakeworker, self.fakeworkerpipe)
-        self.fakeworker = None
-        self.fakeworkerpipe = None
-
-    def read_workers(self):
-        self.workerpipe.read()
-        if self.fakeworkerpipe:
-            self.fakeworkerpipe.read()
-
-    def active_fds(self):
-        fds = []
-        if self.workerpipe:
-            fds.append(self.workerpipe.input)
-        if self.fakeworkerpipe:
-            fds.append(self.fakeworkerpipe.input)
-        return fds
 
     def check_stamp_task(self, task, taskname = None, recurse = False, cache = None):
         def get_timestamp(f):
@@ -999,7 +871,7 @@ class RunQueue:
         (if the abort on failure configuration option isn't set)
         """
 
-        retval = True
+        retval = 0.5
 
         if self.state is runQueuePrepare:
             self.rqexe = RunQueueExecuteDummy(self)
@@ -1008,16 +880,10 @@ class RunQueue:
             else:
                 self.state = runQueueSceneInit
 
-                # we are ready to run, see if any UI client needs the dependency info
-                if bb.cooker.CookerFeatures.SEND_DEPENDS_TREE in self.cooker.featureset:
-                    depgraph = self.cooker.buildDependTree(self, self.rqdata.taskData)
-                    bb.event.fire(bb.event.DepTreeGenerated(depgraph), self.cooker.data)
-
         if self.state is runQueueSceneInit:
             if self.cooker.configuration.dump_signatures:
                 self.dump_signatures()
             else:
-                self.start_worker()
                 self.rqexe = RunQueueExecuteScenequeue(self)
 
         if self.state in [runQueueSceneRun, runQueueRunning, runQueueCleanUp]:
@@ -1038,7 +904,6 @@ class RunQueue:
            self.rqexe.finish()
 
         if self.state is runQueueComplete or self.state is runQueueFailed:
-            self.teardown_workers()
             if self.rqexe.stats.failed:
                 logger.info("Tasks Summary: Attempted %d tasks of which %d didn't need to be rerun and %d failed.", self.rqexe.stats.completed + self.rqexe.stats.failed, self.rqexe.stats.skipped, self.rqexe.stats.failed)
             else:
@@ -1056,6 +921,10 @@ class RunQueue:
             # All done
             return False
 
+        if self.state is runQueueChildProcess:
+            print("Child process, eeek, shouldn't happen!")
+            return False
+
         # Loop
         return retval
 
@@ -1069,10 +938,6 @@ class RunQueue:
             raise
         except:
             logger.error("An uncaught exception occured in runqueue, please see the failure below:")
-            try:
-                self.teardown_workers()
-            except:
-                pass
             self.state = runQueueComplete
             raise
 
@@ -1092,7 +957,7 @@ class RunQueue:
         for task in range(len(self.rqdata.runq_fnid)):
             if self.rqdata.runq_fnid[task] not in done:
                 fn = self.rqdata.taskData.fn_index[self.rqdata.runq_fnid[task]]
-                the_data = bb.cache.Cache.loadDataFull(fn, self.cooker.collection.get_file_appends(fn), self.cooker.data)
+                the_data = bb.cache.Cache.loadDataFull(fn, self.cooker.get_file_appends(fn), self.cooker.configuration.data)
                 done.add(self.rqdata.runq_fnid[task])
 
         bb.parse.siggen.dump_sigs(self.rqdata.dataCache)
@@ -1114,21 +979,38 @@ class RunQueueExecute:
         self.runq_buildable = []
         self.runq_running = []
         self.runq_complete = []
-
+        self.build_pids = {}
+        self.build_pipes = {}
         self.build_stamps = {}
         self.failed_fnids = []
 
         self.stampcache = {}
 
-        rq.workerpipe.setrunqueueexec(self)
-        if rq.fakeworkerpipe:
-            rq.fakeworkerpipe.setrunqueueexec(self)
+    def runqueue_process_waitpid(self):
+        """
+        Return none is there are no processes awaiting result collection, otherwise
+        collect the process exit codes and close the information pipe.
+        """
+        pid, status = os.waitpid(-1, os.WNOHANG)
+        if pid == 0 or os.WIFSTOPPED(status):
+            return None
 
-    def runqueue_process_waitpid(self, task, status):
+        if os.WIFEXITED(status):
+            status = os.WEXITSTATUS(status)
+        elif os.WIFSIGNALED(status):
+            # Per shell conventions for $?, when a process exits due to
+            # a signal, we return an exit code of 128 + SIGNUM
+            status = 128 + os.WTERMSIG(status)
+
+        task = self.build_pids[pid]
+        del self.build_pids[pid]
+
+        self.build_pipes[pid].close()
+        del self.build_pipes[pid]
 
         # self.build_stamps[pid] may not exist when use shared work directory.
-        if task in self.build_stamps:
-            del self.build_stamps[task]
+        if pid in self.build_stamps:
+            del self.build_stamps[pid]
 
         if status != 0:
             self.task_fail(task, status)
@@ -1137,12 +1019,16 @@ class RunQueueExecute:
         return True
 
     def finish_now(self):
-
-        self.rq.worker.stdin.write("<finishnow></finishnow>")
-        self.rq.worker.stdin.flush()
-        if self.rq.fakeworker:
-            self.rq.fakeworker.stdin.write("<finishnow></finishnow>")
-            self.rq.fakeworker.stdin.flush()
+        if self.stats.active:
+            logger.info("Sending SIGTERM to remaining %s tasks", self.stats.active)
+            for k, v in self.build_pids.iteritems():
+                try:
+                    os.kill(-k, signal.SIGTERM)
+                    os.waitpid(-1, 0)
+                except:
+                    pass
+        for pipe in self.build_pipes:
+            self.build_pipes[pipe].read()
 
         if len(self.failed_fnids) != 0:
             self.rq.state = runQueueFailed
@@ -1154,10 +1040,12 @@ class RunQueueExecute:
     def finish(self):
         self.rq.state = runQueueCleanUp
 
+        for pipe in self.build_pipes:
+            self.build_pipes[pipe].read()
+
         if self.stats.active > 0:
             bb.event.fire(runQueueExitWait(self.stats.active), self.cfgData)
-            self.rq.read_workers()
-
+            self.runqueue_process_waitpid()
             return
 
         if len(self.failed_fnids) != 0:
@@ -1167,6 +1055,114 @@ class RunQueueExecute:
         self.rq.state = runQueueComplete
         return
 
+    def fork_off_task(self, fn, task, taskname, quieterrors=False):
+        # We need to setup the environment BEFORE the fork, since
+        # a fork() or exec*() activates PSEUDO...
+
+        envbackup = {}
+        fakeenv = {}
+        umask = None
+
+        taskdep = self.rqdata.dataCache.task_deps[fn]
+        if 'umask' in taskdep and taskname in taskdep['umask']:
+            # umask might come in as a number or text string..
+            try:
+                 umask = int(taskdep['umask'][taskname],8)
+            except TypeError:
+                 umask = taskdep['umask'][taskname]
+
+        if 'fakeroot' in taskdep and taskname in taskdep['fakeroot']:
+            envvars = (self.rqdata.dataCache.fakerootenv[fn] or "").split()
+            for key, value in (var.split('=') for var in envvars):
+                envbackup[key] = os.environ.get(key)
+                os.environ[key] = value
+                fakeenv[key] = value
+
+            fakedirs = (self.rqdata.dataCache.fakerootdirs[fn] or "").split()
+            for p in fakedirs:
+                bb.utils.mkdirhier(p)
+
+            logger.debug(2, 'Running %s:%s under fakeroot, fakedirs: %s' %
+                            (fn, taskname, ', '.join(fakedirs)))
+        else:
+            envvars = (self.rqdata.dataCache.fakerootnoenv[fn] or "").split()
+            for key, value in (var.split('=') for var in envvars):
+                envbackup[key] = os.environ.get(key)
+                os.environ[key] = value
+                fakeenv[key] = value
+
+        sys.stdout.flush()
+        sys.stderr.flush()
+        try:
+            pipein, pipeout = os.pipe()
+            pipein = os.fdopen(pipein, 'rb', 4096)
+            pipeout = os.fdopen(pipeout, 'wb', 0)
+            pid = os.fork()
+        except OSError as e:
+            bb.msg.fatal("RunQueue", "fork failed: %d (%s)" % (e.errno, e.strerror))
+
+        if pid == 0:
+            pipein.close()
+
+            # Save out the PID so that the event can include it the
+            # events
+            bb.event.worker_pid = os.getpid()
+            bb.event.worker_pipe = pipeout
+
+            self.rq.state = runQueueChildProcess
+            # Make the child the process group leader
+            os.setpgid(0, 0)
+            # No stdin
+            newsi = os.open(os.devnull, os.O_RDWR)
+            os.dup2(newsi, sys.stdin.fileno())
+
+            if umask:
+                os.umask(umask)
+
+            self.cooker.configuration.data.setVar("BB_WORKERCONTEXT", "1")
+            bb.parse.siggen.set_taskdata(self.rqdata.hashes, self.rqdata.hash_deps)
+            ret = 0
+            try:
+                the_data = bb.cache.Cache.loadDataFull(fn, self.cooker.get_file_appends(fn), self.cooker.configuration.data)
+                the_data.setVar('BB_TASKHASH', self.rqdata.runq_hash[task])
+                for h in self.rqdata.hashes:
+                    the_data.setVar("BBHASH_%s" % h, self.rqdata.hashes[h])
+                for h in self.rqdata.hash_deps:
+                    the_data.setVar("BBHASHDEPS_%s" % h, self.rqdata.hash_deps[h])
+
+                # exported_vars() returns a generator which *cannot* be passed to os.environ.update() 
+                # successfully. We also need to unset anything from the environment which shouldn't be there 
+                exports = bb.data.exported_vars(the_data)
+                bb.utils.empty_environment()
+                for e, v in exports:
+                    os.environ[e] = v
+                for e in fakeenv:
+                    os.environ[e] = fakeenv[e]
+                    the_data.setVar(e, fakeenv[e])
+
+                if quieterrors:
+                    the_data.setVarFlag(taskname, "quieterrors", "1")
+
+            except Exception as exc:
+                if not quieterrors:
+                    logger.critical(str(exc))
+                os._exit(1)
+            try:
+                if not self.cooker.configuration.dry_run:
+                    profile = self.cooker.configuration.profile
+                    ret = bb.build.exec_task(fn, taskname, the_data, profile)
+                os._exit(ret)
+            except:
+                os._exit(1)
+        else:
+            for key, value in envbackup.iteritems():
+                if value is None:
+                    del os.environ[key]
+                else:
+                    os.environ[key] = value
+
+        return pid, pipein, pipeout
+
     def check_dependencies(self, task, taskdeps, setscene = False):
         if not self.rq.depvalidate:
             return False
@@ -1183,7 +1179,7 @@ class RunQueueExecute:
             taskname = self.rqdata.runq_task[depid]
             taskdata[dep] = [pn, taskname, fn]
         call = self.rq.depvalidate + "(task, taskdata, notneeded, d)"
-        locs = { "task" : task, "taskdata" : taskdata, "notneeded" : self.scenequeue_notneeded, "d" : self.cooker.data }
+        locs = { "task" : task, "taskdata" : taskdata, "notneeded" : self.scenequeue_notneeded, "d" : self.cooker.configuration.data }
         valid = bb.utils.better_eval(call, locs)
         return valid
 
@@ -1250,7 +1246,7 @@ class RunQueueExecuteTasks(RunQueueExecute):
 
             call = self.rq.setsceneverify + "(covered, tasknames, fnids, fns, d, invalidtasks=invalidtasks)"
             call2 = self.rq.setsceneverify + "(covered, tasknames, fnids, fns, d)"
-            locs = { "covered" : self.rq.scenequeue_covered, "tasknames" : self.rqdata.runq_task, "fnids" : self.rqdata.runq_fnid, "fns" : self.rqdata.taskData.fn_index, "d" : self.cooker.data, "invalidtasks" : invalidtasks }
+            locs = { "covered" : self.rq.scenequeue_covered, "tasknames" : self.rqdata.runq_task, "fnids" : self.rqdata.runq_fnid, "fns" : self.rqdata.taskData.fn_index, "d" : self.cooker.configuration.data, "invalidtasks" : invalidtasks }
             # Backwards compatibility with older versions without invalidtasks
             try:
                 covered_remove = bb.utils.better_eval(call, locs)
@@ -1278,6 +1274,7 @@ class RunQueueExecuteTasks(RunQueueExecute):
             bb.fatal("Invalid scheduler '%s'.  Available schedulers: %s" %
                      (self.scheduler, ", ".join(obj.name for obj in schedulers)))
 
+
     def get_schedulers(self):
         schedulers = set(obj for obj in globals().values()
                              if type(obj) is type and
@@ -1339,10 +1336,9 @@ class RunQueueExecuteTasks(RunQueueExecute):
         if self.rqdata.taskData.abort:
             self.rq.state = runQueueCleanUp
 
-    def task_skip(self, task, reason):
+    def task_skip(self, task):
         self.runq_running[task] = 1
         self.runq_buildable[task] = 1
-        bb.event.fire(runQueueTaskSkipped(task, self.stats, self.rq, reason), self.cfgData)
         self.task_completeoutright(task)
         self.stats.taskCompleted()
         self.stats.taskSkipped()
@@ -1352,9 +1348,6 @@ class RunQueueExecuteTasks(RunQueueExecute):
         Run the tasks in a queue prepared by rqdata.prepare()
         """
 
-        self.rq.read_workers()
-        
-
         if self.stats.total == 0:
             # nothing to do
             self.rq.state = runQueueCleanUp
@@ -1367,13 +1360,13 @@ class RunQueueExecuteTasks(RunQueueExecute):
             if task in self.rq.scenequeue_covered:
                 logger.debug(2, "Setscene covered task %s (%s)", task,
                                 self.rqdata.get_user_idstring(task))
-                self.task_skip(task, "covered")
+                self.task_skip(task)
                 return True
 
             if self.rq.check_stamp_task(task, taskname, cache=self.stampcache):
                 logger.debug(2, "Stamp current task %s (%s)", task,
                                 self.rqdata.get_user_idstring(task))
-                self.task_skip(task, "existing")
+                self.task_skip(task)
                 return True
 
             taskdep = self.rqdata.dataCache.task_deps[fn]
@@ -1390,25 +1383,23 @@ class RunQueueExecuteTasks(RunQueueExecute):
                 startevent = runQueueTaskStarted(task, self.stats, self.rq)
                 bb.event.fire(startevent, self.cfgData)
 
-            taskdep = self.rqdata.dataCache.task_deps[fn]
-            if 'fakeroot' in taskdep and taskname in taskdep['fakeroot']:
-                if not self.rq.fakeworker:
-                    self.rq.start_fakeworker(self)
-                self.rq.fakeworker.stdin.write("<runtask>" + pickle.dumps((fn, task, taskname, False, self.cooker.collection.get_file_appends(fn))) + "</runtask>")
-                self.rq.fakeworker.stdin.flush()
-            else:
-                self.rq.worker.stdin.write("<runtask>" + pickle.dumps((fn, task, taskname, False, self.cooker.collection.get_file_appends(fn))) + "</runtask>")
-                self.rq.worker.stdin.flush()
+            pid, pipein, pipeout = self.fork_off_task(fn, task, taskname)
 
-            self.build_stamps[task] = bb.build.stampfile(taskname, self.rqdata.dataCache, fn)
+            self.build_pids[pid] = task
+            self.build_pipes[pid] = runQueuePipe(pipein, pipeout, self.cfgData)
+            self.build_stamps[pid] = bb.build.stampfile(taskname, self.rqdata.dataCache, fn)
             self.runq_running[task] = 1
             self.stats.taskActive()
             if self.stats.active < self.number_tasks:
                 return True
 
+        for pipe in self.build_pipes:
+            self.build_pipes[pipe].read()
+
         if self.stats.active > 0:
-            self.rq.read_workers()
-            return self.rq.active_fds()
+            if self.runqueue_process_waitpid() is None:
+                return 0.5
+            return True
 
         if len(self.failed_fnids) != 0:
             self.rq.state = runQueueFailed
@@ -1423,7 +1414,6 @@ class RunQueueExecuteTasks(RunQueueExecute):
             if self.runq_complete[task] == 0:
                 logger.error("Task %s never completed!", task)
         self.rq.state = runQueueComplete
-
         return True
 
 class RunQueueExecuteScenequeue(RunQueueExecute):
@@ -1445,7 +1435,6 @@ class RunQueueExecuteScenequeue(RunQueueExecute):
         sq_revdeps = []
         sq_revdeps_new = []
         sq_revdeps_squash = []
-        self.sq_harddeps = []
 
         # We need to construct a dependency graph for the setscene functions. Intermediate
         # dependencies between the setscene tasks only complicate the code. This code
@@ -1558,7 +1547,6 @@ class RunQueueExecuteScenequeue(RunQueueExecute):
                     if taskid is None:
                         bb.msg.fatal("RunQueue", "Task %s:%s depends upon non-existent task %s:%s" % (self.rqdata.taskData.fn_index[self.rqdata.runq_fnid[realid]], self.rqdata.taskData.tasks_name[realid], dep, idependtask))
 
-                    self.sq_harddeps.append(self.rqdata.runq_setscene.index(taskid))
                     sq_revdeps_squash[self.rqdata.runq_setscene.index(task)].add(self.rqdata.runq_setscene.index(taskid))
                     # Have to zero this to avoid circular dependencies
                     sq_revdeps_squash[self.rqdata.runq_setscene.index(taskid)] = set()
@@ -1618,7 +1606,7 @@ class RunQueueExecuteScenequeue(RunQueueExecute):
                 sq_taskname.append(taskname)
                 sq_task.append(task)
             call = self.rq.hashvalidate + "(sq_fn, sq_task, sq_hash, sq_hashfn, d)"
-            locs = { "sq_fn" : sq_fn, "sq_task" : sq_taskname, "sq_hash" : sq_hash, "sq_hashfn" : sq_hashfn, "d" : self.cooker.data }
+            locs = { "sq_fn" : sq_fn, "sq_task" : sq_taskname, "sq_hash" : sq_hash, "sq_hashfn" : sq_hashfn, "d" : self.cooker.configuration.data }
             valid = bb.utils.better_eval(call, locs)
 
             valid_new = stamppresent
@@ -1636,10 +1624,8 @@ class RunQueueExecuteScenequeue(RunQueueExecute):
 
         self.rq.state = runQueueSceneRun
 
-    def scenequeue_updatecounters(self, task, fail = False):
+    def scenequeue_updatecounters(self, task):
         for dep in self.sq_deps[task]:
-            if fail and task in self.sq_harddeps:
-                continue
             self.sq_revdeps2[dep].remove(task)
             if len(self.sq_revdeps2[dep]) == 0:
                 self.runq_buildable[dep] = 1
@@ -1660,14 +1646,13 @@ class RunQueueExecuteScenequeue(RunQueueExecute):
 
     def task_complete(self, task):
         self.stats.taskCompleted()
-        bb.event.fire(sceneQueueTaskCompleted(task, self.stats, self.rq), self.cfgData)
         self.task_completeoutright(task)
 
     def task_fail(self, task, result):
         self.stats.taskFailed()
         bb.event.fire(sceneQueueTaskFailed(task, self.stats, result, self), self.cfgData)
         self.scenequeue_notcovered.add(task)
-        self.scenequeue_updatecounters(task, True)
+        self.scenequeue_updatecounters(task)
 
     def task_failoutright(self, task):
         self.runq_running[task] = 1
@@ -1676,7 +1661,7 @@ class RunQueueExecuteScenequeue(RunQueueExecute):
         self.stats.taskSkipped()
         index = self.rqdata.runq_setscene[task]
         self.scenequeue_notcovered.add(task)
-        self.scenequeue_updatecounters(task, True)
+        self.scenequeue_updatecounters(task)
 
     def task_skip(self, task):
         self.runq_running[task] = 1
@@ -1690,8 +1675,6 @@ class RunQueueExecuteScenequeue(RunQueueExecute):
         Run the tasks in a queue prepared by prepare_runqueue
         """
 
-        self.rq.read_workers()
-
         task = None
         if self.stats.active < self.number_tasks:
             # Find the next setscene to run
@@ -1732,24 +1715,22 @@ class RunQueueExecuteScenequeue(RunQueueExecute):
             startevent = sceneQueueTaskStarted(task, self.stats, self.rq)
             bb.event.fire(startevent, self.cfgData)
 
-            taskdep = self.rqdata.dataCache.task_deps[fn]
-            if 'fakeroot' in taskdep and taskname in taskdep['fakeroot']:
-                if not self.rq.fakeworker:
-                    self.rq.start_fakeworker(self)
-                self.rq.fakeworker.stdin.write("<runtask>" + pickle.dumps((fn, realtask, taskname, True, self.cooker.collection.get_file_appends(fn))) + "</runtask>")
-                self.rq.fakeworker.stdin.flush()
-            else:
-                self.rq.worker.stdin.write("<runtask>" + pickle.dumps((fn, realtask, taskname, True, self.cooker.collection.get_file_appends(fn))) + "</runtask>")
-                self.rq.worker.stdin.flush()
+            pid, pipein, pipeout = self.fork_off_task(fn, realtask, taskname)
 
+            self.build_pids[pid] = task
+            self.build_pipes[pid] = runQueuePipe(pipein, pipeout, self.cfgData)
             self.runq_running[task] = 1
             self.stats.taskActive()
             if self.stats.active < self.number_tasks:
                 return True
 
+        for pipe in self.build_pipes:
+            self.build_pipes[pipe].read()
+
         if self.stats.active > 0:
-            self.rq.read_workers()
-            return self.rq.active_fds()
+            if self.runqueue_process_waitpid() is None:
+                return 0.5
+            return True
 
         # Convert scenequeue_covered task numbers into full taskgraph ids
         oldcovered = self.scenequeue_covered
@@ -1765,10 +1746,8 @@ class RunQueueExecuteScenequeue(RunQueueExecute):
         self.rq.state = runQueueRunInit
         return True
 
-    def runqueue_process_waitpid(self, task, status):
-        task = self.rq.rqdata.runq_setscene.index(task)
-
-        RunQueueExecute.runqueue_process_waitpid(self, task, status)
+    def fork_off_task(self, fn, task, taskname):
+        return RunQueueExecute.fork_off_task(self, fn, task, taskname, quieterrors=True)
 
 class TaskFailure(Exception):
     """
@@ -1795,9 +1774,6 @@ class runQueueEvent(bb.event.Event):
     def __init__(self, task, stats, rq):
         self.taskid = task
         self.taskstring = rq.rqdata.get_user_idstring(task)
-        self.taskname = rq.rqdata.get_task_name(task)
-        self.taskfile = rq.rqdata.get_task_file(task)
-        self.taskhash = rq.rqdata.get_task_hash(task)
         self.stats = stats.copy()
         bb.event.Event.__init__(self)
 
@@ -1809,9 +1785,6 @@ class sceneQueueEvent(runQueueEvent):
         runQueueEvent.__init__(self, task, stats, rq)
         realtask = rq.rqdata.runq_setscene[task]
         self.taskstring = rq.rqdata.get_user_idstring(realtask, "_setscene")
-        self.taskname = rq.rqdata.get_task_name(realtask) + "_setscene"
-        self.taskfile = rq.rqdata.get_task_file(realtask)
-        self.taskhash = rq.rqdata.get_task_hash(task)
 
 class runQueueTaskStarted(runQueueEvent):
     """
@@ -1850,60 +1823,29 @@ class runQueueTaskCompleted(runQueueEvent):
     Event notifing a task completed
     """
 
-class sceneQueueTaskCompleted(sceneQueueEvent):
-    """
-    Event notifing a setscene task completed
-    """
-
-class runQueueTaskSkipped(runQueueEvent):
-    """
-    Event notifing a task was skipped
-    """
-    def __init__(self, task, stats, rq, reason):
-        runQueueEvent.__init__(self, task, stats, rq)
-        self.reason = reason
-
 class runQueuePipe():
     """
     Abstraction for a pipe between a worker thread and the server
     """
-    def __init__(self, pipein, pipeout, d, rq):
+    def __init__(self, pipein, pipeout, d):
         self.input = pipein
-        if pipeout:
-            pipeout.close()
+        pipeout.close()
         bb.utils.nonblockingfd(self.input)
         self.queue = ""
         self.d = d
-        self.rq = rq
-
-    def setrunqueueexec(self, rq):
-        self.rq = rq
 
     def read(self):
         start = len(self.queue)
         try:
             self.queue = self.queue + self.input.read(102400)
-        except (OSError, IOError) as e:
-            if e.errno != errno.EAGAIN:
-                raise
+        except (OSError, IOError):
+            pass
         end = len(self.queue)
-        found = True
-        while found and len(self.queue):
-            found = False
+        index = self.queue.find("</event>")
+        while index != -1:
+            bb.event.fire_from_worker(self.queue[:index+8], self.d)
+            self.queue = self.queue[index+8:]
             index = self.queue.find("</event>")
-            while index != -1 and self.queue.startswith("<event>"):
-                event = pickle.loads(self.queue[7:index])
-                bb.event.fire_from_worker(event, self.d)
-                found = True
-                self.queue = self.queue[index+8:]
-                index = self.queue.find("</event>")
-            index = self.queue.find("</exitcode>")
-            while index != -1 and self.queue.startswith("<exitcode>"):
-                task, status = pickle.loads(self.queue[10:index])
-                self.rq.runqueue_process_waitpid(task, status)
-                found = True
-                self.queue = self.queue[index+11:]
-                index = self.queue.find("</exitcode>")
         return (end > start)
 
     def close(self):

bitbake/lib/bb/server/__init__.py

@@ -1,96 +0,0 @@
-#
-# BitBake Base Server Code
-#
-# Copyright (C) 2006 - 2007  Michael 'Mickey' Lauer
-# Copyright (C) 2006 - 2008  Richard Purdie
-# Copyright (C) 2013         Alexandru Damian
-#
-# 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.
-
-""" Base code for Bitbake server process
-
-Have a common base for that all Bitbake server classes ensures a consistent
-approach to the interface, and minimize risks associated with code duplication.
-
-"""
-
-"""  BaseImplServer() the base class for all XXServer() implementations.
-
-    These classes contain the actual code that runs the server side, i.e.
-    listens for the commands and executes them. Although these implementations
-    contain all the data of the original bitbake command, i.e the cooker instance,
-    they may well run on a different process or even machine.
-
-"""
-
-class BaseImplServer():
-    def __init__(self):
-        self._idlefuns = {}
-
-    def addcooker(self, cooker):
-        self.cooker = cooker
-
-    def register_idle_function(self, function, data):
-        """Register a function to be called while the server is idle"""
-        assert hasattr(function, '__call__')
-        self._idlefuns[function] = data
-
-
-
-""" BitBakeBaseServerConnection class is the common ancestor to all
-    BitBakeServerConnection classes.
-
-    These classes control the remote server. The only command currently
-    implemented is the terminate() command.
-
-"""
-
-class BitBakeBaseServerConnection():
-    def __init__(self, serverImpl):
-        pass
-
-    def terminate(self):
-        pass
-
-
-""" BitBakeBaseServer class is the common ancestor to all Bitbake servers
-
-    Derive this class in order to implement a BitBakeServer which is the
-    controlling stub for the actual server implementation
-
-"""
-class BitBakeBaseServer(object):
-    def initServer(self):
-        self.serverImpl = None  # we ensure a runtime crash if not overloaded
-        self.connection = None
-        return
-
-    def addcooker(self, cooker):
-        self.cooker = cooker
-        self.serverImpl.addcooker(cooker)
-
-    def getServerIdleCB(self):
-        return self.serverImpl.register_idle_function
-
-    def saveConnectionDetails(self):
-        return
-
-    def detach(self):
-        return
-
-    def establishConnection(self, featureset):
-        raise   "Must redefine the %s.establishConnection()" % self.__class__.__name__
-
-    def endSession(self):
-        self.connection.terminate()

bitbake/lib/bb/server/none.py

@@ -0,0 +1,203 @@
+#
+# BitBake 'dummy' Passthrough Server
+#
+# Copyright (C) 2006 - 2007  Michael 'Mickey' Lauer
+# Copyright (C) 2006 - 2008  Richard Purdie
+#
+# 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.
+
+"""
+    This module implements a passthrough server for BitBake.
+
+    Use register_idle_function() to add a function which the server
+    calls from within idle_commands when no requests are pending. Make sure
+    that those functions are non-blocking or else you will introduce latency
+    in the server's main loop.
+"""
+
+import time
+import bb
+import signal
+
+DEBUG = False
+
+import inspect, select
+
+class BitBakeServerCommands():
+    def __init__(self, server):
+        self.server = server
+
+    def runCommand(self, command):
+        """
+        Run a cooker command on the server
+        """
+        #print "Running Command %s" % command
+        return self.cooker.command.runCommand(command)
+
+    def terminateServer(self):
+        """
+        Trigger the server to quit
+        """
+        self.server.server_exit()
+        #print "Server (cooker) exitting"
+        return
+
+    def ping(self):
+        """
+        Dummy method which can be used to check the server is still alive
+        """
+        return True
+
+eventQueue = []
+
+class BBUIEventQueue:
+    class event:
+        def __init__(self, parent):
+            self.parent = parent
+        @staticmethod
+        def send(event):
+            bb.server.none.eventQueue.append(event)
+        @staticmethod
+        def quit():
+            return
+
+    def __init__(self, BBServer):
+        self.eventQueue = bb.server.none.eventQueue
+        self.BBServer = BBServer
+        self.EventHandle = bb.event.register_UIHhandler(self)
+
+    def __popEvent(self):
+        if len(self.eventQueue) == 0:
+            return None
+        return self.eventQueue.pop(0)
+
+    def getEvent(self):
+        if len(self.eventQueue) == 0:
+          self.BBServer.idle_commands(0)
+        return self.__popEvent()
+
+    def waitEvent(self, delay):
+        event = self.__popEvent()
+        if event:
+            return event
+        self.BBServer.idle_commands(delay)
+        return self.__popEvent()
+
+    def queue_event(self, event):
+        self.eventQueue.append(event)
+
+    def system_quit( self ):
+        bb.event.unregister_UIHhandler(self.EventHandle)
+
+# Dummy signal handler to ensure we break out of sleep upon SIGCHLD
+def chldhandler(signum, stackframe):
+    pass
+
+class BitBakeNoneServer():
+    # remove this when you're done with debugging
+    # allow_reuse_address = True
+
+    def __init__(self):
+        self._idlefuns = {}
+        self.commands = BitBakeServerCommands(self)
+
+    def addcooker(self, cooker):
+        self.cooker = cooker
+        self.commands.cooker = cooker
+
+    def register_idle_function(self, function, data):
+        """Register a function to be called while the server is idle"""
+        assert hasattr(function, '__call__')
+        self._idlefuns[function] = data
+
+    def idle_commands(self, delay):
+        #print "Idle queue length %s" % len(self._idlefuns)
+        #print "Idle timeout, running idle functions"
+        #if len(self._idlefuns) == 0:
+        nextsleep = delay
+        for function, data in self._idlefuns.items():
+            try:
+                retval = function(self, data, False)
+                #print "Idle function returned %s" % (retval)
+                if retval is False:
+                    del self._idlefuns[function]
+                elif retval is True:
+                    nextsleep = None
+                elif nextsleep is None:
+                    continue
+                elif retval < nextsleep:
+                    nextsleep = retval
+            except SystemExit:
+                raise
+            except:
+                import traceback
+                traceback.print_exc()
+                self.commands.runCommand(["stateShutdown"])
+                pass
+        if nextsleep is not None:
+            #print "Sleeping for %s (%s)" % (nextsleep, delay)
+            signal.signal(signal.SIGCHLD, chldhandler)
+            time.sleep(nextsleep)
+            signal.signal(signal.SIGCHLD, signal.SIG_DFL)
+
+    def server_exit(self):
+        # Tell idle functions we're exiting
+        for function, data in self._idlefuns.items():
+            try:
+                retval = function(self, data, True)
+            except:
+                pass
+
+class BitBakeServerConnection():
+    def __init__(self, server):
+        self.server = server.server
+        self.connection = self.server.commands
+        self.events = bb.server.none.BBUIEventQueue(self.server)
+        for event in bb.event.ui_queue:
+            self.events.queue_event(event)
+
+    def terminate(self):
+        try:
+            self.events.system_quit()
+        except:
+            pass
+        try:
+            self.connection.terminateServer()
+        except:
+            pass
+
+class BitBakeServer(object):
+    def initServer(self):
+        self.server = BitBakeNoneServer()
+
+    def addcooker(self, cooker):
+        self.cooker = cooker
+        self.server.addcooker(cooker)
+
+    def getServerIdleCB(self):
+        return self.server.register_idle_function
+
+    def saveConnectionDetails(self):
+        return
+
+    def detach(self):
+        return
+
+    def establishConnection(self):
+        self.connection = BitBakeServerConnection(self)
+        return self.connection
+
+    def launchUI(self, uifunc, *args):
+        return bb.cooker.server_main(self.cooker, uifunc, *args)
+

bitbake/lib/bb/server/process.py

@@ -29,18 +29,14 @@ import os
 import signal
 import sys
 import time
-import select
 from Queue import Empty
-from multiprocessing import Event, Process, util, Queue, Pipe, queues, Manager
-
-from . import BitBakeBaseServer, BitBakeBaseServerConnection, BaseImplServer
+from multiprocessing import Event, Process, util, Queue, Pipe, queues
 
 logger = logging.getLogger('BitBake')
 
 class ServerCommunicator():
-    def __init__(self, connection, event_handle):
+    def __init__(self, connection):
         self.connection = connection
-        self.event_handle = event_handle
 
     def runCommand(self, command):
         # @todo try/except
@@ -56,8 +52,6 @@ class ServerCommunicator():
             except KeyboardInterrupt:
                 pass
 
-    def getEventHandle(self):
-        return self.event_handle.value
 
 class EventAdapter():
     """
@@ -74,35 +68,30 @@ class EventAdapter():
             print("EventAdapter puked: %s" % str(err))
 
 
-class ProcessServer(Process, BaseImplServer):
+class ProcessServer(Process):
     profile_filename = "profile.log"
     profile_processed_filename = "profile.log.processed"
 
-    def __init__(self, command_channel, event_queue, featurelist):
-        BaseImplServer.__init__(self)
-        Process.__init__(self, args=(featurelist))
+    def __init__(self, command_channel, event_queue):
+        Process.__init__(self)
         self.command_channel = command_channel
         self.event_queue = event_queue
         self.event = EventAdapter(event_queue)
-        self.featurelist = featurelist
+        self._idlefunctions = {}
         self.quit = False
 
         self.keep_running = Event()
         self.keep_running.set()
-        self.event_handle = multiprocessing.Value("i")
+
+    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):
         for event in bb.event.ui_queue:
             self.event_queue.put(event)
-        self.event_handle.value = bb.event.register_UIHhandler(self)
-
-        # process any feature changes based on what UI requested
-        original_featureset = list(self.cooker.featureset)
-        while len(self.featurelist)> 0:
-            self.cooker.featureset.setFeature(self.featurelist.pop())
-        if (original_featureset != list(self.cooker.featureset)):
-            self.cooker.reset()
-
+        self.event_handle = bb.event.register_UIHhandler(self)
         bb.cooker.server_main(self.cooker, self.main)
 
     def main(self):
@@ -115,37 +104,37 @@ class ProcessServer(Process, BaseImplServer):
                     command = self.command_channel.recv()
                     self.runCommand(command)
 
-                self.idle_commands(.1, [self.event_queue._reader, self.command_channel])
+                self.idle_commands(.1)
             except Exception:
                 logger.exception('Running command %s', command)
 
-        self.event_queue.close()
-        bb.event.unregister_UIHhandler(self.event_handle.value)
+        self.event_queue.cancel_join_thread()
+        bb.event.unregister_UIHhandler(self.event_handle)
         self.command_channel.close()
-        self.cooker.shutdown(True)
+        self.cooker.stop()
         self.idle_commands(.1)
 
-    def idle_commands(self, delay, fds = []):
+    def idle_commands(self, delay):
         nextsleep = delay
 
-        for function, data in self._idlefuns.items():
+        for function, data in self._idlefunctions.items():
             try:
                 retval = function(self, data, False)
                 if retval is False:
-                    del self._idlefuns[function]
+                    del self._idlefunctions[function]
                 elif retval is True:
                     nextsleep = None
                 elif nextsleep is None:
                     continue
-                else:
-                    fds = fds + retval
+                elif retval < nextsleep:
+                    nextsleep = retval
             except SystemExit:
                 raise
             except Exception:
                 logger.exception('Running idle function')
 
         if nextsleep is not None:
-            select.select(fds,[],[],nextsleep)
+            time.sleep(nextsleep)
 
     def runCommand(self, command):
         """
@@ -156,33 +145,80 @@ class ProcessServer(Process, BaseImplServer):
     def stop(self):
         self.keep_running.clear()
 
-class BitBakeProcessServerConnection(BitBakeBaseServerConnection):
-    def __init__(self, serverImpl, ui_channel, event_queue):
-        self.procserver = serverImpl
-        self.ui_channel = ui_channel
-        self.event_queue = event_queue
-        self.connection = ServerCommunicator(self.ui_channel, self.procserver.event_handle)
-        self.events = self.event_queue
+    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."""
 
-    def terminate(self):
-        def flushevents():
-            while True:
-                try:
-                    event = self.event_queue.get(block=False)
-                except (Empty, IOError):
-                    break
-                if isinstance(event, logging.LogRecord):
-                    logger.handle(event)
+        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 as 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:
+            exitcode = 1
+            import traceback
+            sys.stderr.write('Process %s:\n' % self.name)
+            sys.stderr.flush()
+            traceback.print_exc()
 
+        util.info('process exiting with exitcode %d' % exitcode)
+        return exitcode
+
+    # Python versions 2.6.0 through 2.6.2 suffer from a multiprocessing bug
+    # which can result in a bitbake server hang during the parsing process
+    if (2, 6, 0) <= sys.version_info < (2, 6, 3):
+        _bootstrap = bootstrap_2_6_6
+
+class BitBakeServerConnection():
+    def __init__(self, server):
+        self.server = server
+        self.procserver = server.server
+        self.connection = ServerCommunicator(server.ui_channel)
+        self.events = server.event_queue
+
+    def terminate(self, force = False):
         signal.signal(signal.SIGINT, signal.SIG_IGN)
         self.procserver.stop()
-
-        while self.procserver.is_alive():
-            flushevents()
-            self.procserver.join(0.1)
-
-        self.ui_channel.close()
-        self.event_queue.close()
+        if force:
+            self.procserver.join(0.5)
+            if self.procserver.is_alive():
+                self.procserver.terminate()
+                self.procserver.join()
+        else:
+            self.procserver.join()
+        while True:
+            try:
+                event = self.server.event_queue.get(block=False)
+            except (Empty, IOError):
+                break
+            if isinstance(event, logging.LogRecord):
+                logger.handle(event)
+        self.server.ui_channel.close()
+        self.server.event_queue.close()
+        if force:
+            sys.exit(1)
 
 # Wrap Queue to provide API which isn't server implementation specific
 class ProcessEventQueue(multiprocessing.queues.Queue):
@@ -199,7 +235,7 @@ class ProcessEventQueue(multiprocessing.queues.Queue):
             return None
 
 
-class BitBakeServer(BitBakeBaseServer):
+class BitBakeServer(object):
     def initServer(self):
         # establish communication channels.  We use bidirectional pipes for
         # ui <--> server command/response pairs
@@ -207,17 +243,28 @@ class BitBakeServer(BitBakeBaseServer):
         #
         self.ui_channel, self.server_channel = Pipe()
         self.event_queue = ProcessEventQueue(0)
-        manager = Manager()
-        self.featurelist = manager.list()
-        self.serverImpl = ProcessServer(self.server_channel, self.event_queue, self.featurelist)
 
-    def detach(self):
-        self.serverImpl.start()
+        self.server = ProcessServer(self.server_channel, self.event_queue)
+
+    def addcooker(self, cooker):
+        self.cooker = cooker
+        self.server.cooker = cooker
+
+    def getServerIdleCB(self):
+        return self.server.register_idle_function
+
+    def saveConnectionDetails(self):
         return
 
-    def establishConnection(self, featureset):
-        for f in featureset:
-            self.featurelist.append(f)
-        self.connection = BitBakeProcessServerConnection(self.serverImpl, self.ui_channel, self.event_queue)
-        signal.signal(signal.SIGTERM, lambda i, s: self.connection.terminate())
+    def detach(self):
+        self.server.start() 
+        return
+
+    def establishConnection(self):
+        self.connection = BitBakeServerConnection(self)
+        signal.signal(signal.SIGTERM, lambda i, s: self.connection.terminate(force=True))
         return self.connection
+
+    def launchUI(self, uifunc, *args):
+        return uifunc(*args)
+

bitbake/lib/bb/server/xmlrpc.py

@@ -35,79 +35,103 @@ import bb
 import xmlrpclib, sys
 from bb import daemonize
 from bb.ui import uievent
-import hashlib, time
-import socket
-import os, signal
-import threading
-try:
-    import cPickle as pickle
-except ImportError:
-    import pickle
 
 DEBUG = False
 
 from SimpleXMLRPCServer import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler
-import inspect, select, httplib
+import inspect, select
 
-from . import BitBakeBaseServer, BitBakeBaseServerConnection, BaseImplServer
+if sys.hexversion < 0x020600F0:
+    print("Sorry, python 2.6 or later is required for bitbake's XMLRPC mode")
+    sys.exit(1)
+
+##
+# The xmlrpclib.Transport class has undergone various changes in Python 2.7
+# which break BitBake's XMLRPC implementation.
+# To work around this we subclass Transport and have a copy/paste of method
+# implementations from Python 2.6.6's xmlrpclib.
+#
+# Upstream Python bug is #8194 (http://bugs.python.org/issue8194)
+# This bug is relevant for Python 2.7.0 and 2.7.1 but was fixed for
+# Python > 2.7.2
+##
 
 class BBTransport(xmlrpclib.Transport):
-    def __init__(self, timeout):
-        self.timeout = timeout
-        self.connection_token = None
-        xmlrpclib.Transport.__init__(self)
+    def request(self, host, handler, request_body, verbose=0):
+        h = self.make_connection(host)
+        if verbose:
+            h.set_debuglevel(1)
+
+        self.send_request(h, handler, request_body)
+        self.send_host(h, host)
+        self.send_user_agent(h)
+        self.send_content(h, request_body)
+
+        errcode, errmsg, headers = h.getreply()
+
+        if errcode != 200:
+            raise ProtocolError(
+                host + handler,
+                errcode, errmsg,
+                headers
+                )
+
+        self.verbose = verbose
+
+        try:
+            sock = h._conn.sock
+        except AttributeError:
+            sock = None
+
+        return self._parse_response(h.getfile(), sock)
 
-    # Modified from default to pass timeout to HTTPConnection
     def make_connection(self, host):
-        #return an existing connection if possible.  This allows
-        #HTTP/1.1 keep-alive.
-        if self._connection and host == self._connection[0]:
-            return self._connection[1]
+        import httplib
+        host, extra_headers, x509 = self.get_host_info(host)
+        return httplib.HTTP(host)
 
-        # create a HTTP connection object from a host descriptor
-        chost, self._extra_headers, x509 = self.get_host_info(host)
-        #store the host argument along with the connection object
-        self._connection = host, httplib.HTTPConnection(chost, timeout=self.timeout)
-        return self._connection[1]
+    def _parse_response(self, file, sock):
+        p, u = self.getparser()
 
-    def set_connection_token(self, token):
-        self.connection_token = token
+        while 1:
+            if sock:
+                response = sock.recv(1024)
+            else:
+                response = file.read(1024)
+            if not response:
+                break
+            if self.verbose:
+                print "body:", repr(response)
+            p.feed(response)
 
-    def send_content(self, h, body):
-        if self.connection_token:
-            h.putheader("Bitbake-token", self.connection_token)
-        xmlrpclib.Transport.send_content(self, h, body)
+        file.close()
+        p.close()
 
-def _create_server(host, port, timeout = 60):
-    t = BBTransport(timeout)
-    s = xmlrpclib.Server("http://%s:%d/" % (host, port), transport=t, allow_none=True)
-    return s, t
+        return u.close()
+
+def _create_server(host, port):
+    # Python 2.7.0 and 2.7.1 have a buggy Transport implementation
+    # For those versions of Python, and only those versions, use our
+    # own copy/paste BBTransport class.
+    if (2, 7, 0) <= sys.version_info < (2, 7, 2):
+        t = BBTransport()
+        s = xmlrpclib.Server("http://%s:%d/" % (host, port), transport=t, allow_none=True)
+    else:
+        s = xmlrpclib.Server("http://%s:%d/" % (host, port), allow_none=True)
+
+    return s
 
 class BitBakeServerCommands():
-
     def __init__(self, server):
         self.server = server
-        self.has_client = False
 
-    def registerEventHandler(self, host, port, featureset = []):
+    def registerEventHandler(self, host, port):
         """
         Register a remote UI Event Handler
         """
-        s, t = _create_server(host, port)
+        s = _create_server(host, port)
 
-        # we don't allow connections if the cooker is running
-        if (self.cooker.state in [bb.cooker.state.parsing, bb.cooker.state.running]):
-            return None
-
-        original_featureset = list(self.cooker.featureset)
-        for f in featureset:
-            self.cooker.featureset.setFeature(f)
-
-        if (original_featureset != list(self.cooker.featureset)):
-            self.cooker.reset()
-
-        self.event_handle = bb.event.register_UIHhandler(s)
-        return self.event_handle
+        return bb.event.register_UIHhandler(s)
 
     def unregisterEventHandler(self, handlerNum):
         """
@@ -119,10 +143,7 @@ class BitBakeServerCommands():
         """
         Run a cooker command on the server
         """
-        return self.cooker.command.runCommand(command, self.server.readonly)
-
-    def getEventHandle(self):
-        return self.event_handle
+        return self.cooker.command.runCommand(command)
 
     def terminateServer(self):
         """
@@ -132,64 +153,13 @@ class BitBakeServerCommands():
         print("Server (cooker) exiting")
         return
 
-    def addClient(self):
-        if self.has_client:
-            return None
-        token = hashlib.md5(str(time.time())).hexdigest()
-        self.server.set_connection_token(token)
-        self.has_client = True
-        return token
+    def ping(self):
+        """
+        Dummy method which can be used to check the server is still alive
+        """
+        return True
 
-    def removeClient(self):
-        if self.has_client:
-            self.server.set_connection_token(None)
-            self.has_client = False
-            if self.server.single_use:
-                self.server.quit = True
-
-# This request handler checks if the request has a "Bitbake-token" header
-# field (this comes from the client side) and compares it with its internal
-# "Bitbake-token" field (this comes from the server). If the two are not
-# equal, it is assumed that a client is trying to connect to the server
-# while another client is connected to the server. In this case, a 503 error
-# ("service unavailable") is returned to the client.
-class BitBakeXMLRPCRequestHandler(SimpleXMLRPCRequestHandler):
-    def __init__(self, request, client_address, server):
-        self.server = server
-        SimpleXMLRPCRequestHandler.__init__(self, request, client_address, server)
-
-    def do_POST(self):
-        try:
-            remote_token = self.headers["Bitbake-token"]
-        except:
-            remote_token = None
-        if remote_token != self.server.connection_token and remote_token != "observer":
-            self.report_503()
-        else:
-            if remote_token == "observer":
-                self.server.readonly = True
-            else:
-                self.server.readonly = False
-            SimpleXMLRPCRequestHandler.do_POST(self)
-
-    def report_503(self):
-        self.send_response(503)
-        response = 'No more client allowed'
-        self.send_header("Content-type", "text/plain")
-        self.send_header("Content-length", str(len(response)))
-        self.end_headers()
-        self.wfile.write(response)
-
-
-class XMLRPCProxyServer(BaseImplServer):
-    """ not a real working server, but a stub for a proxy server connection
-
-    """
-    def __init__(self, host, port):
-        self.host = host
-        self.port = port
-
-class XMLRPCServer(SimpleXMLRPCServer, BaseImplServer):
+class BitBakeXMLRPCServer(SimpleXMLRPCServer):
     # remove this when you're done with debugging
     # allow_reuse_address = True
 
@@ -197,22 +167,17 @@ class XMLRPCServer(SimpleXMLRPCServer, BaseImplServer):
         """
         Constructor
         """
-        BaseImplServer.__init__(self)
         SimpleXMLRPCServer.__init__(self, interface,
-                                    requestHandler=BitBakeXMLRPCRequestHandler,
+                                    requestHandler=SimpleXMLRPCRequestHandler,
                                     logRequests=False, allow_none=True)
+        self._idlefuns = {}
         self.host, self.port = self.socket.getsockname()
-        self.connection_token = None
         #self.register_introspection_functions()
         self.commands = BitBakeServerCommands(self)
         self.autoregister_all_functions(self.commands, "")
-        self.interface = interface
-        self.single_use = False
-        if (interface[1] == 0):     # anonymous port, not getting reused
-            self.single_use = True
 
     def addcooker(self, cooker):
-        BaseImplServer.addcooker(self, cooker)
+        self.cooker = cooker
         self.commands.cooker = cooker
 
     def autoregister_all_functions(self, context, prefix):
@@ -225,9 +190,12 @@ class XMLRPCServer(SimpleXMLRPCServer, BaseImplServer):
             if name.startswith(prefix):
                 self.register_function(method, name[len(prefix):])
 
+    def register_idle_function(self, function, data):
+        """Register a function to be called while the server is idle"""
+        assert hasattr(function, '__call__')
+        self._idlefuns[function] = data
 
     def serve_forever(self):
-        # Start the actual XMLRPC server
         bb.cooker.server_main(self.cooker, self._serve_forever)
 
     def _serve_forever(self):
@@ -235,9 +203,12 @@ class XMLRPCServer(SimpleXMLRPCServer, BaseImplServer):
         Serve Requests. Overloaded to honor a quit command
         """
         self.quit = False
+        self.timeout = 0 # Run Idle calls for our first callback
         while not self.quit:
-            fds = [self]
-            nextsleep = 0.1
+            #print "Idle queue length %s" % len(self._idlefuns)
+            self.handle_request()
+            #print "Idle timeout, running idle functions"
+            nextsleep = None
             for function, data in self._idlefuns.items():
                 try:
                     retval = function(self, data, False)
@@ -245,59 +216,42 @@ class XMLRPCServer(SimpleXMLRPCServer, BaseImplServer):
                         del self._idlefuns[function]
                     elif retval is True:
                         nextsleep = 0
-                    else:
-                        fds = fds + retval
+                    elif nextsleep is 0:
+                        continue
+                    elif nextsleep is None:
+                        nextsleep = retval
+                    elif retval < nextsleep:
+                        nextsleep = retval
                 except SystemExit:
                     raise
                 except:
                     import traceback
                     traceback.print_exc()
                     pass
-
-            socktimeout = self.socket.gettimeout() or nextsleep
-            socktimeout = min(socktimeout, nextsleep)
-            # Mirror what BaseServer handle_request would do
-            fd_sets = select.select(fds, [], [], socktimeout)
-            if fd_sets[0] and self in fd_sets[0]:
-                self._handle_request_noblock()
-
+            if nextsleep is None and len(self._idlefuns) > 0:
+                nextsleep = 0
+            self.timeout = nextsleep
         # Tell idle functions we're exiting
         for function, data in self._idlefuns.items():
             try:
                 retval = function(self, data, True)
             except:
                 pass
+
         self.server_close()
         return
 
-    def set_connection_token(self, token):
-        self.connection_token = token
+class BitbakeServerInfo():
+    def __init__(self, host, port):
+        self.host = host
+        self.port = port
 
-class BitBakeXMLRPCServerConnection(BitBakeBaseServerConnection):
-    def __init__(self, serverImpl, clientinfo=("localhost", 0), observer_only = False, featureset = []):
-        self.connection, self.transport = _create_server(serverImpl.host, serverImpl.port)
-        self.clientinfo = clientinfo
-        self.serverImpl = serverImpl
-        self.observer_only = observer_only
-        self.featureset = featureset
-
-    def connect(self):
-        if not self.observer_only:
-            token = self.connection.addClient()
-        else:
-            token = "observer"
-        if token is None:
-            return None
-        self.transport.set_connection_token(token)
-
-        self.events = uievent.BBUIEventQueue(self.connection, self.clientinfo, self.featureset)
+class BitBakeServerConnection():
+    def __init__(self, serverinfo, clientinfo=("localhost", 0)):
+        self.connection = _create_server(serverinfo.host, serverinfo.port)
+        self.events = uievent.BBUIEventQueue(self.connection, clientinfo)
         for event in bb.event.ui_queue:
             self.events.queue_event(event)
-        return self
-
-    def removeClient(self):
-        if not self.observer_only:
-            self.connection.removeClient()
 
     def terminate(self):
         # Don't wait for server indefinitely
@@ -308,58 +262,34 @@ class BitBakeXMLRPCServerConnection(BitBakeBaseServerConnection):
         except:
             pass
         try:
-            self.connection.removeClient()
+            self.connection.terminateServer()
         except:
             pass
 
-class BitBakeServer(BitBakeBaseServer):
+class BitBakeServer(object):
     def initServer(self, interface = ("localhost", 0)):
-        self.interface = interface
-        self.serverImpl = XMLRPCServer(interface)
+        self.server = BitBakeXMLRPCServer(interface)
+
+    def addcooker(self, cooker):
+        self.cooker = cooker
+        self.server.addcooker(cooker)
+
+    def getServerIdleCB(self):
+        return self.server.register_idle_function
+
+    def saveConnectionDetails(self): 
+        self.serverinfo = BitbakeServerInfo(self.server.host, self.server.port)
 
     def detach(self):
-        daemonize.createDaemon(self.serverImpl.serve_forever, "bitbake-cookerdaemon.log")
+        daemonize.createDaemon(self.server.serve_forever, "bitbake-cookerdaemon.log")
         del self.cooker
+        del self.server
 
-    def establishConnection(self, featureset):
-        self.connection = BitBakeXMLRPCServerConnection(self.serverImpl, self.interface, False, featureset)
-        return self.connection.connect()
+    def establishConnection(self):
+        self.connection = BitBakeServerConnection(self.serverinfo)
+        return self.connection
 
-    def set_connection_token(self, token):
-        self.connection.transport.set_connection_token(token)
+    def launchUI(self, uifunc, *args):
+        return uifunc(*args)
 
-class BitBakeXMLRPCClient(BitBakeBaseServer):
 
-    def __init__(self, observer_only = False):
-        self.observer_only = observer_only
-        # if we need extra caches, just tell the server to load them all
-        pass
-
-    def saveConnectionDetails(self, remote):
-        self.remote = remote
-
-    def establishConnection(self, featureset):
-        # The format of "remote" must be "server:port"
-        try:
-            [host, port] = self.remote.split(":")
-            port = int(port)
-        except:
-            return None
-        # We need our IP for the server connection. We get the IP
-        # by trying to connect with the server
-        try:
-            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            s.connect((host, port))
-            ip = s.getsockname()[0]
-            s.close()
-        except:
-            return None
-        try:
-            self.serverImpl = XMLRPCProxyServer(host, port)
-            self.connection = BitBakeXMLRPCServerConnection(self.serverImpl, (ip, 0), self.observer_only, featureset)
-            return self.connection.connect()
-        except Exception as e:
-            bb.fatal("Could not connect to server at %s:%s (%s)" % (host, port, str(e)))
-
-    def endSession(self):
-        self.connection.removeClient()

bitbake/lib/bb/siggen.py

@@ -24,7 +24,7 @@ def init(d):
             break
     else:
         logger.error("Invalid signature generator '%s', using default 'noop'\n"
-                     "Available generators: %s", desired,
+                     "Available generators: %s",
                      ', '.join(obj.name for obj in siggens))
         return SignatureGenerator(d)
 
@@ -91,7 +91,8 @@ class SignatureGeneratorBasic(SignatureGenerator):
         basehash = {}
 
         for task in tasklist:
-            data = lookupcache[task]
+            data = d.getVar(task, False)
+            lookupcache[task] = data
 
             if data is None:
                 bb.error("Task %s from %s seems to be empty?!" % (task, fn))
@@ -114,8 +115,16 @@ class SignatureGeneratorBasic(SignatureGenerator):
             alldeps = sorted(seen)
             for dep in alldeps:
                 data = data + dep
-                var = lookupcache[dep]
-                if var is not None:
+                if dep in lookupcache:
+                    var = lookupcache[dep]
+                elif dep[-1] == ']':
+                    vf = dep[:-1].split('[')
+                    var = d.getVarFlag(vf[0], vf[1], False)
+                    lookupcache[dep] = var
+                else:
+                    var = d.getVar(dep, False)
+                    lookupcache[dep] = var
+                if var:
                     data = data + str(var)
             self.basehash[fn + "." + task] = hashlib.md5(data).hexdigest()
             taskdeps[task] = alldeps
@@ -192,10 +201,9 @@ class SignatureGeneratorBasic(SignatureGenerator):
         #d.setVar("BB_TASKHASH_task-%s" % task, taskhash[task])
         return h
 
-    def set_taskdata(self, hashes, deps, checksums):
+    def set_taskdata(self, hashes, deps):
         self.runtaskdeps = deps
         self.taskhash = hashes
-        self.file_checksum_values = checksums
 
     def dump_sigtask(self, fn, task, stampbase, runtime):
         k = fn + "." + task
@@ -241,7 +249,7 @@ class SignatureGeneratorBasic(SignatureGenerator):
                 os.fsync(fd)
             os.chmod(tmpfile, 0664)
             os.rename(tmpfile, sigfile)
-        except (OSError, IOError) as err:
+        except (OSError, IOError), err:
             try:
                 os.unlink(tmpfile)
             except OSError:

bitbake/lib/bb/taskdata.py

@@ -390,17 +390,6 @@ class TaskData:
                     reasons.append("%s PROVIDES %s but was skipped: %s" % (skipitem.pn, item, skipitem.skipreason))
         return reasons
 
-    def get_close_matches(self, item, provider_list):
-        import difflib
-        if self.skiplist:
-            skipped = []
-            for fn in self.skiplist:
-                skipped.append(self.skiplist[fn].pn)
-            full_list = provider_list + skipped
-        else:
-            full_list = provider_list
-        return difflib.get_close_matches(item, full_list, cutoff=0.7)
-
     def add_provider(self, cfgData, dataCache, item):
         try:
             self.add_provider_internal(cfgData, dataCache, item)
@@ -422,7 +411,7 @@ class TaskData:
             return
 
         if not item in dataCache.providers:
-            bb.event.fire(bb.event.NoProvider(item, dependees=self.get_dependees_str(item), reasons=self.get_reasons(item), close_matches=self.get_close_matches(item, dataCache.providers.keys())), cfgData)
+            bb.event.fire(bb.event.NoProvider(item, dependees=self.get_dependees_str(item), reasons=self.get_reasons(item)), cfgData)
             raise bb.providers.NoProvider(item)
 
         if self.have_build_target(item):

bitbake/lib/bb/tests/data.py

@@ -27,21 +27,21 @@ import bb.data
 class DataExpansions(unittest.TestCase):
     def setUp(self):
         self.d = bb.data.init()
-        self.d["foo"] = "value_of_foo"
-        self.d["bar"] = "value_of_bar"
-        self.d["value_of_foo"] = "value_of_'value_of_foo'"
+        self.d["foo"] = "value of foo"
+        self.d["bar"] = "value of bar"
+        self.d["value of foo"] = "value of 'value of foo'"
 
     def test_one_var(self):
         val = self.d.expand("${foo}")
-        self.assertEqual(str(val), "value_of_foo")
+        self.assertEqual(str(val), "value of foo")
 
     def test_indirect_one_var(self):
         val = self.d.expand("${${foo}}")
-        self.assertEqual(str(val), "value_of_'value_of_foo'")
+        self.assertEqual(str(val), "value of 'value of foo'")
 
     def test_indirect_and_another(self):
         val = self.d.expand("${${foo}} ${bar}")
-        self.assertEqual(str(val), "value_of_'value_of_foo' value_of_bar")
+        self.assertEqual(str(val), "value of 'value of foo' value of bar")
 
     def test_python_snippet(self):
         val = self.d.expand("${@5*12}")
@@ -49,11 +49,11 @@ class DataExpansions(unittest.TestCase):
 
     def test_expand_in_python_snippet(self):
         val = self.d.expand("${@'boo ' + '${foo}'}")
-        self.assertEqual(str(val), "boo value_of_foo")
+        self.assertEqual(str(val), "boo value of foo")
 
     def test_python_snippet_getvar(self):
         val = self.d.expand("${@d.getVar('foo', True) + ' ${bar}'}")
-        self.assertEqual(str(val), "value_of_foo value_of_bar")
+        self.assertEqual(str(val), "value of foo value of bar")
 
     def test_python_snippet_syntax_error(self):
         self.d.setVar("FOO", "${@foo = 5}")
@@ -70,7 +70,7 @@ class DataExpansions(unittest.TestCase):
 
     def test_value_containing_value(self):
         val = self.d.expand("${@d.getVar('foo', True) + ' ${bar}'}")
-        self.assertEqual(str(val), "value_of_foo value_of_bar")
+        self.assertEqual(str(val), "value of foo value of bar")
 
     def test_reference_undefined_var(self):
         val = self.d.expand("${undefinedvar} meh")
@@ -109,7 +109,7 @@ class DataExpansions(unittest.TestCase):
 
     def test_rename(self):
         self.d.renameVar("foo", "newfoo")
-        self.assertEqual(self.d.getVar("newfoo"), "value_of_foo")
+        self.assertEqual(self.d.getVar("newfoo"), "value of foo")
         self.assertEqual(self.d.getVar("foo"), None)
 
     def test_deletion(self):
@@ -118,17 +118,17 @@ class DataExpansions(unittest.TestCase):
 
     def test_keys(self):
         keys = self.d.keys()
-        self.assertEqual(keys, ['value_of_foo', 'foo', 'bar'])
+        self.assertEqual(keys, ['value of foo', 'foo', 'bar'])
 
 class TestNestedExpansions(unittest.TestCase):
     def setUp(self):
         self.d = bb.data.init()
         self.d["foo"] = "foo"
         self.d["bar"] = "bar"
-        self.d["value_of_foobar"] = "187"
+        self.d["value of foobar"] = "187"
 
     def test_refs(self):
-        val = self.d.expand("${value_of_${foo}${bar}}")
+        val = self.d.expand("${value of ${foo}${bar}}")
         self.assertEqual(str(val), "187")
 
     #def test_python_refs(self):
@@ -154,11 +154,11 @@ class TestNestedExpansions(unittest.TestCase):
     #    self.assertEqual(str(val), str(depth + 1))
 
     def test_mixed(self):
-        val = self.d.expand("${value_of_${@('${foo}'+'bar')[0:3]}${${@'BAR'.lower()}}}")
+        val = self.d.expand("${value of ${@('${foo}'+'bar')[0:3]}${${@'BAR'.lower()}}}")
         self.assertEqual(str(val), "187")
 
     def test_runtime(self):
-        val = self.d.expand("${${@'value_of' + '_f'+'o'+'o'+'b'+'a'+'r'}}")
+        val = self.d.expand("${${@'value of' + ' f'+'o'+'o'+'b'+'a'+'r'}}")
         self.assertEqual(str(val), "187")
 
 class TestMemoize(unittest.TestCase):

bitbake/lib/bb/tinfoil.py

@@ -25,8 +25,7 @@ import bb.cache
 import bb.cooker
 import bb.providers
 import bb.utils
-from bb.cooker import state, BBCooker
-from bb.cookerdata import CookerConfiguration, ConfigParameters
+from bb.cooker import state
 import bb.fetch2
 
 class Tinfoil:
@@ -44,12 +43,13 @@ class Tinfoil:
         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)
-        self.cooker = BBCooker(self.config)
-        self.config_data = self.cooker.data
+        initialenv = os.environ.copy()
+        bb.utils.clean_environment()
+        self.config = TinfoilConfig(parse_only=True)
+        self.cooker = bb.cooker.BBCooker(self.config,
+                                            self.register_idle_function,
+                                            initialenv)
+        self.config_data = self.cooker.configuration.data
         bb.providers.logger.setLevel(logging.ERROR)
         self.cooker_data = None
 
@@ -71,26 +71,30 @@ class Tinfoil:
         self.logger.setLevel(logging.INFO)
         sys.stderr.write("done.\n")
 
-        self.cooker_data = self.cooker.recipecache
+        self.cooker_data = self.cooker.status
 
     def prepare(self, config_only = False):
         if not self.cooker_data:
             if config_only:
                 self.cooker.parseConfiguration()
-                self.cooker_data = self.cooker.recipecache
+                self.cooker_data = self.cooker.status
             else:
                 self.parseRecipes()
 
-class TinfoilConfigParameters(ConfigParameters):
 
+class TinfoilConfig(object):
     def __init__(self, **options):
-        self.initial_options = options
-        super(TinfoilConfigParameters, self).__init__()
+        self.pkgs_to_build = []
+        self.debug_domains = []
+        self.extra_assume_provided = []
+        self.prefile = []
+        self.postfile = []
+        self.debug = 0
+        self.__dict__.update(options)
 
-    def parseCommandLine(self):
-        class DummyOptions:
-            def __init__(self, initial_options):
-                for key, val in initial_options.items():
-                    setattr(self, key, val)
+    def __getattr__(self, attribute):
+        try:
+            return super(TinfoilConfig, self).__getattribute__(attribute)
+        except AttributeError:
+            return None
 
-        return DummyOptions(self.initial_options), None

bitbake/lib/bb/ui/buildinfohelper.py

@@ -1,723 +0,0 @@
-#
-# BitBake ToasterUI Implementation
-#
-# Copyright (C) 2013        Intel Corporation
-#
-# 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 datetime
-import sys
-import bb
-import re
-import subprocess
-
-
-os.environ.setdefault("DJANGO_SETTINGS_MODULE", "toaster.toastermain.settings")
-
-import toaster.toastermain.settings as toaster_django_settings
-from toaster.orm.models import Build, Task, Recipe, Layer_Version, Layer, Target, LogMessage
-from toaster.orm.models import Target_Package, Build_Package, Variable, Build_File
-from toaster.orm.models import Task_Dependency, Build_Package_Dependency, Target_Package_Dependency, Recipe_Dependency
-from bb.msg import BBLogFormatter as format
-
-class ORMWrapper(object):
-    """ This class creates the dictionaries needed to store information in the database
-        following the format defined by the Django models. It is also used to save this
-        information in the database.
-    """
-
-    def __init__(self):
-        pass
-
-
-    def create_build_object(self, build_info):
-
-        build = Build.objects.create(
-                                    machine=build_info['machine'],
-                                    image_fstypes=build_info['image_fstypes'],
-                                    distro=build_info['distro'],
-                                    distro_version=build_info['distro_version'],
-                                    started_on=build_info['started_on'],
-                                    completed_on=build_info['completed_on'],
-                                    cooker_log_path=build_info['cooker_log_path'],
-                                    build_name=build_info['build_name'],
-                                    bitbake_version=build_info['bitbake_version'])
-
-        return build
-
-    def create_target_objects(self, target_info):
-        targets = []
-        for tgt_name in target_info['targets']:
-            tgt_object = Target.objects.create( build = target_info['build'],
-                                    target = tgt_name,
-                                    is_image = False,
-                                    file_name = "",
-                                    file_size = 0);
-            targets.append(tgt_object)
-        return targets
-
-    def update_build_object(self, build, errors, warnings, taskfailures):
-
-        outcome = Build.SUCCEEDED
-        if errors or taskfailures:
-            outcome = Build.FAILED
-
-        build.completed_on = datetime.datetime.now()
-        build.errors_no = errors
-        build.warnings_no = warnings
-        build.outcome = outcome
-        build.save()
-
-
-    def get_update_task_object(self, task_information):
-        task_object, created = Task.objects.get_or_create(
-                                build=task_information['build'],
-                                recipe=task_information['recipe'],
-                                task_name=task_information['task_name'],
-                                )
-
-        for v in vars(task_object):
-            if v in task_information.keys():
-                vars(task_object)[v] = task_information[v]
-        # if we got covered by a setscene task, we're SSTATE
-        if task_object.outcome == Task.OUTCOME_COVERED and 1 == Task.objects.filter(task_executed=True, build = task_object.build, recipe = task_object.recipe, task_name=task_object.task_name+"_setscene").count():
-            task_object.outcome = Task.OUTCOME_SSTATE
-
-        # mark down duration if we have a start time
-        if 'start_time' in task_information.keys():
-            duration = datetime.datetime.now() - task_information['start_time']
-            task_object.elapsed_time = duration.total_seconds()
-
-        task_object.save()
-        return task_object
-
-
-    def get_update_recipe_object(self, recipe_information):
-
-        recipe_object, created = Recipe.objects.get_or_create(
-                                         layer_version=recipe_information['layer_version'],
-                                         file_path=recipe_information['file_path'])
-
-        for v in vars(recipe_object):
-            if v in recipe_information.keys():
-                vars(recipe_object)[v] = recipe_information[v]
-
-        recipe_object.save()
-
-        return recipe_object
-
-    def get_layer_version_object(self, layer_version_information):
-
-        layer_version_object = Layer_Version.objects.get_or_create(
-                                    layer = layer_version_information['layer'],
-                                    branch = layer_version_information['branch'],
-                                    commit = layer_version_information['commit'],
-                                    priority = layer_version_information['priority']
-                                    )
-
-        layer_version_object[0].save()
-
-        return layer_version_object[0]
-
-    def get_update_layer_object(self, layer_information):
-
-        layer_object = Layer.objects.get_or_create(
-                                name=layer_information['name'],
-                                local_path=layer_information['local_path'],
-                                layer_index_url=layer_information['layer_index_url'])
-        layer_object[0].save()
-
-        return layer_object[0]
-
-
-    def save_target_package_information(self, target_obj, packagedict, bldpkgs, recipes):
-        for p in packagedict:
-            packagedict[p]['object'] = Target_Package.objects.create( target = target_obj,
-                                        name = p,
-                                        size = packagedict[p]['size'])
-            if p in bldpkgs:
-                packagedict[p]['object'].version = bldpkgs[p]['version']
-                packagedict[p]['object'].recipe =  recipes[bldpkgs[p]['pn']]
-                packagedict[p]['object'].save()
-
-        for p in packagedict:
-            for (px,deptype) in packagedict[p]['depends']:
-                Target_Package_Dependency.objects.create( package = packagedict[p]['object'],
-                                        depends_on = packagedict[px]['object'],
-                                        dep_type = deptype);
-
-
-    def create_logmessage(self, log_information):
-        log_object = LogMessage.objects.create(
-                        build = log_information['build'],
-                        level = log_information['level'],
-                        message = log_information['message'])
-
-        for v in vars(log_object):
-            if v in log_information.keys():
-                vars(log_object)[v] = log_information[v]
-
-        return log_object.save()
-
-
-    def save_build_package_information(self, build_obj, package_info, recipes):
-        # create and save the object
-        bp_object = Build_Package.objects.create( build = build_obj,
-                                       recipe = recipes[package_info['PN']],
-                                       name = package_info['PKG'],
-                                       version = package_info['PKGV'],
-                                       revision = package_info['PKGR'],
-                                       summary = package_info['SUMMARY'],
-                                       description = package_info['DESCRIPTION'],
-                                       size = package_info['PKGSIZE'],
-                                       section = package_info['SECTION'],
-                                       license = package_info['LICENSE'],
-                                       )
-        # save any attached file information
-        for path in package_info['FILES_INFO']:
-                fo = Build_File.objects.create( bpackage = bp_object,
-                                        path = path,
-                                        size = package_info['FILES_INFO'][path] )
-
-        # save soft dependency information
-        if 'RDEPENDS' in package_info and package_info['RDEPENDS']:
-            for p in bb.utils.explode_deps(package_info['RDEPENDS']):
-                Build_Package_Dependency.objects.get_or_create( package = bp_object,
-                    depends_on = p, dep_type = Build_Package_Dependency.TYPE_RDEPENDS)
-        if 'RPROVIDES' in package_info and package_info['RPROVIDES']:
-            for p in bb.utils.explode_deps(package_info['RPROVIDES']):
-                Build_Package_Dependency.objects.get_or_create( package = bp_object,
-                    depends_on = p, dep_type = Build_Package_Dependency.TYPE_RPROVIDES)
-        if 'RRECOMMENDS' in package_info and package_info['RRECOMMENDS']:
-            for p in bb.utils.explode_deps(package_info['RRECOMMENDS']):
-                Build_Package_Dependency.objects.get_or_create( package = bp_object,
-                    depends_on = p, dep_type = Build_Package_Dependency.TYPE_RRECOMMENDS)
-        if 'RSUGGESTS' in package_info and package_info['RSUGGESTS']:
-            for p in bb.utils.explode_deps(package_info['RSUGGESTS']):
-                Build_Package_Dependency.objects.get_or_create( package = bp_object,
-                    depends_on = p, dep_type = Build_Package_Dependency.TYPE_RSUGGESTS)
-        if 'RREPLACES' in package_info and package_info['RREPLACES']:
-            for p in bb.utils.explode_deps(package_info['RREPLACES']):
-                Build_Package_Dependency.objects.get_or_create( package = bp_object,
-                    depends_on = p, dep_type = Build_Package_Dependency.TYPE_RREPLACES)
-        if 'RCONFLICTS' in package_info and package_info['RCONFLICTS']:
-            for p in bb.utils.explode_deps(package_info['RCONFLICTS']):
-                Build_Package_Dependency.objects.get_or_create( package = bp_object,
-                    depends_on = p, dep_type = Build_Package_Dependency.TYPE_RCONFLICTS)
-
-        return bp_object
-
-    def save_build_variables(self, build_obj, vardump):
-        for k in vardump:
-            if not bool(vardump[k]['func']):
-                value = vardump[k]['v'];
-                if value is None:
-                    value = ''
-                desc = vardump[k]['doc'];
-                if desc is None:
-                    var_words = [word for word in k.split('_')]
-                    root_var = "_".join([word for word in var_words if word.isupper()])
-                    if root_var and root_var != k and root_var in vardump:
-                        desc = vardump[root_var]['doc']
-                if desc is None:
-                    desc = ''
-                Variable.objects.create( build = build_obj,
-                    variable_name = k,
-                    variable_value = value,
-                    description = desc)
-
-
-class BuildInfoHelper(object):
-    """ This class gathers the build information from the server and sends it
-        towards the ORM wrapper for storing in the database
-        It is instantiated once per build
-        Keeps in memory all data that needs matching before writing it to the database
-    """
-
-    def __init__(self, server, has_build_history = False):
-        self._configure_django()
-        self.internal_state = {}
-        self.task_order = 0
-        self.server = server
-        self.orm_wrapper = ORMWrapper()
-        self.has_build_history = has_build_history
-        self.tmp_dir = self.server.runCommand(["getVariable", "TMPDIR"])[0]
-
-    def _configure_django(self):
-        # Add toaster to sys path for importing modules
-        sys.path.append(os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'toaster'))
-
-    ###################
-    ## methods to convert event/external info into objects that the ORM layer uses
-
-    def _get_layer_dict(self, layer_path):
-
-        layer_info = {}
-        layer_name = layer_path.split('/')[-1]
-        layer_url = 'http://layers.openembedded.org/layerindex/layer/{layer}/'
-        layer_url_name = self._get_url_map_name(layer_name)
-
-        layer_info['name'] = layer_name
-        layer_info['local_path'] = layer_path
-        layer_info['layer_index_url'] = layer_url.format(layer=layer_url_name)
-
-        return layer_info
-
-    def _get_url_map_name(self, layer_name):
-        """ Some layers have a different name on openembedded.org site,
-            this method returns the correct name to use in the URL
-        """
-
-        url_name = layer_name
-        url_mapping = {'meta': 'openembedded-core'}
-
-        for key in url_mapping.keys():
-            if key == layer_name:
-                url_name = url_mapping[key]
-
-        return url_name
-
-    def _get_layer_information(self):
-
-        layer_info = {}
-
-        return layer_info
-
-    def _get_layer_version_information(self, layer_object):
-
-        layer_version_info = {}
-        layer_version_info['build'] = self.internal_state['build']
-        layer_version_info['layer'] = layer_object
-        layer_version_info['branch'] = self._get_git_branch(layer_object.local_path)
-        layer_version_info['commit'] = self._get_git_revision(layer_object.local_path)
-        layer_version_info['priority'] = 0
-
-        return layer_version_info
-
-
-    def _get_git_branch(self, layer_path):
-        branch = subprocess.Popen("git symbolic-ref HEAD 2>/dev/null ", cwd=layer_path, shell=True, stdout=subprocess.PIPE).communicate()[0]
-        branch = branch.replace('refs/heads/', '').rstrip()
-        return branch
-
-    def _get_git_revision(self, layer_path):
-        revision = subprocess.Popen("git rev-parse HEAD 2>/dev/null ", cwd=layer_path, shell=True, stdout=subprocess.PIPE).communicate()[0].rstrip()
-        return revision
-
-
-    def _get_build_information(self):
-        build_info = {}
-        # Generate an identifier for each new build
-
-        build_info['machine'] = self.server.runCommand(["getVariable", "MACHINE"])[0]
-        build_info['distro'] = self.server.runCommand(["getVariable", "DISTRO"])[0]
-        build_info['distro_version'] = self.server.runCommand(["getVariable", "DISTRO_VERSION"])[0]
-        build_info['started_on'] = datetime.datetime.now()
-        build_info['completed_on'] = datetime.datetime.now()
-        build_info['image_fstypes'] = self._remove_redundant(self.server.runCommand(["getVariable", "IMAGE_FSTYPES"])[0] or "")
-        build_info['cooker_log_path'] = self.server.runCommand(["getVariable", "BB_CONSOLELOG"])[0]
-        build_info['build_name'] = self.server.runCommand(["getVariable", "BUILDNAME"])[0]
-        build_info['bitbake_version'] = self.server.runCommand(["getVariable", "BB_VERSION"])[0]
-
-        return build_info
-
-    def _get_task_information(self, event, recipe):
-
-
-        task_information = {}
-        task_information['build'] = self.internal_state['build']
-        task_information['outcome'] = Task.OUTCOME_NA
-        task_information['recipe'] = recipe
-        task_information['task_name'] = event.taskname
-        try:
-            # some tasks don't come with a hash. and that's ok
-            task_information['sstate_checksum'] = event.taskhash
-        except AttributeError:
-            pass
-        return task_information
-
-    def _get_layer_version_for_path(self, path):
-        def _slkey(layer_version):
-            return len(layer_version.layer.local_path)
-
-        # Heuristics: we always match recipe to the deepest layer path that
-        # we can match to the recipe file path
-        for bl in sorted(self.internal_state['layer_versions'], reverse=True, key=_slkey):
-            if (path.startswith(bl.layer.local_path)):
-                return bl
-
-        #TODO: if we get here, we didn't read layers correctly
-        assert False
-        return None
-
-    def _get_recipe_information_from_build_event(self, event):
-
-        layer_version_obj = self._get_layer_version_for_path(re.split(':', event.taskfile)[-1])
-
-        recipe_info = {}
-        recipe_info['layer_version'] = layer_version_obj
-        recipe_info['file_path'] = re.split(':', event.taskfile)[-1]
-
-        return recipe_info
-
-    def _get_task_build_stats(self, task_object):
-        bs_path = self._get_path_information(task_object)
-        for bp in bs_path:  # TODO: split for each target
-            task_build_stats = self._get_build_stats_from_file(bp, task_object.task_name)
-
-        return task_build_stats
-
-    def _get_path_information(self, task_object):
-        build_stats_format = "{tmpdir}/buildstats/{target}-{machine}/{buildname}/{package}/"
-        build_stats_path = []
-
-        for t in self.internal_state['targets']:
-            target = t.target
-            machine = self.internal_state['build'].machine
-            buildname = self.internal_state['build'].build_name
-            package = task_object.recipe.name + "-" + task_object.recipe.version.strip(":")
-
-            build_stats_path.append(build_stats_format.format(tmpdir=self.tmp_dir, target=target,
-                                                     machine=machine, buildname=buildname,
-                                                     package=package))
-
-        return build_stats_path
-
-    def _get_build_stats_from_file(self, bs_path, task_name):
-
-        task_bs_filename = str(bs_path) + str(task_name)
-        task_bs = open(task_bs_filename, 'r')
-
-        cpu_usage = 0
-        disk_io = 0
-        startio = ''
-        endio = ''
-
-        for line in task_bs.readlines():
-            if line.startswith('CPU usage: '):
-                cpu_usage = line[11:]
-            elif line.startswith('EndTimeIO: '):
-                endio = line[11:]
-            elif line.startswith('StartTimeIO: '):
-                startio = line[13:]
-
-        task_bs.close()
-
-        if startio and endio:
-            disk_io = int(endio.strip('\n ')) - int(startio.strip('\n '))
-
-        if cpu_usage:
-            cpu_usage = float(cpu_usage.strip('% \n'))
-
-        task_build_stats = {'cpu_usage': cpu_usage, 'disk_io': disk_io}
-
-        return task_build_stats
-
-    def _remove_redundant(self, string):
-        ret = []
-        for i in string.split():
-            if i not in ret:
-                ret.append(i)
-        return " ".join(ret)
-
-
-    ################################
-    ## external available methods to store information
-
-    def store_layer_info(self):
-        layers = self.server.runCommand(["getVariable", "BBLAYERS"])[0].strip().split(" ")
-        self.internal_state['layers'] = []
-        for layer_path in { l for l in layers if len(l) }:
-            layer_information = self._get_layer_dict(layer_path)
-            self.internal_state['layers'].append(self.orm_wrapper.get_update_layer_object(layer_information))
-
-    def store_started_build(self, event):
-
-        build_information = self._get_build_information()
-
-        build_obj = self.orm_wrapper.create_build_object(build_information)
-        self.internal_state['build'] = build_obj
-
-        # create target information
-        target_information = {}
-        target_information['targets'] = event.getPkgs()
-        target_information['build'] = build_obj
-
-        self.internal_state['targets'] = self.orm_wrapper.create_target_objects(target_information)
-
-        # Load layer information for the build
-        self.internal_state['layer_versions'] = []
-        for layer_object in self.internal_state['layers']:
-            layer_version_information = self._get_layer_version_information(layer_object)
-            self.internal_state['layer_versions'].append(self.orm_wrapper.get_layer_version_object(layer_version_information))
-
-        del self.internal_state['layers']
-        # Save build configuration
-        self.orm_wrapper.save_build_variables(build_obj, self.server.runCommand(["getAllKeysWithFlags", ["doc", "func"]])[0])
-
-
-    def update_build_information(self, event, errors, warnings, taskfailures):
-        if 'build' in self.internal_state:
-            self.orm_wrapper.update_build_object(self.internal_state['build'], errors, warnings, taskfailures)
-
-    def store_started_task(self, event):
-        identifier = event.taskfile + event.taskname
-
-        recipe_information = self._get_recipe_information_from_build_event(event)
-        recipe = self.orm_wrapper.get_update_recipe_object(recipe_information)
-
-        task_information = self._get_task_information(event, recipe)
-        task_information['outcome'] = Task.OUTCOME_NA
-
-        if isinstance(event, bb.runqueue.runQueueTaskSkipped):
-            task_information['task_executed'] = False
-            if event.reason == "covered":
-                task_information['outcome'] = Task.OUTCOME_COVERED
-            if event.reason == "existing":
-                task_information['outcome'] = Task.OUTCOME_EXISTING
-        else:
-            task_information['task_executed'] = True
-            if 'noexec' in vars(event) and event.noexec == True:
-                task_information['script_type'] = Task.CODING_NOEXEC
-
-        self.task_order += 1
-        task_information['order'] = self.task_order
-        task_obj = self.orm_wrapper.get_update_task_object(task_information)
-
-        self.internal_state[identifier] = {'start_time': datetime.datetime.now()}
-
-    def update_and_store_task(self, event):
-        identifier = event.taskfile + event.taskname
-        recipe_information = self._get_recipe_information_from_build_event(event)
-        recipe = self.orm_wrapper.get_update_recipe_object(recipe_information)
-        task_information = self._get_task_information(event,recipe)
-        try:
-            task_information['start_time'] = self.internal_state[identifier]['start_time']
-        except:
-            pass
-
-        if 'logfile' in vars(event):
-            task_information['logfile'] = event.logfile
-
-        if '_message' in vars(event):
-            task_information['message'] = event._message
-
-        if 'taskflags' in vars(event):
-            # with TaskStarted, we get even more information
-            if 'python' in event.taskflags.keys() and event.taskflags['python'] == '1':
-                task_information['script_type'] = Task.CODING_PYTHON
-            else:
-                task_information['script_type'] = Task.CODING_SHELL
-
-        if isinstance(event, (bb.runqueue.runQueueTaskCompleted, bb.runqueue.sceneQueueTaskCompleted)):
-            task_information['outcome'] = Task.OUTCOME_SUCCESS
-            task_build_stats = self._get_task_build_stats(self.orm_wrapper.get_update_task_object(task_information))
-            task_information['cpu_usage'] = task_build_stats['cpu_usage']
-            task_information['disk_io'] = task_build_stats['disk_io']
-            del self.internal_state[identifier]
-
-        if isinstance(event, bb.runqueue.runQueueTaskFailed):
-            task_information['outcome'] = Task.OUTCOME_FAILED
-            del self.internal_state[identifier]
-
-        self.orm_wrapper.get_update_task_object(task_information)
-
-
-    def read_target_package_dep_data(self, event):
-        # for all targets
-        for target in self.internal_state['targets']:
-            # verify that we have something to read
-            if not target.is_image or not self.has_build_history:
-                print "not collecting package info ", target.is_image, self.has_build_history
-                break
-
-            # TODO this is a temporary replication of the code in buildhistory.bbclass
-            # This MUST be changed to query the actual BUILD_DIR_IMAGE in the target context when
-            # the capability will be implemented in Bitbake
-
-            MACHINE_ARCH, error = self.server.runCommand(['getVariable', 'MACHINE_ARCH'])
-            TCLIBC, error = self.server.runCommand(['getVariable', 'TCLIBC'])
-            BUILDHISTORY_DIR, error = self.server.runCommand(['getVariable', 'BUILDHISTORY_DIR'])
-            BUILDHISTORY_DIR_IMAGE = "%s/images/%s/%s/%s" % (BUILDHISTORY_DIR, MACHINE_ARCH, TCLIBC, target.target)
-
-            self.internal_state['packages'] = {}
-
-            with open("%s/installed-package-sizes.txt" % BUILDHISTORY_DIR_IMAGE, "r") as fin:
-                for line in fin:
-                    line = line.rstrip(";")
-                    psize, px = line.split("\t")
-                    punit, pname = px.split(" ")
-                    self.internal_state['packages'][pname.strip()] = {'size':int(psize)*1024, 'depends' : []}
-
-            with open("%s/depends.dot" % BUILDHISTORY_DIR_IMAGE, "r") as fin:
-                p = re.compile(r' -> ')
-                dot = re.compile(r'.*style=dotted')
-                for line in fin:
-                    line = line.rstrip(';')
-                    linesplit = p.split(line)
-                    if len(linesplit) == 2:
-                        pname = linesplit[0].rstrip('"').strip('"')
-                        dependsname = linesplit[1].split(" ")[0].strip().strip(";").strip('"').rstrip('"')
-                        deptype = Target_Package_Dependency.TYPE_DEPENDS
-                        if dot.match(line):
-                            deptype = Target_Package_Dependency.TYPE_RECOMMENDS
-                        if not pname in self.internal_state['packages']:
-                            self.internal_state['packages'][pname] = {'size': 0, 'depends' : []}
-                        if not dependsname in self.internal_state['packages']:
-                            self.internal_state['packages'][dependsname] = {'size': 0, 'depends' : []}
-                        self.internal_state['packages'][pname]['depends'].append((dependsname, deptype))
-
-            self.orm_wrapper.save_target_package_information(target,
-                        self.internal_state['packages'],
-                        self.internal_state['bldpkgs'], self.internal_state['recipes'])
-
-
-    def store_dependency_information(self, event):
-        # save layer version priorities
-        if 'layer-priorities' in event._depgraph.keys():
-            for lv in event._depgraph['layer-priorities']:
-                (name, path, regexp, priority) = lv
-                layer_version_obj = self._get_layer_version_for_path(path[1:]) # paths start with a ^
-                assert layer_version_obj is not None
-                layer_version_obj.priority = priority
-                layer_version_obj.save()
-
-        # save build time package information
-        self.internal_state['bldpkgs'] = {}
-        for pkg  in event._depgraph['packages']:
-            self.internal_state['bldpkgs'][pkg] = event._depgraph['packages'][pkg]
-
-        # save recipe information
-        self.internal_state['recipes'] = {}
-        for pn in event._depgraph['pn']:
-
-            file_name = re.split(':', event._depgraph['pn'][pn]['filename'])[-1]
-            layer_version_obj = self._get_layer_version_for_path(re.split(':', file_name)[-1])
-
-            assert layer_version_obj is not None
-
-            recipe_info = {}
-            recipe_info['name'] = pn
-            recipe_info['version'] = event._depgraph['pn'][pn]['version']
-            recipe_info['layer_version'] = layer_version_obj
-            recipe_info['summary'] = event._depgraph['pn'][pn]['summary']
-            recipe_info['license'] = event._depgraph['pn'][pn]['license']
-            recipe_info['description'] = event._depgraph['pn'][pn]['description']
-            recipe_info['section'] = event._depgraph['pn'][pn]['section']
-            recipe_info['licensing_info'] = 'Not Available'
-            recipe_info['homepage'] = event._depgraph['pn'][pn]['homepage']
-            recipe_info['bugtracker'] = event._depgraph['pn'][pn]['bugtracker']
-            recipe_info['author'] = 'Not Available'
-            recipe_info['file_path'] = file_name
-            recipe = self.orm_wrapper.get_update_recipe_object(recipe_info)
-            if 'inherits' in event._depgraph['pn'][pn].keys():
-                recipe.is_image = True in map(lambda x: x.endswith('image.bbclass'), event._depgraph['pn'][pn]['inherits'])
-            else:
-                recipe.is_image = False
-            if recipe.is_image:
-                for t in self.internal_state['targets']:
-                    if pn == t.target:
-                        t.is_image = True
-                        t.save()
-            self.internal_state['recipes'][pn] = recipe
-
-        # save recipe dependency
-        # buildtime
-        for recipe in event._depgraph['depends']:
-            try:
-                target = self.internal_state['recipes'][recipe]
-                for dep in event._depgraph['depends'][recipe]:
-                    dependency = self.internal_state['recipes'][dep]
-                    Recipe_Dependency.objects.get_or_create( recipe = target,
-                            depends_on = dependency, dep_type = Recipe_Dependency.TYPE_DEPENDS)
-            except KeyError:    # we'll not get recipes for key w/ values listed in ASSUME_PROVIDED
-                pass
-
-        # runtime
-        for recipe in event._depgraph['rdepends-pn']:
-            try:
-                target = self.internal_state['recipes'][recipe]
-                for dep in event._depgraph['rdepends-pn'][recipe]:
-                    dependency = self.internal_state['recipes'][dep]
-                    Recipe_Dependency.objects.get_or_create( recipe = target,
-                            depends_on = dependency, dep_type = Recipe_Dependency.TYPE_RDEPENDS)
-
-            except KeyError:    # we'll not get recipes for key w/ values listed in ASSUME_PROVIDED
-                pass
-
-        # save all task information
-        def _save_a_task(taskdesc):
-            spec = re.split(r'\.', taskdesc);
-            pn = ".".join(spec[0:-1])
-            taskname = spec[-1]
-            e = event
-            e.taskname = pn
-            recipe = self.internal_state['recipes'][pn]
-            task_info = self._get_task_information(e, recipe)
-            task_info['task_name'] = taskname
-            task_obj = self.orm_wrapper.get_update_task_object(task_info)
-            return task_obj
-
-        for taskdesc in event._depgraph['tdepends']:
-            target = _save_a_task(taskdesc)
-            for taskdesc1 in event._depgraph['tdepends'][taskdesc]:
-                dep = _save_a_task(taskdesc1)
-                Task_Dependency.objects.get_or_create( task = target, depends_on = dep )
-
-    def store_build_package_information(self, event):
-        package_info = event.data
-        self.orm_wrapper.save_build_package_information(self.internal_state['build'],
-                            package_info,
-                            self.internal_state['recipes'],
-                            )
-
-    def _store_log_information(self, level, text):
-        log_information = {}
-        log_information['build'] = self.internal_state['build']
-        log_information['level'] = level
-        log_information['message'] = text
-        self.orm_wrapper.create_logmessage(log_information)
-
-    def store_log_info(self, text):
-        self._store_log_information(LogMessage.INFO, text)
-
-    def store_log_warn(self, text):
-        self._store_log_information(LogMessage.WARNING, text)
-
-    def store_log_error(self, text):
-        self._store_log_information(LogMessage.ERROR, text)
-
-    def store_log_event(self, event):
-        # look up license files info from insane.bbclass
-        m = re.match("([^:]*): md5 checksum matched for ([^;]*)", event.msg)
-        if m:
-            (pn, fn) = m.groups()
-            self.internal_state['recipes'][pn].licensing_info = fn
-            self.internal_state['recipes'][pn].save()
-
-        if event.levelno < format.WARNING:
-            return
-        if not 'build' in self.internal_state:
-            return
-        log_information = {}
-        log_information['build'] = self.internal_state['build']
-        if event.levelno >= format.ERROR:
-            log_information['level'] = LogMessage.ERROR
-        elif event.levelno == format.WARNING:
-            log_information['level'] = LogMessage.WARNING
-        log_information['message'] = event.msg
-        log_information['pathname'] = event.pathname
-        log_information['lineno'] = event.lineno
-        self.orm_wrapper.create_logmessage(log_information)
-

bitbake/lib/bb/ui/crumbs/builder.py

@@ -30,8 +30,7 @@ import shlex
 import re
 import logging
 import sys
-import signal
-import time
+from bb.ui.crumbs.template import TemplateMgr
 from bb.ui.crumbs.imageconfigurationpage import ImageConfigurationPage
 from bb.ui.crumbs.recipeselectionpage import RecipeSelectionPage
 from bb.ui.crumbs.packageselectionpage import PackageSelectionPage
@@ -109,8 +108,6 @@ class Configuration:
         self.extra_setting = {}
         self.toolchain_build = False
         self.image_fstypes = ""
-        self.image_size = None
-        self.image_packages = []
         # bblayers.conf
         self.layers = []
         # image/recipes/packages
@@ -193,12 +190,41 @@ class Configuration:
         self.split_proxy("socks", params["socks_proxy"])
         self.split_proxy("cvs", params["cvs_proxy_host"] + ":" + params["cvs_proxy_port"])
 
-    def save(self, handler, defaults=False):
+    def load(self, template):
+        try:
+            self.image_rootfs_size = int(template.getVar("IMAGE_ROOTFS_SIZE"))
+        except:
+            pass
+        try:
+            self.image_extra_size = int(template.getVar("IMAGE_EXTRA_SPACE"))
+        except:
+            pass
+        # image_overhead_factor is read-only.
+        self.incompat_license = template.getVar("INCOMPATIBLE_LICENSE")
+        self.curr_sdk_machine = template.getVar("SDKMACHINE")
+        self.extra_setting = eval(template.getVar("EXTRA_SETTING"))
+        self.toolchain_build = eval(template.getVar("TOOLCHAIN_BUILD"))
+        self.image_fstypes = template.getVar("IMAGE_FSTYPES")
+        # image/recipes/packages
+        self.selected_image = template.getVar("__SELECTED_IMAGE__")
+        self.selected_recipes = template.getVar("DEPENDS").split()
+        self.selected_packages = template.getVar("IMAGE_INSTALL").split()
+        # proxy
+        self.enable_proxy = eval(template.getVar("enable_proxy"))
+        self.same_proxy = eval(template.getVar("use_same_proxy"))
+        self.split_proxy("http", template.getVar("http_proxy"))
+        self.split_proxy("https", template.getVar("https_proxy"))
+        self.split_proxy("ftp", template.getVar("ftp_proxy"))
+        self.split_proxy("socks", template.getVar("all_proxy"))
+        self.split_proxy("cvs", template.getVar("CVS_PROXY_HOST") + ":" + template.getVar("CVS_PROXY_PORT"))
+
+    def save(self, handler, template, defaults=False):
+        template.setVar("VERSION", "%s" % hobVer)
         # bblayers.conf
         handler.set_var_in_file("BBLAYERS", self.layers, "bblayers.conf")
         # local.conf
         if not defaults:
-            handler.early_assign_var_in_file("MACHINE", self.curr_mach, "local.conf")
+            handler.set_var_in_file("MACHINE", self.curr_mach, "local.conf")
         handler.set_var_in_file("DISTRO", self.curr_distro, "local.conf")
         handler.set_var_in_file("DL_DIR", self.dldir, "local.conf")
         handler.set_var_in_file("SSTATE_DIR", self.sstatedir, "local.conf")
@@ -212,29 +238,29 @@ class Configuration:
         handler.set_var_in_file("PARALLEL_MAKE", "-j %s" % self.pmake, "local.conf")
         handler.set_var_in_file("BB_NUMBER_THREADS", self.bbthread, "local.conf")
         handler.set_var_in_file("PACKAGE_CLASSES", " ".join(["package_" + i for i in self.curr_package_format.split()]), "local.conf")
-        handler.set_var_in_file("IMAGE_ROOTFS_SIZE", self.image_rootfs_size, "local.conf")
-        handler.set_var_in_file("IMAGE_EXTRA_SPACE", self.image_extra_size, "local.conf")
-        handler.set_var_in_file("INCOMPATIBLE_LICENSE", self.incompat_license, "local.conf")
-        handler.set_var_in_file("SDKMACHINE", self.curr_sdk_machine, "local.conf")
+        template.setVar("IMAGE_ROOTFS_SIZE", self.image_rootfs_size)
+        template.setVar("IMAGE_EXTRA_SPACE", self.image_extra_size)
+        template.setVar("INCOMPATIBLE_LICENSE", self.incompat_license)
+        template.setVar("SDKMACHINE", self.curr_sdk_machine)
         handler.set_var_in_file("CONF_VERSION", self.conf_version, "local.conf")
         handler.set_var_in_file("LCONF_VERSION", self.lconf_version, "bblayers.conf")
-        handler.set_extra_config(self.extra_setting)
-        handler.set_var_in_file("TOOLCHAIN_BUILD", self.toolchain_build, "local.conf")
-        handler.set_var_in_file("IMAGE_FSTYPES", self.image_fstypes, "local.conf")
+        template.setVar("EXTRA_SETTING", self.extra_setting)
+        template.setVar("TOOLCHAIN_BUILD", self.toolchain_build)
+        template.setVar("IMAGE_FSTYPES", self.image_fstypes)
         if not defaults:
             # image/recipes/packages
-            handler.set_var_in_file("__SELECTED_IMAGE__", self.selected_image, "local.conf")
-            handler.set_var_in_file("DEPENDS", self.selected_recipes, "local.conf")
-            handler.set_var_in_file("IMAGE_INSTALL", self.user_selected_packages, "local.conf")
+            template.setVar("__SELECTED_IMAGE__", self.selected_image)
+            template.setVar("DEPENDS", self.selected_recipes)
+            template.setVar("IMAGE_INSTALL", self.user_selected_packages)
         # proxy
-        handler.set_var_in_file("enable_proxy", self.enable_proxy, "local.conf")
-        handler.set_var_in_file("use_same_proxy", self.same_proxy, "local.conf")
-        handler.set_var_in_file("http_proxy", self.combine_proxy("http"), "local.conf")
-        handler.set_var_in_file("https_proxy", self.combine_proxy("https"), "local.conf")
-        handler.set_var_in_file("ftp_proxy", self.combine_proxy("ftp"), "local.conf")
-        handler.set_var_in_file("all_proxy", self.combine_proxy("socks"), "local.conf")
-        handler.set_var_in_file("CVS_PROXY_HOST", self.combine_host_only("cvs"), "local.conf")
-        handler.set_var_in_file("CVS_PROXY_PORT", self.combine_port_only("cvs"), "local.conf")
+        template.setVar("enable_proxy", self.enable_proxy)
+        template.setVar("use_same_proxy", self.same_proxy)
+        template.setVar("http_proxy", self.combine_proxy("http"))
+        template.setVar("https_proxy", self.combine_proxy("https"))
+        template.setVar("ftp_proxy", self.combine_proxy("ftp"))
+        template.setVar("all_proxy", self.combine_proxy("socks"))
+        template.setVar("CVS_PROXY_HOST", self.combine_host_only("cvs"))
+        template.setVar("CVS_PROXY_PORT", self.combine_port_only("cvs"))
 
     def __str__(self):
         s = "VERSION: '%s', BBLAYERS: '%s', MACHINE: '%s', DISTRO: '%s', DL_DIR: '%s'," % \
@@ -379,6 +405,8 @@ class Builder(gtk.Window):
         # handler
         self.handler = hobHandler
 
+        self.template = None
+
         # logger
         self.logger = logging.getLogger("BitBake")
         self.consolelog = None
@@ -441,11 +469,8 @@ class Builder(gtk.Window):
         self.handler.connect("recipe-populated",         self.handler_recipe_populated_cb)
         self.handler.connect("package-populated",        self.handler_package_populated_cb)
 
-        self.handler.append_to_bbfiles("${TOPDIR}/recipes/images/*.bb")
         self.initiate_new_build_async()
 
-        signal.signal(signal.SIGINT, self.event_handle_SIGINT)
-
     def create_visual_elements(self):
         self.set_title("Hob")
         self.set_icon_name("applications-development")
@@ -513,7 +538,7 @@ class Builder(gtk.Window):
         if not self.display_sanity_check:
           func()
         else:
-          self.sanity_check_post_func = func
+          sanity_check_post_func = func
 
     def generate_configuration(self):
         if not self.sanity_checked:
@@ -521,11 +546,11 @@ class Builder(gtk.Window):
         self.handler.generate_configuration()
 
     def initiate_new_build_async(self):
-        self.configuration.selected_image = None
         self.switch_page(self.MACHINE_SELECTION)
         self.handler.init_cooker()
         self.handler.set_extra_inherit("image_types")
         self.generate_configuration()
+        self.load_template(TemplateMgr.convert_to_template_pathfilename("default", ".hob/"))
 
     def update_config_async(self):
         self.switch_page(self.MACHINE_SELECTION)
@@ -596,16 +621,6 @@ class Builder(gtk.Window):
                                     toolchain_packages,
                                     self.configuration.default_task)
 
-    def generate_new_image(self, image, description):
-        base_image = self.configuration.initial_selected_image
-        if base_image == self.recipe_model.__custom_image__:
-            base_image = None
-        packages = self.package_model.get_selected_packages()
-        self.handler.generate_new_image(image, base_image, packages, description)
-
-    def ensure_dir(self, directory):
-        self.handler.ensure_dir(directory)
-
     def get_parameters_sync(self):
         return self.handler.get_parameters()
 
@@ -618,6 +633,61 @@ class Builder(gtk.Window):
     def cancel_parse_sync(self):
         self.handler.cancel_parse()
 
+    def load_template(self, path):
+        if not os.path.isfile(path):
+            return False
+
+        self.template = TemplateMgr()
+        # check compatibility
+        tempVer = self.template.getVersion(path)
+        if not tempVer or int(tempVer) < hobVer:
+            self.template.destroy()
+            self.template = None
+            return False
+
+        try:
+            self.template.load(path)
+            self.configuration.load(self.template)
+        except Exception as e:
+            self.show_error_dialog("Hob Exception - %s" % (str(e)))
+            self.reset()
+        finally:
+            self.template.destroy()
+            self.template = None
+
+        for layer in self.configuration.layers:
+            if not os.path.exists(layer+'/conf/layer.conf'):
+                return False
+
+        self.set_user_config_extra()
+        return True
+
+    def save_template(self, path, defaults=False):
+        if path.rfind("/") == -1:
+            filename = "default"
+            path = "."
+        else:
+            filename = path[path.rfind("/") + 1:len(path)]
+            path = path[0:path.rfind("/")]
+
+        self.template = TemplateMgr()
+        try:
+            self.template.open(filename, path)
+            self.configuration.save(self.handler, self.template, defaults)
+
+            self.template.save()
+        except Exception as e:
+            self.show_error_dialog("Hob Exception - %s" % (str(e)))
+            self.reset()
+        finally:
+            self.template.destroy()
+            self.template = None
+
+    def save_defaults(self):
+        if not os.path.exists(".hob/"):
+            os.mkdir(".hob/")
+        self.save_template(".hob/default", True)
+
     def switch_page(self, next_step):
         # Main Workflow (Business Logic)
         self.nb.set_current_page(self.__step2page__[next_step])
@@ -700,11 +770,12 @@ class Builder(gtk.Window):
         self.handler.set_sdk_machine(self.configuration.curr_sdk_machine)
         self.handler.set_image_fstypes(self.configuration.image_fstypes)
         self.handler.set_extra_config(self.configuration.extra_setting)
-        self.handler.set_extra_inherit("packageinfo image_types")
+        self.handler.set_extra_inherit("packageinfo")
+        self.handler.set_extra_inherit("image_types")
         self.set_user_config_proxies()
 
     def set_user_config(self):
-        self.handler.reset_cooker()
+        self.handler.init_cooker()
         # set bb layers
         self.handler.set_bblayers(self.configuration.layers)
         # set local configuration
@@ -1091,12 +1162,6 @@ class Builder(gtk.Window):
         else:
             gtk.main_quit()
 
-    def event_handle_SIGINT(self, signal, frame):
-        for w in gtk.window_list_toplevels():
-            if w.get_modal():
-                w.response(gtk.RESPONSE_DELETE_EVENT)
-        sys.exit(0)
-
     def build_packages(self):
         _, all_recipes = self.recipe_model.get_selected_recipes()
         if not all_recipes:
@@ -1188,6 +1253,7 @@ class Builder(gtk.Window):
         response = dialog.run()
         if response == gtk.RESPONSE_YES:
             self.configuration.layers = dialog.layers
+            self.save_defaults() # remember layers
             # DO refresh layers
             if dialog.layers_changed:
                 self.update_config_async()
@@ -1251,7 +1317,7 @@ class Builder(gtk.Window):
         settings_changed = False
         if response == gtk.RESPONSE_YES:
             self.configuration = dialog.configuration
-            self.configuration.save(self.handler, True) # remember settings
+            self.save_defaults() # remember settings
             settings_changed = dialog.settings_changed
         dialog.destroy()
         return response == gtk.RESPONSE_YES, settings_changed
@@ -1279,7 +1345,7 @@ class Builder(gtk.Window):
         settings_changed = False
         if response == gtk.RESPONSE_YES:
             self.configuration = dialog.configuration
-            self.configuration.save(self.handler, True) # remember settings
+            self.save_defaults() # remember settings
             settings_changed = dialog.settings_changed
             if dialog.proxy_settings_changed:
                 self.set_user_config_proxies()
@@ -1464,13 +1530,3 @@ class Builder(gtk.Window):
             self.consolelog.setFormatter(format)
 
             self.logger.addHandler(self.consolelog)
-
-    def get_topdir(self):
-        return self.handler.get_topdir()
-
-    def wait(self, delay):
-        time_start = time.time()
-        time_end = time_start + delay
-        while time_end > time.time():
-            while gtk.events_pending():
-                gtk.main_iteration()

bitbake/lib/bb/ui/crumbs/hig/advancedsettingsdialog.py

@@ -131,7 +131,7 @@ class AdvancedSettingsDialog (CrumbsDialog, SettingsUIHelper):
         self.rootfs_size_spinner = None
         self.extra_size_spinner = None
         self.gplv3_checkbox = None
-        self.sdk_checkbox = None
+        self.toolchain_checkbox = None
         self.image_types_checkbuttons = {}
 
         self.md5 = self.config_md5()
@@ -234,10 +234,7 @@ class AdvancedSettingsDialog (CrumbsDialog, SettingsUIHelper):
             article = ""
             if image_type.startswith(("a", "e", "i", "o", "u")):
                 article = "n"
-            if image_type == "live":
-                self.image_types_checkbuttons[image_type].set_tooltip_text("Build iso and hddimg images")
-            else:
-                self.image_types_checkbuttons[image_type].set_tooltip_text("Build a%s %s image" % (article, image_type))
+            self.image_types_checkbuttons[image_type].set_tooltip_text("Build a%s %s image" % (article, image_type))
             table.attach(self.image_types_checkbuttons[image_type], j - 1, j + 3, i, i + 1)
             if image_type in self.configuration.image_fstypes.split():
                 self.image_types_checkbuttons[image_type].set_active(True)
@@ -267,7 +264,7 @@ class AdvancedSettingsDialog (CrumbsDialog, SettingsUIHelper):
         sub_vbox = gtk.VBox(False, 6)
         advanced_vbox.pack_start(sub_vbox, expand=False, fill=False)
         label = self.gen_label_widget("Image basic size (in MB)")
-        tooltip = "Defines the size for the generated image. The OpenEmbedded build system determines the final size for the generated image using an algorithm that takes into account the initial disk space used for the generated image, the Image basic size value, and the Additional free space value.\n\nFor more information, check the <a href=\"http://www.yoctoproject.org/docs/current/poky-ref-manual/poky-ref-manual.html#var-IMAGE_ROOTFS_SIZE\">Yocto Project Reference Manual</a>."
+        tooltip = "Sets the basic size of your target image.\nThis is the basic size of your target image unless your selected package size exceeds this value or you select \'Image Extra Size\'."
         rootfs_size_widget, self.rootfs_size_spinner = self.gen_spinner_widget(int(self.configuration.image_rootfs_size*1.0/1024), 0, 65536,"<b>Image basic size</b>" + "*" + tooltip)
         sub_vbox.pack_start(label, expand=False, fill=False)
         sub_vbox.pack_start(rootfs_size_widget, expand=False, fill=False)
@@ -275,7 +272,7 @@ class AdvancedSettingsDialog (CrumbsDialog, SettingsUIHelper):
         sub_vbox = gtk.VBox(False, 6)
         advanced_vbox.pack_start(sub_vbox, expand=False, fill=False)
         label = self.gen_label_widget("Additional free space (in MB)")
-        tooltip = "Sets extra free disk space to be added to the generated image. Use this variable when you want to ensure that a specific amount of free disk space is available on a device after an image is installed and running."
+        tooltip = "Sets the extra free space of your target image.\nBy default, the system reserves 30% of your image size as free space. If your image contains zypper, it brings in 50MB more space. The maximum free space is 64GB."
         extra_size_widget, self.extra_size_spinner = self.gen_spinner_widget(int(self.configuration.image_extra_size*1.0/1024), 0, 65536,"<b>Additional free space</b>" + "*" + tooltip)
         sub_vbox.pack_start(label, expand=False, fill=False)
         sub_vbox.pack_start(extra_size_widget, expand=False, fill=False)
@@ -289,17 +286,16 @@ class AdvancedSettingsDialog (CrumbsDialog, SettingsUIHelper):
             self.gplv3_checkbox.set_active(False)
         advanced_vbox.pack_start(self.gplv3_checkbox, expand=False, fill=False)
 
-        advanced_vbox.pack_start(self.gen_label_widget('<span weight="bold">SDK</span>'), expand=False, fill=False)
+        advanced_vbox.pack_start(self.gen_label_widget('<span weight="bold">Toolchain</span>'), expand=False, fill=False)
         sub_hbox = gtk.HBox(False, 6)
         advanced_vbox.pack_start(sub_hbox, expand=False, fill=False)
-        self.sdk_checkbox = gtk.CheckButton("Populate SDK")
-        tooltip = "Check this box to generate an SDK tarball that consists of the cross-toolchain and a sysroot that contains development packages for your image."
-        self.sdk_checkbox.set_tooltip_text(tooltip)
-        self.sdk_checkbox.set_active(self.configuration.toolchain_build)
-        sub_hbox.pack_start(self.sdk_checkbox, expand=False, fill=False)
+        self.toolchain_checkbox = gtk.CheckButton("Build toolchain")
+        self.toolchain_checkbox.set_tooltip_text("Check this box to build the related toolchain with your image")
+        self.toolchain_checkbox.set_active(self.configuration.toolchain_build)
+        sub_hbox.pack_start(self.toolchain_checkbox, expand=False, fill=False)
 
-        tooltip = "Select the host platform for which you want to run the toolchain contained in the SDK tarball."
-        sdk_machine_widget, self.sdk_machine_combo = self.gen_combo_widget(self.configuration.curr_sdk_machine, self.all_sdk_machines,"<b>Populate SDK</b>" + "*" + tooltip)
+        tooltip = "Selects the host platform for which you want to run the toolchain"
+        sdk_machine_widget, self.sdk_machine_combo = self.gen_combo_widget(self.configuration.curr_sdk_machine, self.all_sdk_machines,"<b>Build toolchain</b>" + "*" + tooltip)
         sub_hbox.pack_start(sdk_machine_widget, expand=False, fill=False)
 
         return advanced_vbox
@@ -334,7 +330,7 @@ class AdvancedSettingsDialog (CrumbsDialog, SettingsUIHelper):
                 self.configuration.incompat_license = " ".join(self.configuration.incompat_license or [])
         self.configuration.incompat_license = self.configuration.incompat_license.strip()
 
-        self.configuration.toolchain_build = self.sdk_checkbox.get_active()
+        self.configuration.toolchain_build = self.toolchain_checkbox.get_active()
         self.configuration.curr_sdk_machine = self.sdk_machine_combo.get_active_text()
         md5 = self.config_md5()
         self.settings_changed = (self.md5 != md5)

bitbake/lib/bb/ui/crumbs/hig/propertydialog.py

@@ -87,7 +87,6 @@ class PropertyDialog(CrumbsDialog):
                 self.table.attach(self.info_label, 0,1,1,2, xoptions=gtk.FILL|gtk.EXPAND, yoptions=gtk.FILL,xpadding=40,ypadding=10)
         
                 self.vbox.add(self.table)
-                self.connect('delete-event', lambda w, e: self.destroy() or True) 
 
         def treeViewTooltip( self, widget, e, tooltips, cell, emptyText="" ):
                  try:
@@ -275,23 +274,24 @@ class PropertyDialog(CrumbsDialog):
                 binb_items_count = len(binb.split(','))
                 binb_items = binb.split(',')
                                		
-		vbox = gtk.VBox(False,spacing = 0)
-
+		vbox = gtk.VBox(True,spacing = 0)
+                
                 ######################################## SUMMARY LABEL #########################################                	                
                 
                 if summary != '':                
                         self.label_short = gtk.Label()
-                        self.label_short.set_width_chars(37)
+                        self.label_short.set_size_request(300,-1)
                         self.label_short.set_selectable(True)                
                         self.label_short.set_line_wrap(True)
                         self.label_short.set_markup("<b>" + summary + "</b>")
                         self.label_short.set_property("xalign", 0)
                         
-                        self.vbox.add(self.label_short)
+                        self.vbox.pack_start(self.label_short, expand=False, fill=False, padding=0)
                 
                 ########################################## NAME ROW + COL #######################################
                                 
                 self.label_short = gtk.Label()
+                self.label_short.set_size_request(300,-1)
                 self.label_short.set_selectable(True)
                 self.label_short.set_line_wrap(True)
                 self.label_short.set_markup("<span weight=\"bold\">Name: </span>" + name)
@@ -302,6 +302,7 @@ class PropertyDialog(CrumbsDialog):
                 ####################################### VERSION ROW + COL ####################################
                 
                 self.label_short = gtk.Label()
+                self.label_short.set_size_request(300,-1)
                 self.label_short.set_selectable(True)
                 self.label_short.set_line_wrap(True)
                 self.label_short.set_markup("<span weight=\"bold\">Version: </span>" + version)
@@ -312,6 +313,7 @@ class PropertyDialog(CrumbsDialog):
                 ##################################### REVISION ROW + COL #####################################
 
                 self.label_short = gtk.Label()
+                self.label_short.set_size_request(300,-1)
                 self.label_short.set_line_wrap(True)
                 self.label_short.set_selectable(True)
                 self.label_short.set_markup("<span weight=\"bold\">Revision: </span>" + revision)
@@ -322,6 +324,7 @@ class PropertyDialog(CrumbsDialog):
                 ################################## GROUP ROW + COL ############################################
                
                 self.label_short = gtk.Label()
+                self.label_short.set_size_request(300,-1)  
                 self.label_short.set_selectable(True)              
                 self.label_short.set_line_wrap(True)                                
                 self.label_short.set_markup("<span weight=\"bold\">Group: </span>" + group)
@@ -343,6 +346,7 @@ class PropertyDialog(CrumbsDialog):
                         self.label_info.set_property("xalign", 0)
                        
                         self.label_short = gtk.Label()
+                        self.label_short.set_size_request(300,-1)   
                         self.label_short.set_selectable(True)                     
                         self.label_short.set_line_wrap(True)                        
                         self.label_short.set_markup("<b>Homepage: </b>")                      
@@ -364,6 +368,7 @@ class PropertyDialog(CrumbsDialog):
                         self.label_info.set_property("xalign", 0)  
 
                         self.label_short = gtk.Label()
+                        self.label_short.set_size_request(300,-1)    
                         self.label_short.set_selectable(True)                    
                         self.label_short.set_line_wrap(True)
                         self.label_short.set_markup("<b>Bugtracker: </b>")                   
@@ -375,6 +380,7 @@ class PropertyDialog(CrumbsDialog):
                 ################################# LICENSE ROW + COL ############################################
                 
                 self.label_info = gtk.Label()
+                self.label_info.set_size_request(300,-1)
                 self.label_info.set_selectable(True)
                 self.label_info.set_line_wrap(True)
                 self.label_info.set_markup(license)
@@ -397,25 +403,16 @@ class PropertyDialog(CrumbsDialog):
                         self.label_short.set_line_wrap(True)
                         self.label_short.set_markup("<span weight=\"bold\">Brought in by: </span>")
                         self.label_short.set_property("xalign", 0)
-                        self.vbox.add(self.label_short)
+
                         self.label_info = gtk.Label()
+                        self.label_info.set_size_request(300,-1)
                         self.label_info.set_selectable(True)
-                        self.label_info.set_width_chars(36)
-                        if len(binb) > 200:
-                            scrolled_window = gtk.ScrolledWindow()
-                            scrolled_window.set_policy(gtk.POLICY_NEVER,gtk.POLICY_ALWAYS)
-                            scrolled_window.set_size_request(100,100)
-                            self.label_info.set_markup(binb)
-                            self.label_info.set_padding(6,6)
-                            self.label_info.set_alignment(0,0)
-                            self.label_info.set_line_wrap(True)
-                            scrolled_window.add_with_viewport(self.label_info)
-                            self.vbox.add(scrolled_window)
-                        else:
-                            self.label_info.set_markup(binb)
-                            self.label_info.set_property("xalign", 0)
-                            self.label_info.set_line_wrap(True) 
-                            self.vbox.add(self.label_info)
+                        self.label_info.set_markup(binb)
+                        self.label_info.set_property("xalign", 0)
+                        self.label_info.set_line_wrap(True)
+                        
+                        self.vbox.add(self.label_short)
+                        self.vbox.add(self.label_info)
 
                 ################################ DESCRIPTION TAG ROW #################################################
                 
@@ -430,22 +427,11 @@ class PropertyDialog(CrumbsDialog):
                 hbox = gtk.HBox(True,spacing = 0)
 
                 self.label_short = gtk.Label()
-                self.label_short.set_selectable(True)
-                self.label_short.set_width_chars(36)
-                if len(description) > 200:
-                    scrolled_window = gtk.ScrolledWindow()
-                    scrolled_window.set_policy(gtk.POLICY_NEVER,gtk.POLICY_ALWAYS)
-                    scrolled_window.set_size_request(100,100)
-                    self.label_short.set_markup(description)
-                    self.label_short.set_padding(6,6)
-                    self.label_short.set_alignment(0,0)
-                    self.label_short.set_line_wrap(True)
-                    scrolled_window.add_with_viewport(self.label_short)
-                    self.vbox.add(scrolled_window)
-                else:    
-                    self.label_short.set_markup(description)
-                    self.label_short.set_property("xalign", 0)
-                    self.label_short.set_line_wrap(True)
-                    self.vbox.add(self.label_short)
+                self.label_short.set_size_request(300,-1)
+                self.label_short.set_selectable(True)                
+                self.label_short.set_text(description)
+                self.label_short.set_line_wrap(True)
+                self.label_short.set_property("xalign", 0)
+                self.vbox.add(self.label_short)
 
                 self.vbox.show_all()

bitbake/lib/bb/ui/crumbs/hig/retrieveimagedialog.py

@@ -1,51 +0,0 @@
-#
-# BitBake Graphical GTK User Interface
-#
-# Copyright (C) 2013   Intel Corporation
-#
-# Authored by Cristiana Voicu <cristiana.voicu@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 gtk
-
-class RetrieveImageDialog (gtk.FileChooserDialog):
-    """
-    This class is used to create a dialog that permits to retrieve
-    a custom image saved previously from Hob.
-    """
-    def __init__(self, directory,title, parent, flags, buttons=None):
-        super(RetrieveImageDialog, self).__init__(title, None, gtk.FILE_CHOOSER_ACTION_OPEN,
-            (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,gtk.STOCK_OPEN, gtk.RESPONSE_OK))
-        self.directory = directory
-
-        # create visual elements on the dialog
-        self.create_visual_elements()
-
-    def create_visual_elements(self):
-        self.set_show_hidden(True)
-        self.set_default_response(gtk.RESPONSE_OK)
-        self.set_current_folder(self.directory)
-
-        vbox = self.get_children()[0].get_children()[0].get_children()[0]
-        for child in vbox.get_children()[0].get_children()[0].get_children()[0].get_children():
-            vbox.get_children()[0].get_children()[0].get_children()[0].remove(child)
-
-        label1 = gtk.Label()
-        label1.set_text("File system" + self.directory)
-        label1.show()
-        vbox.get_children()[0].get_children()[0].get_children()[0].pack_start(label1, expand=False, fill=False, padding=0)
-        vbox.get_children()[0].get_children()[1].get_children()[0].hide()
-
-        self.get_children()[0].get_children()[1].get_children()[0].set_label("Select")

bitbake/lib/bb/ui/crumbs/hig/saveimagedialog.py

@@ -1,160 +0,0 @@
-#
-# BitBake Graphical GTK User Interface
-#
-# Copyright (C) 2013   Intel Corporation
-#
-# Authored by Cristiana Voicu <cristiana.voicu@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 gtk
-import glib
-from bb.ui.crumbs.hig.crumbsdialog import CrumbsDialog
-from bb.ui.crumbs.hig.crumbsmessagedialog import CrumbsMessageDialog
-from bb.ui.crumbs.hobwidget import HobButton
-
-class SaveImageDialog (CrumbsDialog):
-    """
-    This class is used to create a dialog that permits to save
-    a custom image in a predefined directory.
-    """
-    def __init__(self, directory, name, description, title, parent, flags, buttons=None):
-        super(SaveImageDialog, self).__init__(title, parent, flags, buttons)
-        self.directory = directory
-        self.builder = parent
-        self.name_field = name
-        self.description_field = description
-
-        # create visual elements on the dialog
-        self.create_visual_elements()
-
-    def create_visual_elements(self):
-        self.set_default_response(gtk.RESPONSE_OK)
-        self.vbox.set_border_width(6)
-
-        sub_vbox = gtk.VBox(False, 12)
-        self.vbox.pack_start(sub_vbox, expand=False, fill=False)
-        label = gtk.Label()
-        label.set_alignment(0, 0)
-        label.set_markup("<b>Name</b>")
-        sub_label = gtk.Label()
-        sub_label.set_alignment(0, 0)
-        content = "Image recipe names should be all lowercase and include only alphanumeric\n"
-        content += "characters. The only special character you can use is the ASCII hyphen (-)."
-        sub_label.set_markup(content)
-        self.name_entry = gtk.Entry()
-        self.name_entry.set_text(self.name_field)
-        self.name_entry.set_size_request(350,30)
-        self.name_entry.connect("changed", self.name_entry_changed)
-        sub_vbox.pack_start(label, expand=False, fill=False)
-        sub_vbox.pack_start(sub_label, expand=False, fill=False)
-        sub_vbox.pack_start(self.name_entry, expand=False, fill=False)
-
-        sub_vbox = gtk.VBox(False, 12)
-        self.vbox.pack_start(sub_vbox, expand=False, fill=False)
-        label = gtk.Label()
-        label.set_alignment(0, 0)
-        label.set_markup("<b>Description</b> (optional)")
-        sub_label = gtk.Label()
-        sub_label.set_alignment(0, 0)
-        sub_label.set_markup("The description should be less than 150 characters long.")
-        self.description_entry = gtk.TextView()
-        description_buffer = self.description_entry.get_buffer()
-        description_buffer.set_text(self.description_field)
-        description_buffer.connect("insert-text", self.limit_description_length)
-        self.description_entry.set_wrap_mode(gtk.WRAP_WORD)
-        self.description_entry.set_size_request(350,50)
-        sub_vbox.pack_start(label, expand=False, fill=False)
-        sub_vbox.pack_start(sub_label, expand=False, fill=False)
-        sub_vbox.pack_start(self.description_entry, expand=False, fill=False)
-
-        sub_vbox = gtk.VBox(False, 12)
-        self.vbox.pack_start(sub_vbox, expand=False, fill=False)
-        label = gtk.Label()
-        label.set_alignment(0, 0)
-        label.set_markup("Your image recipe will be saved to:")
-        sub_label = gtk.Label()
-        sub_label.set_alignment(0, 0)
-        sub_label.set_markup(self.directory)
-        sub_vbox.pack_start(label, expand=False, fill=False)
-        sub_vbox.pack_start(sub_label, expand=False, fill=False)
-
-        table = gtk.Table(1, 4, True)
-
-        cancel_button = gtk.Button()
-        cancel_button.set_label("Cancel")
-        cancel_button.connect("clicked", self.cancel_button_cb)
-        cancel_button.set_size_request(110, 30)
-
-        self.save_button = gtk.Button()
-        self.save_button.set_label("Save")
-        self.save_button.connect("clicked", self.save_button_cb)
-        self.save_button.set_size_request(110, 30)
-        if self.name_entry.get_text() == '':
-            self.save_button.set_sensitive(False)
-
-        table.attach(cancel_button, 2, 3, 0, 1)
-        table.attach(self.save_button, 3, 4, 0, 1)
-        self.vbox.pack_end(table, expand=False, fill=False)
-
-        self.show_all()
-
-    def limit_description_length(self, textbuffer, iter, text, length):
-        buffer_bounds = textbuffer.get_bounds()
-        entire_text = textbuffer.get_text(*buffer_bounds)
-        entire_text += text
-        if len(entire_text)>150 or text=="\n":
-            textbuffer.emit_stop_by_name("insert-text")
-
-    def name_entry_changed(self, entry):
-        text = entry.get_text()
-        if text == '':
-            self.save_button.set_sensitive(False)
-        else:
-            self.save_button.set_sensitive(True)
-
-    def cancel_button_cb(self, button):
-        self.destroy()
-
-    def save_button_cb(self, button):
-        text = self.name_entry.get_text()
-        new_text = text.replace("-","")
-        description_buffer = self.description_entry.get_buffer()
-        description = description_buffer.get_text(description_buffer.get_start_iter(),description_buffer.get_end_iter())
-        if new_text.islower() and new_text.isalnum():
-            self.builder.image_details_page.image_saved = True
-            self.builder.customized = False
-            self.builder.generate_new_image(self.directory+text, description)
-            self.builder.recipe_model.set_in_list(text, description)
-            self.builder.recipe_model.set_selected_image(text)
-            self.builder.image_details_page.show_page(self.builder.IMAGE_GENERATED)
-            self.builder.image_details_page.name_field_template = text
-            self.builder.image_details_page.description_field_template = description
-            self.destroy()
-        else:
-            self.show_invalid_input_error_dialog()
-
-    def show_invalid_input_error_dialog(self):
-        lbl = "<b>Invalid characters in image recipe name</b>\n"
-        msg = "Image recipe names should be all lowercase and\n"
-        msg += "include only alphanumeric characters. The only\n"
-        msg += "special character you can use is the ASCII hyphen (-)."
-        lbl = lbl + "\n%s\n" % glib.markup_escape_text(msg)
-        dialog = CrumbsMessageDialog(self, lbl, gtk.STOCK_DIALOG_ERROR)
-        button = dialog.add_button("Close", gtk.RESPONSE_OK)
-        HobButton.style_button(button)
-
-        res = dialog.run()
-        self.name_entry.grab_focus()
-        dialog.destroy()

bitbake/lib/bb/ui/crumbs/hig/simplesettingsdialog.py

@@ -310,6 +310,7 @@ class SimpleSettingsDialog (CrumbsDialog, SettingsUIHelper):
 
         sub_vbox = gtk.VBox(False)
         advanced_vbox.pack_start(sub_vbox, gtk.TRUE, gtk.TRUE, 0)
+        searched_string = "file://"
 
         if self.sstatemirrors_changed == 0:
             self.sstatemirrors_changed = 1
@@ -318,12 +319,18 @@ class SimpleSettingsDialog (CrumbsDialog, SettingsUIHelper):
                 sm_list = ["Standard", "", "file://(.*)"]
                 self.sstatemirrors_list.append(sm_list)
             else:
-                sstatemirrors = [x for x in sstatemirrors.split('\\n')]
-                for sstatemirror in sstatemirrors:
+                while sstatemirrors.find(searched_string) != -1:
+                    if sstatemirrors.find(searched_string,1) != -1:
+                        sstatemirror = sstatemirrors[:sstatemirrors.find(searched_string,1)]
+                        sstatemirrors = sstatemirrors[sstatemirrors.find(searched_string,1):]
+                    else:
+                        sstatemirror = sstatemirrors
+                        sstatemirrors = sstatemirrors[1:]
+
                     sstatemirror_fields = [x for x in sstatemirror.split(' ') if x.strip()]
-                    if len(sstatemirror_fields) == 2:
-                        if sstatemirror_fields[0] == "file://(.*)" or sstatemirror_fields[0] == "file://.*":
-                            sm_list = ["Standard", sstatemirror_fields[1], sstatemirror_fields[0]]
+                    if len(sstatemirror_fields):
+                        if sstatemirror_fields[0] == "file://(.*)":
+                            sm_list = ["Standard", sstatemirror_fields[1], "file://(.*)"]
                         else:
                             sm_list = ["Custom", sstatemirror_fields[1], sstatemirror_fields[0]]
                         self.sstatemirrors_list.append(sm_list)

bitbake/lib/bb/ui/crumbs/hobeventhandler.py

@@ -21,7 +21,6 @@
 
 import gobject
 import logging
-import ast
 from bb.ui.crumbs.runningbuild import RunningBuild
 
 class HobHandler(gobject.GObject):
@@ -148,7 +147,7 @@ class HobHandler(gobject.GObject):
             self.runCommand(["findFilesMatchingInDir", "rootfs_", "classes"])
         elif next_command == self.SUB_PARSE_CONFIG:
             self.runCommand(["enableDataTracking"])
-            self.runCommand(["parseConfigurationFiles", "conf/.hob.conf", ""])
+            self.runCommand(["parseConfigurationFiles", "", ""])
             self.runCommand(["disableDataTracking"])
         elif next_command == self.SUB_GNERATE_TGTS:
             self.runCommand(["generateTargetsTree", "classes/image.bbclass", []])
@@ -167,15 +166,17 @@ class HobHandler(gobject.GObject):
             self.clear_busy()
             self.building = True
             targets = [self.image]
+            if self.package_queue:
+                self.runCommand(["setVariable", "LINGUAS_INSTALL", ""])
+                self.runCommand(["setVariable", "PACKAGE_INSTALL", " ".join(self.package_queue)])
             if self.toolchain_packages:
-                self.set_var_in_file("TOOLCHAIN_TARGET_TASK", " ".join(self.toolchain_packages), "local.conf")
+                self.runCommand(["setVariable", "TOOLCHAIN_TARGET_TASK", " ".join(self.toolchain_packages)])
                 targets.append(self.toolchain)
             if targets[0] == "hob-image":
-                self.set_var_in_file("LINGUAS_INSTALL", "", "local.conf")
                 hobImage = self.runCommand(["matchFile", "hob-image.bb"])
-                if self.base_image != "Start with an empty image recipe":
+                if self.base_image != "Create your own image":
                     baseImage = self.runCommand(["matchFile", self.base_image + ".bb"])
-                    version = self.runCommand(["generateNewImage", hobImage, baseImage, self.package_queue, True, ""])
+                    version = self.runCommand(["generateNewImage", hobImage, baseImage, self.package_queue])
                     targets[0] += version
                     self.recipe_model.set_custom_image_version(version)
 
@@ -203,8 +204,8 @@ class HobHandler(gobject.GObject):
         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(["parseConfigurationFiles", "conf/.hob.conf", ""])
+                self.runCommand(["setVariable", "BB_INVALIDCONF", False])
+                self.runCommand(["parseConfigurationFiles", "", ""])
             self.run_next_command()
 
         elif isinstance(event, bb.event.SanityCheckFailed):
@@ -299,98 +300,79 @@ class HobHandler(gobject.GObject):
 
     def init_cooker(self):
         self.runCommand(["initCooker"])
-        self.runCommand(["createConfigFile", ".hob.conf"])
-
-    def reset_cooker(self):
-        self.runCommand(["enableDataTracking"])
-        self.runCommand(["resetCooker"])
-        self.runCommand(["disableDataTracking"])
 
     def set_extra_inherit(self, bbclass):
         inherits = self.runCommand(["getVariable", "INHERIT"]) or ""
         inherits = inherits + " " + bbclass
-        self.set_var_in_file("INHERIT", inherits, ".hob.conf")
+        self.runCommand(["setVariable", "INHERIT", inherits])
 
     def set_bblayers(self, bblayers):
-        self.set_var_in_file("BBLAYERS", " ".join(bblayers), "bblayers.conf")
+        self.runCommand(["setVariable", "BBLAYERS", " ".join(bblayers)])
 
     def set_machine(self, machine):
         if machine:
-            self.early_assign_var_in_file("MACHINE", machine, "local.conf")
+            self.runCommand(["setVariable", "MACHINE", machine])
 
     def set_sdk_machine(self, sdk_machine):
-        self.set_var_in_file("SDKMACHINE", sdk_machine, "local.conf")
+        self.runCommand(["setVariable", "SDKMACHINE", sdk_machine])
 
     def set_image_fstypes(self, image_fstypes):
-        self.set_var_in_file("IMAGE_FSTYPES", image_fstypes, "local.conf")
+        self.runCommand(["setVariable", "IMAGE_FSTYPES", image_fstypes])
 
     def set_distro(self, distro):
-        self.set_var_in_file("DISTRO", distro, "local.conf")
+        self.runCommand(["setVariable", "DISTRO", distro])
 
     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")
+        self.runCommand(["setVariable", "PACKAGE_CLASSES", package_classes])
 
     def set_bbthreads(self, threads):
-        self.set_var_in_file("BB_NUMBER_THREADS", threads, "local.conf")
+        self.runCommand(["setVariable", "BB_NUMBER_THREADS", threads])
 
     def set_pmake(self, threads):
         pmake = "-j %s" % threads
-        self.set_var_in_file("PARALLEL_MAKE", pmake, "local.conf")
+        self.runCommand(["setVariable", "PARALLEL_MAKE", pmake])
 
     def set_dl_dir(self, directory):
-        self.set_var_in_file("DL_DIR", directory, "local.conf")
+        self.runCommand(["setVariable", "DL_DIR", directory])
 
     def set_sstate_dir(self, directory):
-        self.set_var_in_file("SSTATE_DIR", directory, "local.conf")
+        self.runCommand(["setVariable", "SSTATE_DIR", directory])
 
     def set_sstate_mirrors(self, url):
-        self.set_var_in_file("SSTATE_MIRRORS", url, "local.conf")
+        self.runCommand(["setVariable", "SSTATE_MIRRORS", url])
 
     def set_extra_size(self, image_extra_size):
-        self.set_var_in_file("IMAGE_ROOTFS_EXTRA_SPACE", str(image_extra_size), "local.conf")
+        self.runCommand(["setVariable", "IMAGE_ROOTFS_EXTRA_SPACE", str(image_extra_size)])
 
     def set_rootfs_size(self, image_rootfs_size):
-        self.set_var_in_file("IMAGE_ROOTFS_SIZE", str(image_rootfs_size), "local.conf")
+        self.runCommand(["setVariable", "IMAGE_ROOTFS_SIZE", str(image_rootfs_size)])
 
     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")
+        self.runCommand(["setVariable", "INCOMPATIBLE_LICENSE", incompat_license])
 
     def set_extra_config(self, extra_setting):
-        old_extra_setting = ast.literal_eval(self.runCommand(["getVariable", "EXTRA_SETTING"]) or "{}")
-        if extra_setting:
-            self.set_var_in_file("EXTRA_SETTING", extra_setting, "local.conf")
-        else:
-            self.remove_var_from_file("EXTRA_SETTING")
-
-        #remove not needed settings from conf
-        for key in old_extra_setting:
-            if key not in extra_setting:
-                self.remove_var_from_file(key)
         for key in extra_setting.keys():
             value = extra_setting[key]
-            self.set_var_in_file(key, value, "local.conf")
+            self.runCommand(["setVariable", key, value])
 
     def set_http_proxy(self, http_proxy):
-        self.set_var_in_file("http_proxy", http_proxy, "local.conf")
+        self.runCommand(["setVariable", "http_proxy", http_proxy])
 
     def set_https_proxy(self, https_proxy):
-        self.set_var_in_file("https_proxy", https_proxy, "local.conf")
+        self.runCommand(["setVariable", "https_proxy", https_proxy])
 
     def set_ftp_proxy(self, ftp_proxy):
-        self.set_var_in_file("ftp_proxy", ftp_proxy, "local.conf")
+        self.runCommand(["setVariable", "ftp_proxy", ftp_proxy])
 
     def set_socks_proxy(self, socks_proxy):
-        self.set_var_in_file("all_proxy", socks_proxy, "local.conf")
+        self.runCommand(["setVariable", "all_proxy", socks_proxy])
 
     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")
+        self.runCommand(["setVariable", "CVS_PROXY_HOST", host])
+        self.runCommand(["setVariable", "CVS_PROXY_PORT", port])
 
     def request_package_info(self):
         self.commands_async.append(self.SUB_GENERATE_PKGINFO)
@@ -438,13 +420,6 @@ class HobHandler(gobject.GObject):
         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):
-        base_image = self.runCommand(["matchFile", self.base_image + ".bb"])
-        self.runCommand(["generateNewImage", image, base_image, package_queue, False, description])
-
-    def ensure_dir(self, directory):
-        self.runCommand(["ensureDir", directory])
-
     def build_succeeded_async(self):
         self.building = False
 
@@ -454,12 +429,12 @@ class HobHandler(gobject.GObject):
         self.building = False
 
     def cancel_parse(self):
-        self.runCommand(["stateForceShutdown"])
+        self.runCommand(["stateStop"])
 
     def cancel_build(self, force=False):
         if force:
             # Force the cooker to stop as quickly as possible
-            self.runCommand(["stateForceShutdown"])
+            self.runCommand(["stateStop"])
         else:
             # Wait for tasks to complete before shutting down, this helps
             # leave the workdir in a usable state
@@ -471,9 +446,6 @@ class HobHandler(gobject.GObject):
     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():
@@ -482,26 +454,7 @@ class HobHandler(gobject.GObject):
         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, "local.conf")
+        self.server.runCommand(["setVarFile", var, val, default_file])
 
     def get_parameters(self):
         # retrieve the parameters from bitbake

bitbake/lib/bb/ui/crumbs/hoblistmodel.py

@@ -63,7 +63,6 @@ class PackageListModel(gtk.ListStore):
                                 gobject.TYPE_BOOLEAN,
                                 gobject.TYPE_STRING,
                                 gobject.TYPE_STRING)
-        self.sort_column_id, self.sort_order = PackageListModel.COL_NAME, gtk.SORT_ASCENDING
 
     """
     Find the model path for the item_name
@@ -110,11 +109,11 @@ class PackageListModel(gtk.ListStore):
         model.set_visible_func(self.tree_model_filter, filter)
 
         sort = gtk.TreeModelSort(model)
-        sort.connect ('sort-column-changed', self.sort_column_changed_cb)
         if initial:
             sort.set_sort_column_id(PackageListModel.COL_NAME, gtk.SORT_ASCENDING)
             sort.set_default_sort_func(None)
-        elif excluded_items_ahead:
+
+        if excluded_items_ahead:
             sort.set_default_sort_func(self.exclude_item_sort_func, search_data)
         elif included_items_ahead:
             sort.set_default_sort_func(self.include_item_sort_func, search_data)
@@ -122,18 +121,15 @@ class PackageListModel(gtk.ListStore):
             if search_data and search_data!='Search recipes by name' and search_data!='Search package groups by name':
                 sort.set_default_sort_func(self.sort_func, search_data)
             else:
-                sort.set_sort_column_id(self.sort_column_id, self.sort_order)
+                sort.set_sort_column_id(PackageListModel.COL_NAME, gtk.SORT_ASCENDING)
                 sort.set_default_sort_func(None)
 
         sort.set_sort_func(PackageListModel.COL_INC, self.sort_column, PackageListModel.COL_INC)
         sort.set_sort_func(PackageListModel.COL_SIZE, self.sort_column, PackageListModel.COL_SIZE)
-        sort.set_sort_func(PackageListModel.COL_BINB, self.sort_binb_column)
+        sort.set_sort_func(PackageListModel.COL_BINB, self.sort_column, PackageListModel.COL_BINB)
         sort.set_sort_func(PackageListModel.COL_RCP, self.sort_column, PackageListModel.COL_RCP)
         return sort
 
-    def sort_column_changed_cb (self, data):
-        self.sort_column_id, self.sort_order = data.get_sort_column_id ()
-
     def sort_column(self, model, row1, row2, col):
         value1 = model.get_value(row1, col)
         value2 = model.get_value(row2, col)
@@ -152,32 +148,16 @@ class PackageListModel(gtk.ListStore):
             name2 = model.get_value(row2, PackageListModel.COL_NAME)
             return cmp(name1,name2)
 
-    def sort_binb_column(self, model, row1, row2):
-        value1 = model.get_value(row1, PackageListModel.COL_BINB)
-        value2 = model.get_value(row2, PackageListModel.COL_BINB)
-        value1_list = value1.split(', ')
-        value2_list = value2.split(', ')
-
-        value1 = value1_list[0]
-        value2 = value2_list[0]
-
-        cmp_res = cmp(value1, value2)
-        if cmp_res==0:
-            cmp_size = cmp(len(value1_list), len(value2_list))
-            if cmp_size==0:
-                name1 = model.get_value(row1, PackageListModel.COL_NAME)
-                name2 = model.get_value(row2, PackageListModel.COL_NAME)
-                return cmp(name1,name2)
-            else:
-                return cmp_size
-        else:
-            return cmp_res
-
     def exclude_item_sort_func(self, model, iter1, iter2, user_data=None):
         if user_data:
             val1 = model.get_value(iter1, PackageListModel.COL_NAME)
             val2 = model.get_value(iter2, PackageListModel.COL_NAME)
-            return self.cmp_vals(val1, val2, user_data)
+            if val1.startswith(user_data) and not val2.startswith(user_data):
+                return -1
+            elif not val1.startswith(user_data) and val2.startswith(user_data):
+                return 1
+            else:
+                return 0
         else:
             val1 = model.get_value(iter1, PackageListModel.COL_FADE_INC)
             val2 = model.get_value(iter2, PackageListModel.COL_INC)
@@ -187,7 +167,12 @@ class PackageListModel(gtk.ListStore):
         if user_data:
             val1 = model.get_value(iter1, PackageListModel.COL_NAME)
             val2 = model.get_value(iter2, PackageListModel.COL_NAME)
-            return self.cmp_vals(val1, val2, user_data)
+            if val1.startswith(user_data) and not val2.startswith(user_data):
+                return -1
+            elif not val1.startswith(user_data) and val2.startswith(user_data):
+                return 1
+            else:
+                return 0
         else:
             val1 = model.get_value(iter1, PackageListModel.COL_INC)
             val2 = model.get_value(iter2, PackageListModel.COL_INC)
@@ -196,15 +181,12 @@ class PackageListModel(gtk.ListStore):
     def sort_func(self, model, iter1, iter2, user_data):
         val1 = model.get_value(iter1, PackageListModel.COL_NAME)
         val2 = model.get_value(iter2, PackageListModel.COL_NAME)
-        return self.cmp_vals(val1, val2, user_data)
-
-    def cmp_vals(self, val1, val2, user_data):
         if val1.startswith(user_data) and not val2.startswith(user_data):
             return -1
         elif not val1.startswith(user_data) and val2.startswith(user_data):
             return 1
         else:
-            return cmp(val1, val2)
+            return 0
 
     def convert_vpath_to_path(self, view_model, view_path):
         # view_model is the model sorted
@@ -474,9 +456,9 @@ class RecipeListModel(gtk.ListStore):
     provide filtered views of the data.
     """
     (COL_NAME, COL_DESC, COL_LIC, COL_GROUP, COL_DEPS, COL_BINB, COL_TYPE, COL_INC, COL_IMG, COL_INSTALL, COL_PN, COL_FADE_INC, COL_SUMMARY, COL_VERSION,
-     COL_REVISION, COL_HOMEPAGE, COL_BUGTRACKER, COL_FILE) = range(18)
+     COL_REVISION, COL_HOMEPAGE, COL_BUGTRACKER) = range(17)
 
-    __custom_image__ = "Start with an empty image recipe"
+    __custom_image__ = "Create your own image"
 
     __gsignals__ = {
         "recipe-selection-changed" : (gobject.SIGNAL_RUN_LAST,
@@ -504,9 +486,7 @@ class RecipeListModel(gtk.ListStore):
                                 gobject.TYPE_STRING,
                                 gobject.TYPE_STRING,
                                 gobject.TYPE_STRING,
-                                gobject.TYPE_STRING,
                                 gobject.TYPE_STRING)
-        self.sort_column_id, self.sort_order = RecipeListModel.COL_NAME, gtk.SORT_ASCENDING
 
     """
     Find the model path for the item_name
@@ -553,7 +533,12 @@ class RecipeListModel(gtk.ListStore):
         if user_data:
             val1 = model.get_value(iter1, RecipeListModel.COL_NAME)
             val2 = model.get_value(iter2, RecipeListModel.COL_NAME)
-            return self.cmp_vals(val1, val2, user_data)
+            if val1.startswith(user_data) and not val2.startswith(user_data):
+                return -1
+            elif not val1.startswith(user_data) and val2.startswith(user_data):
+                return 1
+            else:
+                return 0
         else:
             val1 = model.get_value(iter1, RecipeListModel.COL_FADE_INC)
             val2 = model.get_value(iter2, RecipeListModel.COL_INC)
@@ -563,7 +548,12 @@ class RecipeListModel(gtk.ListStore):
         if user_data:
             val1 = model.get_value(iter1, RecipeListModel.COL_NAME)
             val2 = model.get_value(iter2, RecipeListModel.COL_NAME)
-            return self.cmp_vals(val1, val2, user_data)
+            if val1.startswith(user_data) and not val2.startswith(user_data):
+                return -1
+            elif not val1.startswith(user_data) and val2.startswith(user_data):
+                return 1
+            else:
+                return 0
         else:
             val1 = model.get_value(iter1, RecipeListModel.COL_INC)
             val2 = model.get_value(iter2, RecipeListModel.COL_INC)
@@ -572,15 +562,12 @@ class RecipeListModel(gtk.ListStore):
     def sort_func(self, model, iter1, iter2, user_data):
         val1 = model.get_value(iter1, RecipeListModel.COL_NAME)
         val2 = model.get_value(iter2, RecipeListModel.COL_NAME)
-        return self.cmp_vals(val1, val2, user_data)
-
-    def cmp_vals(self, val1, val2, user_data):
         if val1.startswith(user_data) and not val2.startswith(user_data):
             return -1
         elif not val1.startswith(user_data) and val2.startswith(user_data):
             return 1
         else:
-            return cmp(val1, val2)
+            return 0
 
     """
     Create, if required, and return a filtered gtk.TreeModelSort
@@ -592,11 +579,11 @@ class RecipeListModel(gtk.ListStore):
         model.set_visible_func(self.tree_model_filter, filter)
 
         sort = gtk.TreeModelSort(model)
-        sort.connect ('sort-column-changed', self.sort_column_changed_cb)
         if initial:
             sort.set_sort_column_id(RecipeListModel.COL_NAME, gtk.SORT_ASCENDING)
             sort.set_default_sort_func(None)
-        elif excluded_items_ahead:
+
+        if excluded_items_ahead:
             sort.set_default_sort_func(self.exclude_item_sort_func, search_data)
         elif included_items_ahead:
             sort.set_default_sort_func(self.include_item_sort_func, search_data)
@@ -604,18 +591,15 @@ class RecipeListModel(gtk.ListStore):
             if search_data and search_data!='Search recipes by name' and search_data!='Search package groups by name':
                 sort.set_default_sort_func(self.sort_func, search_data)
             else:
-                sort.set_sort_column_id(self.sort_column_id, self.sort_order)
+                sort.set_sort_column_id(RecipeListModel.COL_NAME, gtk.SORT_ASCENDING)
                 sort.set_default_sort_func(None)
 
         sort.set_sort_func(RecipeListModel.COL_INC, self.sort_column, RecipeListModel.COL_INC)
         sort.set_sort_func(RecipeListModel.COL_GROUP, self.sort_column, RecipeListModel.COL_GROUP)
-        sort.set_sort_func(RecipeListModel.COL_BINB, self.sort_binb_column)
+        sort.set_sort_func(RecipeListModel.COL_BINB, self.sort_column, RecipeListModel.COL_BINB)
         sort.set_sort_func(RecipeListModel.COL_LIC, self.sort_column, RecipeListModel.COL_LIC)
         return sort
 
-    def sort_column_changed_cb (self, data):
-        self.sort_column_id, self.sort_order = data.get_sort_column_id ()
-
     def sort_column(self, model, row1, row2, col):
         value1 = model.get_value(row1, col)
         value2 = model.get_value(row2, col)
@@ -630,27 +614,6 @@ class RecipeListModel(gtk.ListStore):
             name2 = model.get_value(row2, RecipeListModel.COL_NAME)
             return cmp(name1,name2)
 
-    def sort_binb_column(self, model, row1, row2):
-        value1 = model.get_value(row1, RecipeListModel.COL_BINB)
-        value2 = model.get_value(row2, RecipeListModel.COL_BINB)
-        value1_list = value1.split(', ')
-        value2_list = value2.split(', ')
-
-        value1 = value1_list[0]
-        value2 = value2_list[0]
-
-        cmp_res = cmp(value1, value2)
-        if cmp_res==0:
-            cmp_size = cmp(len(value1_list), len(value2_list))
-            if cmp_size==0:
-                name1 = model.get_value(row1, RecipeListModel.COL_NAME)
-                name2 = model.get_value(row2, RecipeListModel.COL_NAME)
-                return cmp(name1,name2)
-            else:
-                return cmp_size
-        else:
-            return cmp_res
-
     def convert_vpath_to_path(self, view_model, view_path):
         filtered_model_path = view_model.convert_path_to_child_path(view_path)
         filtered_model = view_model.get_model()
@@ -679,8 +642,15 @@ class RecipeListModel(gtk.ListStore):
         self.clear()
 
         # dummy image for prompt
-        self.set_in_list(self.__custom_image__,  "Use 'Edit image recipe' to customize recipes and packages " \
-                                "to be included in your image ")
+        self.set(self.append(), self.COL_NAME, self.__custom_image__,
+                 self.COL_DESC, "Use 'Edit image' to customize recipes and packages " \
+                                "to be included in your image ",
+                 self.COL_LIC, "", self.COL_GROUP, "",
+                 self.COL_DEPS, "", self.COL_BINB, "",
+                 self.COL_TYPE, "image", self.COL_INC, False,
+                 self.COL_IMG, False, self.COL_INSTALL, "", self.COL_PN, self.__custom_image__,
+                 self.COL_SUMMARY, "", self.COL_VERSION, "", self.COL_REVISION, "",
+                 self.COL_HOMEPAGE, "", self.COL_BUGTRACKER, "")
 
         for item in event_model["pn"]:
             name = item
@@ -690,10 +660,9 @@ class RecipeListModel(gtk.ListStore):
             inherits = event_model["pn"][item]["inherits"]
             summary = event_model["pn"][item]["summary"]
             version = event_model["pn"][item]["version"]
-            revision = event_model["pn"][item]["prevision"]
+            revision = event_model["pn"][item]["revision"]
             homepage = event_model["pn"][item]["homepage"]
             bugtracker = event_model["pn"][item]["bugtracker"]
-            filename = event_model["pn"][item]["filename"]
             install = []
 
             depends = event_model["depends"].get(item, []) + event_model["rdepends-pn"].get(item, [])
@@ -717,8 +686,7 @@ class RecipeListModel(gtk.ListStore):
                      self.COL_TYPE, atype, self.COL_INC, False,
                      self.COL_IMG, False, self.COL_INSTALL, " ".join(install), self.COL_PN, item,
                      self.COL_SUMMARY, summary, self.COL_VERSION, version, self.COL_REVISION, revision,
-                     self.COL_HOMEPAGE, homepage, self.COL_BUGTRACKER, bugtracker,
-                     self.COL_FILE, filename)
+                     self.COL_HOMEPAGE, homepage, self.COL_BUGTRACKER, bugtracker)
 
         self.pn_path = {}
         it = self.get_iter_first()
@@ -728,23 +696,6 @@ class RecipeListModel(gtk.ListStore):
             self.pn_path[pn] = path
             it = self.iter_next(it)
 
-    def set_in_list(self, item, desc):
-        self.set(self.append(), self.COL_NAME, item,
-                 self.COL_DESC, desc,
-                 self.COL_LIC, "", self.COL_GROUP, "",
-                 self.COL_DEPS, "", self.COL_BINB, "",
-                 self.COL_TYPE, "image", self.COL_INC, False,
-                 self.COL_IMG, False, self.COL_INSTALL, "", self.COL_PN, item,
-                 self.COL_SUMMARY, "", self.COL_VERSION, "", self.COL_REVISION, "",
-                 self.COL_HOMEPAGE, "", self.COL_BUGTRACKER, "")
-        self.pn_path = {}
-        it = self.get_iter_first()
-        while it:
-            pn = self.get_value(it, self.COL_NAME)
-            path = self.get_path(it)
-            self.pn_path[pn] = path
-            it = self.iter_next(it)
-
     """
     Update the model, send out the notification.
     """
@@ -895,6 +846,3 @@ class RecipeListModel(gtk.ListStore):
 
     def get_custom_image_version(self):
         return self.custom_image_version
-
-    def is_custom_image(self):
-        return self.get_selected_image() == self.__custom_image__

bitbake/lib/bb/ui/crumbs/imageconfigurationpage.py

@@ -28,7 +28,6 @@ from bb.ui.crumbs.hobcolor import HobColors
 from bb.ui.crumbs.hobwidget import hic, HobImageButton, HobInfoButton, HobAltButton, HobButton
 from bb.ui.crumbs.hoblistmodel import RecipeListModel
 from bb.ui.crumbs.hobpages import HobPage
-from bb.ui.crumbs.hig.retrieveimagedialog import RetrieveImageDialog
 
 #
 # ImageConfigurationPage
@@ -36,8 +35,7 @@ from bb.ui.crumbs.hig.retrieveimagedialog import RetrieveImageDialog
 class ImageConfigurationPage (HobPage):
 
     __dummy_machine__ = "--select a machine--"
-    __dummy_image__   = "--select an image recipe--"
-    __custom_image__  = "Select from my image recipes"
+    __dummy_image__   = "--select a base image--"
 
     def __init__(self, builder):
         super(ImageConfigurationPage, self).__init__(builder, "Image configuration")
@@ -49,7 +47,6 @@ class ImageConfigurationPage (HobPage):
         self.machine_combo_changed_by_manual = True
         self.stopping = False
         self.warning_shift = 0
-        self.custom_image_selected = None
         self.create_visual_elements()
 
     def create_visual_elements(self):
@@ -172,8 +169,7 @@ class ImageConfigurationPage (HobPage):
 
     def disable_warnings_bar(self):
         if self.builder.parsing_warnings:
-            if hasattr(self, 'warnings_bar'):
-                self.warnings_bar.hide_all()
+            self.warnings_bar.hide_all()
             self.builder.parsing_warnings = []
 
     def create_config_machine(self):
@@ -203,9 +199,12 @@ class ImageConfigurationPage (HobPage):
         markup += "http://www.yoctoproject.org/docs/current/dev-manual/"
         markup += "dev-manual.html#understanding-and-using-layers\">reference manual</a>."
         self.layer_info_icon = HobInfoButton("<b>Layers</b>" + "*" + markup, self.get_parent())
+#        self.progress_box = gtk.HBox(False, 6)
         self.progress_bar = HobProgressBar()
+#        self.progress_box.pack_start(self.progress_bar, expand=True, fill=True)
         self.stop_button = HobAltButton("Stop")
         self.stop_button.connect("clicked", self.stop_button_clicked_cb)
+#        self.progress_box.pack_end(stop_button, expand=False, fill=False)
         self.machine_separator = gtk.HSeparator()
 
     def set_config_machine_layout(self, show_progress_bar = False):
@@ -229,19 +228,17 @@ class ImageConfigurationPage (HobPage):
     def create_config_baseimg(self):
         self.image_title = gtk.Label()
         self.image_title.set_alignment(0, 1.0)
-        mark = "<span %s>Select an image recipe</span>" % self.span_tag('x-large', 'bold')
+        mark = "<span %s>Select a base image</span>" % self.span_tag('x-large', 'bold')
         self.image_title.set_markup(mark)
 
         self.image_title_desc = gtk.Label()
         self.image_title_desc.set_alignment(0, 0.5)
-
-        mark = ("<span %s>Image recipes are a starting point for the type of image you want. "
+        mark = ("<span %s>Base images are a starting point for the type of image you want. "
                 "You can build them as \n"
-                "they are or edit them to suit your needs.\n</span>") % self.span_tag('medium')
+                "they are or customize them to your specific needs.\n</span>") % self.span_tag('medium')
         self.image_title_desc.set_markup(mark)
 
         self.image_combo = gtk.combo_box_new_text()
-        self.image_combo.set_row_separator_func(self.combo_separator_func, None)
         self.image_combo_id = self.image_combo.connect("changed", self.image_combo_changed_cb)
 
         self.image_desc = gtk.Label()
@@ -260,11 +257,6 @@ class ImageConfigurationPage (HobPage):
 
         self.image_separator = gtk.HSeparator()
 
-    def combo_separator_func(self, model, iter, user_data):
-        name = model.get_value(iter, 0)
-        if name == "--Separator--":
-            return True
-
     def set_config_baseimg_layout(self):
         self.gtable.attach(self.image_title, 0, 40, 15+self.warning_shift, 17+self.warning_shift)
         self.gtable.attach(self.image_title_desc, 0, 40, 18+self.warning_shift, 22+self.warning_shift)
@@ -279,13 +271,15 @@ class ImageConfigurationPage (HobPage):
 
         # create button "Build image"
         self.just_bake_button = HobButton("Build image")
-        self.just_bake_button.set_tooltip_text("Build the image recipe as it is")
+        #self.just_bake_button.set_size_request(205, 49)
+        self.just_bake_button.set_tooltip_text("Build target image")
         self.just_bake_button.connect("clicked", self.just_bake_button_clicked_cb)
         button_box.pack_end(self.just_bake_button, expand=False, fill=False)
 
-        # create button "Edit image recipe"
-        self.edit_image_button = HobAltButton("Edit image recipe")
-        self.edit_image_button.set_tooltip_text("Customize the recipes and packages to be included in your image")
+        # create button "Edit Image"
+        self.edit_image_button = HobAltButton("Edit image")
+        #self.edit_image_button.set_size_request(205, 49)
+        self.edit_image_button.set_tooltip_text("Edit target image")
         self.edit_image_button.connect("clicked", self.edit_image_button_clicked_cb)
         button_box.pack_end(self.edit_image_button, expand=False, fill=False)
 
@@ -300,12 +294,7 @@ class ImageConfigurationPage (HobPage):
     def view_warnings_button_clicked_cb(self, button):
         self.builder.show_warning_dialog()
 
-    def machine_combo_changed_idle_cb(self):
-        self.builder.window.set_cursor(None)
-
     def machine_combo_changed_cb(self, machine_combo):
-        self.builder.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
-        self.builder.wait(0.1) #wait for combo and cursor to update
         self.stopping = False
         self.builder.parsing_warnings = []
         combo_item = machine_combo.get_active_text()
@@ -324,13 +313,9 @@ class ImageConfigurationPage (HobPage):
         # reset machine_combo_changed_by_manual
         self.machine_combo_changed_by_manual = True
 
-        self.builder.configuration.selected_image = None
-
         # Do reparse recipes
         self.builder.populate_recipe_package_info_async()
 
-        glib.idle_add(self.machine_combo_changed_idle_cb)
-
     def update_machine_combo(self):
         self.disable_warnings_bar()
         all_machines = [self.__dummy_machine__] + self.builder.parameters.all_machines
@@ -376,33 +361,7 @@ class ImageConfigurationPage (HobPage):
     def image_combo_changed_cb(self, combo):
         self.builder.window_sensitive(False)
         selected_image = self.image_combo.get_active_text()
-        if selected_image == self.__custom_image__:
-            topdir = self.builder.get_topdir()
-            images_dir = topdir + "/recipes/images/"
-            self.builder.ensure_dir(images_dir)
-
-            dialog = RetrieveImageDialog(images_dir, "Select from my image recipes",
-                            self.builder, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
-            response = dialog.run()
-            if response == gtk.RESPONSE_OK:
-                image_name = dialog.get_filename()
-                head, tail = os.path.split(image_name)
-                selected_image = os.path.splitext(tail)[0]
-                self.custom_image_selected = selected_image
-                self.update_image_combo(self.builder.recipe_model, selected_image)
-            else:
-                selected_image = self.__dummy_image__
-                self.update_image_combo(self.builder.recipe_model, None)
-            dialog.destroy()
-        else:
-            if self.custom_image_selected:
-                self.custom_image_selected = None
-                self.update_image_combo(self.builder.recipe_model, selected_image)
-
         if not selected_image or (selected_image == self.__dummy_image__):
-            self.builder.window_sensitive(True)
-            self.just_bake_button.hide()
-            self.edit_image_button.hide()
             return
 
         # remove __dummy_image__ item from the store list after first user selection
@@ -468,11 +427,6 @@ class ImageConfigurationPage (HobPage):
             self.image_combo.append_text(self.__dummy_image__)
             cnt = cnt + 1
 
-        self.image_combo.append_text(self.__custom_image__)
-        self.image_combo.append_text("--Separator--")
-        cnt = cnt + 2
-
-        topdir = self.builder.get_topdir()
         # append and set active
         while it:
             path = image_model.get_path(it)
@@ -496,27 +450,16 @@ class ImageConfigurationPage (HobPage):
             else:
                 allow = True
 
-            file_name = image_model[path][recipe_model.COL_FILE]
-            if file_name and topdir in file_name:
-                allow = False
-
             if allow:
                 self.image_combo.append_text(image_name)
                 if image_name == selected_image:
                     active = cnt
                 cnt = cnt + 1
-        self.image_combo.append_text(self.builder.recipe_model.__custom_image__)
 
+        self.image_combo.append_text(self.builder.recipe_model.__custom_image__)
         if selected_image == self.builder.recipe_model.__custom_image__:
             active = cnt
 
-        if self.custom_image_selected:
-            self.image_combo.append_text("--Separator--")
-            self.image_combo.append_text(self.custom_image_selected)
-            cnt = cnt + 2
-            if self.custom_image_selected == selected_image:
-                active = cnt
-
         self.image_combo.set_active(active)
 
         if active != 0:
@@ -527,17 +470,14 @@ class ImageConfigurationPage (HobPage):
     def layer_button_clicked_cb(self, button):
         # Create a layer selection dialog
         self.builder.show_layer_selection_dialog()
-
+        
     def view_adv_configuration_button_clicked_cb(self, button):
         # Create an advanced settings dialog
         response, settings_changed = self.builder.show_adv_settings_dialog()
         if not response:
             return
         if settings_changed:
-            self.builder.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
-            self.builder.wait(0.1) #wait for adv_settings_dialog to terminate
-            self.builder.reparse_post_adv_settings()
-            self.builder.window.set_cursor(None)
+            self.builder.reparse_post_adv_settings()        
 
     def just_bake_button_clicked_cb(self, button):
         self.builder.parsing_warnings = []

bitbake/lib/bb/ui/crumbs/imagedetailspage.py

@@ -27,7 +27,6 @@ from bb.ui.crumbs.hobwidget import hic, HobViewTable, HobAltButton, HobButton
 from bb.ui.crumbs.hobpages import HobPage
 import subprocess
 from bb.ui.crumbs.hig.crumbsdialog import CrumbsDialog
-from bb.ui.crumbs.hig.saveimagedialog import SaveImageDialog
 
 #
 # ImageDetailsPage
@@ -189,10 +188,7 @@ class ImageDetailsPage (HobPage):
         self.image_store = []
         self.button_ids = {}
         self.details_bottom_buttons = gtk.HBox(False, 6)
-        self.image_saved = False
         self.create_visual_elements()
-        self.name_field_template = ""
-        self.description_field_template = ""
 
     def create_visual_elements(self):
         # create visual elements
@@ -251,7 +247,7 @@ class ImageDetailsPage (HobPage):
         self.pack_start(self.group_align, expand=True, fill=True)
 
         self.build_result = None
-        if self.image_saved or (self.build_succeeded and self.builder.current_step == self.builder.IMAGE_GENERATING):
+        if self.build_succeeded and self.builder.current_step == self.builder.IMAGE_GENERATING:
             # building is the previous step
             icon = gtk.Image()
             pixmap_path = hic.ICON_INDI_CONFIRM_FILE
@@ -259,14 +255,11 @@ class ImageDetailsPage (HobPage):
             pix_buffer = gtk.gdk.pixbuf_new_from_file(pixmap_path)
             icon.set_from_pixbuf(pix_buffer)
             varlist = [""]
-            if self.image_saved:
-                vallist = ["Your image recipe has been saved"]
-            else:
-                vallist = ["Your image is ready"]
+            vallist = ["Your image is ready"]
             self.build_result = self.BuildDetailBox(varlist=varlist, vallist=vallist, icon=icon, color=color)
             self.box_group_area.pack_start(self.build_result, expand=False, fill=False)
 
-        self.buttonlist = ["Build new image", "Save image recipe", "Run image", "Deploy image"]
+        self.buttonlist = ["Build new image", "Run image", "Deploy image"]
 
         # Name
         self.image_store = []
@@ -340,18 +333,13 @@ class ImageDetailsPage (HobPage):
         #    self.kernel_detail = self.DetailBox(varlist=varlist, vallist=vallist, button=change_kernel_button)
         #    self.box_group_area.pack_start(self.kernel_detail, expand=True, fill=True)
 
-        # Machine, Image recipe and Layers
+        # Machine, Base image and Layers
         layer_num_limit = 15
-        varlist = ["Machine: ", "Image recipe: ", "Layers: "]
+        varlist = ["Machine: ", "Base image: ", "Layers: "]
         vallist = []
         self.setting_detail = None
         if self.build_succeeded:
             vallist.append(machine)
-            if self.builder.recipe_model.is_custom_image():
-                if self.builder.configuration.initial_selected_image == self.builder.recipe_model.__custom_image__:
-                    base_image ="New image recipe"
-                else:
-                    base_image = self.builder.configuration.initial_selected_image + " (edited)"
             vallist.append(base_image)
             i = 0
             for layer in layers:
@@ -371,7 +359,7 @@ class ImageDetailsPage (HobPage):
                 i += 1
 
             edit_config_button = HobAltButton("Edit configuration")
-            edit_config_button.set_tooltip_text("Edit machine and image recipe")
+            edit_config_button.set_tooltip_text("Edit machine, base image and recipes")
             edit_config_button.connect("clicked", self.edit_config_button_clicked_cb)
             self.setting_detail = self.DetailBox(varlist=varlist, vallist=vallist, button=edit_config_button)
             self.box_group_area.pack_start(self.setting_detail, expand=True, fill=True)
@@ -381,8 +369,6 @@ class ImageDetailsPage (HobPage):
         vallist = []
         vallist.append(pkg_num)
         vallist.append(default_image_size)
-        self.builder.configuration.image_size = default_image_size
-        self.builder.configuration.image_packages = self.builder.configuration.selected_packages
         if self.build_succeeded:
             edit_packages_button = HobAltButton("Edit packages")
             edit_packages_button.set_tooltip_text("Edit the packages included in your image")
@@ -403,7 +389,6 @@ class ImageDetailsPage (HobPage):
         self.show_all()
         if self.kernel_detail and (not is_runnable):
             self.kernel_detail.hide()
-        self.image_saved = False
 
     def view_files_clicked_cb(self, button, image_addr):
         subprocess.call("xdg-open /%s" % image_addr, shell=True)
@@ -587,15 +572,6 @@ class ImageDetailsPage (HobPage):
             created = True
             is_runnable = True
 
-        name = "Save image recipe"
-        if name in buttonlist and self.builder.recipe_model.is_custom_image():
-            save_button = HobAltButton("Save image recipe")
-            save_button.set_tooltip_text("Keep your changes saving them as an image recipe")
-            save_button.set_sensitive(not self.image_saved)
-            button_id = save_button.connect("clicked", self.save_button_clicked_cb)
-            self.button_ids[button_id] = save_button
-            self.details_bottom_buttons.pack_end(save_button, expand=False, fill=False)
-
         name = "Build new image"
         if name in buttonlist:
             # create button "Build new image"
@@ -630,24 +606,6 @@ class ImageDetailsPage (HobPage):
             else:
                 self.builder.runqemu_image(self.toggled_image, self.sel_kernel)
 
-    def save_button_clicked_cb(self, button):
-        topdir = self.builder.get_topdir()
-        images_dir = topdir + "/recipes/images/"
-        self.builder.ensure_dir(images_dir)
-
-        self.name_field_template = self.builder.image_configuration_page.custom_image_selected
-        if self.name_field_template:
-            image_path = self.builder.recipe_model.pn_path[self.name_field_template]
-            image_iter = self.builder.recipe_model.get_iter(image_path)
-            self.description_field_template = self.builder.recipe_model.get_value(image_iter, self.builder.recipe_model.COL_DESC)
-        else:
-            self.name_field_template = ""
-
-        dialog = SaveImageDialog(images_dir, self.name_field_template, self.description_field_template,
-                 "Save image recipe", self.builder, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
-        response = dialog.run()
-        dialog.destroy()
-
     def build_new_button_clicked_cb(self, button):
         self.builder.initiate_new_build_async()
 

bitbake/lib/bb/ui/crumbs/packageselectionpage.py

@@ -150,8 +150,12 @@ class PackageSelectionPage (HobPage):
             sort_model = self.package_model.tree_model(filter, initial=True)
             tab.set_model(sort_model)
             tab.connect("toggled", self.table_toggled_cb, name)
-            tab.connect("button-release-event", self.button_click_cb)
-            tab.connect("cell-fadeinout-stopped", self.after_fadeout_checkin_include, filter)
+            if name == "Included packages":
+                tab.connect("button-release-event", self.button_click_cb)
+                tab.connect("cell-fadeinout-stopped", self.after_fadeout_checkin_include)
+            if name == "All packages":
+                tab.connect("button-release-event", self.button_click_cb)
+                tab.connect("cell-fadeinout-stopped", self.after_fadeout_checkin_include)
             self.ins.append_page(tab, page['name'], page['tooltip'])
             self.tables.append(tab)
 
@@ -195,7 +199,6 @@ class PackageSelectionPage (HobPage):
         if self.package_model.filtered_nb == 0:
             if not self.ins.get_nth_page(current_tab).top_bar:
                 self.ins.get_nth_page(current_tab).add_no_result_bar(entry)
-                self.ins.get_nth_page(current_tab).top_bar.set_no_show_all(True)
             self.ins.get_nth_page(current_tab).top_bar.show()
             self.ins.get_nth_page(current_tab).scroll.hide()
         else:
@@ -243,13 +246,6 @@ class PackageSelectionPage (HobPage):
         self.builder.parsing_warnings = []
         self.builder.build_image()
 
-    def refresh_tables(self):
-        self.ins.reset_entry(self.ins.search, 0)
-        for tab in self.tables:
-            index = self.tables.index(tab)
-            filter = self.pages[index]['filter']
-            tab.set_model(self.package_model.tree_model(filter, initial=True))
-
     def back_button_clicked_cb(self, button):
         if self.builder.previous_step ==  self.builder.IMAGE_GENERATED:
             self.builder.restore_initial_selected_packages()
@@ -257,7 +253,6 @@ class PackageSelectionPage (HobPage):
             self.builder.show_image_details()
         else:
             self.builder.show_configuration()
-        self.refresh_tables()
 
     def refresh_selection(self):
         self.builder.configuration.selected_packages = self.package_model.get_selected_packages()
@@ -266,19 +261,16 @@ class PackageSelectionPage (HobPage):
         selected_packages_size = self.package_model.get_packages_size()
         selected_packages_size_str = HobPage._size_to_string(selected_packages_size)
 
-        if self.builder.configuration.image_packages == self.builder.configuration.selected_packages:
-            image_total_size_str = self.builder.configuration.image_size
-        else:
-            image_overhead_factor = self.builder.configuration.image_overhead_factor
-            image_rootfs_size = self.builder.configuration.image_rootfs_size / 1024 # image_rootfs_size is KB
-            image_extra_size = self.builder.configuration.image_extra_size / 1024 # image_extra_size is KB
-            base_size = image_overhead_factor * selected_packages_size
-            image_total_size = max(base_size, image_rootfs_size) + image_extra_size
-            if "zypper" in self.builder.configuration.selected_packages:
-                image_total_size += (51200 * 1024)
-            image_total_size_str = HobPage._size_to_string(image_total_size)
+        image_overhead_factor = self.builder.configuration.image_overhead_factor
+        image_rootfs_size = self.builder.configuration.image_rootfs_size / 1024 # image_rootfs_size is KB
+        image_extra_size = self.builder.configuration.image_extra_size / 1024 # image_extra_size is KB
+        base_size = image_overhead_factor * selected_packages_size
+        image_total_size = max(base_size, image_rootfs_size) + image_extra_size
+        if "zypper" in self.builder.configuration.selected_packages:
+            image_total_size += (51200 * 1024)
+        image_total_size_str = HobPage._size_to_string(image_total_size)
 
-        self.label.set_label("Packages included: %s\nSelected packages size: %s\nEstimated image size: %s" %
+        self.label.set_label("Packages included: %s\nSelected packages size: %s\nTotal image size: %s" %
                             (selected_packages_num, selected_packages_size_str, image_total_size_str))
         self.ins.show_indicator_icon("Included packages", selected_packages_num)
 
@@ -286,21 +278,20 @@ class PackageSelectionPage (HobPage):
         if not self.package_model.path_included(path):
             self.package_model.include_item(item_path=path, binb="User Selected")
         else:
-            self.pre_fadeout_checkout_include(view_tree)
-            self.package_model.exclude_item(item_path=path)
-            self.render_fadeout(view_tree, cell)
+            if pagename == "Included packages":
+                self.pre_fadeout_checkout_include(view_tree)
+                self.package_model.exclude_item(item_path=path)
+                self.render_fadeout(view_tree, cell)
+            else:
+                self.package_model.exclude_item(item_path=path)
 
         self.refresh_selection()
         if not self.builder.customized:
             self.builder.customized = True
-            self.builder.configuration.initial_selected_image = self.builder.configuration.selected_image
             self.builder.configuration.selected_image = self.recipe_model.__custom_image__
             self.builder.rcppkglist_populated()
 
         self.builder.window_sensitive(True)
-        view_model = view_tree.get_model()
-        vpath = self.package_model.convert_path_to_vpath(view_model, path)
-        view_tree.set_cursor(vpath)
 
     def table_toggled_cb(self, table, cell, view_path, toggled_columnid, view_tree, pagename):
         # Click to include a package
@@ -310,15 +301,11 @@ class PackageSelectionPage (HobPage):
         glib.idle_add(self.toggle_item_idle_cb, path, view_tree, cell, pagename)
 
     def pre_fadeout_checkout_include(self, tree):
-        #after the fadeout the table will be sorted as before
-        self.sort_column_id = self.package_model.sort_column_id
-        self.sort_order = self.package_model.sort_order
-
         self.package_model.resync_fadeout_column(self.package_model.get_iter_first())
         # Check out a model which base on the column COL_FADE_INC,
         # it's save the prev state of column COL_INC before do exclude_item
         filter = { PackageListModel.COL_FADE_INC  : [True]}
-        new_model = self.package_model.tree_model(filter, excluded_items_ahead=True)
+        new_model = self.package_model.tree_model(filter)
         tree.set_model(new_model)
         tree.expand_all()
 
@@ -344,10 +331,8 @@ class PackageSelectionPage (HobPage):
 
         cell.fadeout(tree, 1000, to_render_cells)
 
-    def after_fadeout_checkin_include(self, table, ctrl, cell, tree, filter):
-        self.package_model.sort_column_id = self.sort_column_id
-        self.package_model.sort_order = self.sort_order
-        tree.set_model(self.package_model.tree_model(filter))
+    def after_fadeout_checkin_include(self, table, ctrl, cell, tree):
+        tree.set_model(self.package_model.tree_model(self.pages[0]['filter']))
         tree.expand_all()
 
     def set_packages_curr_tab(self, curr_page):

bitbake/lib/bb/ui/crumbs/recipeselectionpage.py

@@ -162,8 +162,15 @@ class RecipeSelectionPage (HobPage):
             sort_model = self.recipe_model.tree_model(filter, initial=True)
             tab.set_model(sort_model)
             tab.connect("toggled", self.table_toggled_cb, name)
-            tab.connect("button-release-event", self.button_click_cb)
-            tab.connect("cell-fadeinout-stopped", self.after_fadeout_checkin_include, filter)
+            if name == "Included recipes":
+                tab.connect("button-release-event", self.button_click_cb)
+                tab.connect("cell-fadeinout-stopped", self.after_fadeout_checkin_include)
+            if name == "Package Groups":
+                tab.connect("button-release-event", self.button_click_cb)
+                tab.connect("cell-fadeinout-stopped", self.after_fadeout_checkin_include)
+            if name == "All recipes":
+                tab.connect("button-release-event", self.button_click_cb)
+                tab.connect("cell-fadeinout-stopped", self.button_click_cb)
             self.ins.append_page(tab, page['name'], page['tooltip'])
             self.tables.append(tab)
 
@@ -207,7 +214,6 @@ class RecipeSelectionPage (HobPage):
         if self.recipe_model.filtered_nb == 0:
             if not self.ins.get_nth_page(current_tab).top_bar:
                 self.ins.get_nth_page(current_tab).add_no_result_bar(entry)
-                self.ins.get_nth_page(current_tab).top_bar.set_no_show_all(True)
             self.ins.get_nth_page(current_tab).top_bar.show()
             self.ins.get_nth_page(current_tab).scroll.hide()
         else:
@@ -237,22 +243,13 @@ class RecipeSelectionPage (HobPage):
             self.builder.show_recipe_property_dialog(properties)
 
     def build_packages_clicked_cb(self, button):
-        self.refresh_tables()
         self.builder.build_packages()
 
-    def refresh_tables(self):
-        self.ins.reset_entry(self.ins.search, 0)
-        for tab in self.tables:
-            index = self.tables.index(tab)
-            filter = self.pages[index]['filter']
-            tab.set_model(self.recipe_model.tree_model(filter, search_data="", initial=True))
-
     def back_button_clicked_cb(self, button):
         self.builder.recipe_model.set_selected_image(self.builder.configuration.initial_selected_image)
         self.builder.image_configuration_page.update_image_combo(self.builder.recipe_model, self.builder.configuration.initial_selected_image)
         self.builder.image_configuration_page.update_image_desc()
         self.builder.show_configuration()
-        self.refresh_tables()
 
     def refresh_selection(self):
         self.builder.configuration.selected_image = self.recipe_model.get_selected_image()
@@ -263,9 +260,12 @@ class RecipeSelectionPage (HobPage):
         if not self.recipe_model.path_included(path):
             self.recipe_model.include_item(item_path=path, binb="User Selected", image_contents=False)
         else:
-            self.pre_fadeout_checkout_include(view_tree, pagename)
-            self.recipe_model.exclude_item(item_path=path)
-            self.render_fadeout(view_tree, cell)
+            if pagename == "Included recipes":
+                self.pre_fadeout_checkout_include(view_tree)
+                self.recipe_model.exclude_item(item_path=path)
+                self.render_fadeout(view_tree, cell)
+            else:
+                self.recipe_model.exclude_item(item_path=path)
 
         self.refresh_selection()
         if not self.builder.customized:
@@ -275,10 +275,6 @@ class RecipeSelectionPage (HobPage):
 
         self.builder.window_sensitive(True)
 
-        view_model = view_tree.get_model()
-        vpath = self.recipe_model.convert_path_to_vpath(view_model, path)
-        view_tree.set_cursor(vpath)
-
     def table_toggled_cb(self, table, cell, view_path, toggled_columnid, view_tree, pagename):
         # Click to include a recipe
         self.builder.window_sensitive(False)
@@ -286,11 +282,7 @@ class RecipeSelectionPage (HobPage):
         path = self.recipe_model.convert_vpath_to_path(view_model, view_path)
         glib.idle_add(self.toggle_item_idle_cb, path, view_tree, cell, pagename)
 
-    def pre_fadeout_checkout_include(self, tree, pagename):
-        #after the fadeout the table will be sorted as before
-        self.sort_column_id = self.recipe_model.sort_column_id
-        self.sort_order = self.recipe_model.sort_order
-
+    def pre_fadeout_checkout_include(self, tree):
         #resync the included items to a backup fade include column
         it = self.recipe_model.get_iter_first()
         while it:
@@ -299,14 +291,8 @@ class RecipeSelectionPage (HobPage):
             it = self.recipe_model.iter_next(it)
         # Check out a model which base on the column COL_FADE_INC,
         # it's save the prev state of column COL_INC before do exclude_item
-        filter = { RecipeListModel.COL_FADE_INC:[True] }
-        if pagename == "Included recipes":
-            filter[RecipeListModel.COL_TYPE] = ['recipe', 'packagegroup']
-        elif pagename == "All recipes":
-            filter[RecipeListModel.COL_TYPE] = ['recipe']
-        else:
-            filter[RecipeListModel.COL_TYPE] = ['packagegroup']
-
+        filter = { RecipeListModel.COL_FADE_INC  : [True],
+                   RecipeListModel.COL_TYPE      : ['recipe', 'packagegroup'] }
         new_model = self.recipe_model.tree_model(filter, excluded_items_ahead=True)
         tree.set_model(new_model)
 
@@ -326,10 +312,8 @@ class RecipeSelectionPage (HobPage):
 
         cell.fadeout(tree, 1000, to_render_cells)
 
-    def after_fadeout_checkin_include(self, table, ctrl, cell, tree, filter):
-        self.recipe_model.sort_column_id = self.sort_column_id
-        self.recipe_model.sort_order = self.sort_order
-        tree.set_model(self.recipe_model.tree_model(filter))
+    def after_fadeout_checkin_include(self, table, ctrl, cell, tree):
+        tree.set_model(self.recipe_model.tree_model(self.pages[0]['filter']))
 
     def set_recipe_curr_tab(self, curr_page):
         self.ins.set_current_page(curr_page)

bitbake/lib/bb/ui/crumbs/runningbuild.py

@@ -375,16 +375,10 @@ class RunningBuild (gobject.GObject):
                 r = "R"
             else:
                 r = ""
-
-            extra = ''
-            if not event._reasons:
-                if event._close_matches:
-                    extra = ". Close matches:\n  %s" % '\n  '.join(event._close_matches)
-
             if event._dependees:
-                msg = "Nothing %sPROVIDES '%s' (but %s %sDEPENDS on or otherwise requires it)%s\n" % (r, event._item, ", ".join(event._dependees), r, extra)
+                msg = "Nothing %sPROVIDES '%s' (but %s %sDEPENDS on or otherwise requires it)\n" % (r, event._item, ", ".join(event._dependees), r)
             else:
-                msg = "Nothing %sPROVIDES '%s'%s\n" % (r, event._item, extra)
+                msg = "Nothing %sPROVIDES '%s'\n" % (r, event._item)
             if event._reasons:
                 for reason in event._reasons:
                     msg += ("%s\n" % reason)

bitbake/lib/bb/ui/crumbs/template.py

@@ -0,0 +1,187 @@
+#
+# BitBake Graphical GTK User Interface
+#
+# Copyright (C) 2011        Intel Corporation
+#
+# Authored by Shane Wang <shane.wang@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 os
+import re
+
+class File(gobject.GObject):
+
+    def __init__(self, pathfilename, suffix):
+        if not pathfilename.endswith(suffix):
+            pathfilename = "%s%s" % (pathfilename, suffix)
+        gobject.GObject.__init__(self)
+        self.pathfilename = pathfilename
+
+    def readFile(self):
+        if not os.path.isfile(self.pathfilename):
+            return None
+        if not os.path.exists(self.pathfilename):
+            return None
+
+        with open(self.pathfilename, 'r') as f:
+            contents = f.readlines()
+        f.close()
+
+        return contents
+
+    def writeFile(self, contents):
+        if os.path.exists(self.pathfilename):
+            orig = "%s.orig" % self.pathfilename
+            if os.path.exists(orig):
+                os.remove(orig)
+            os.rename(self.pathfilename, orig)
+
+        with open(self.pathfilename, 'w') as f:
+            f.write(contents)
+        f.close()
+
+class ConfigFile(File):
+    """
+    This object does save general config file. (say bblayers.conf, or local.conf). Again, it is the base class for other template files and image bb files.
+    """
+    def __init__(self, pathfilename, suffix = None, header = None):
+        if suffix:
+            File.__init__(self, pathfilename, suffix)
+        else:
+            File.__init__(self, pathfilename, ".conf")
+        if header:
+            self.header = header
+        else:
+            self.header = "# Config generated by Hob\n\n"
+        self.dictionary = {}
+
+    def setVar(self, var, val):
+        if isinstance(val, list):
+            liststr = ""
+            if val:
+                i = 0
+                for value in val:
+                    if i < len(val) - 1:
+                        liststr += "%s " % value
+                    else:
+                        liststr += "%s" % value
+                    i += 1
+            self.dictionary[var] = liststr
+        else:
+            self.dictionary[var] = val
+
+    def save(self):
+        contents = self.header
+        for var, val in self.dictionary.items():
+            contents += "%s = \"%s\"\n" % (var, val)
+        File.writeFile(self, contents)
+
+class HobTemplateFile(ConfigFile):
+    """
+    This object does save or load hob specific file.
+    """
+    def __init__(self, pathfilename):
+        ConfigFile.__init__(self, pathfilename, ".hob", "# Hob Template generated by Hob\n\n")
+
+    def getVar(self, var):
+        if var in self.dictionary: 
+            return self.dictionary[var]
+        else:
+            return ""
+
+    def getVersion(self):
+        contents = ConfigFile.readFile(self)
+
+        pattern = "^\s*(\S+)\s*=\s*(\".*?\")"
+
+        for line in contents:
+            match = re.search(pattern, line)
+            if match:
+                if match.group(1) == "VERSION":
+                    return match.group(2).strip('"')
+        return None
+
+    def load(self):
+        contents = ConfigFile.readFile(self)
+        self.dictionary.clear()
+
+        pattern = "^\s*(\S+)\s*=\s*(\".*?\")"
+
+        for line in contents:
+            match = re.search(pattern, line)
+            if match:
+                var = match.group(1)
+                val = match.group(2).strip('"')
+                self.dictionary[var] = val
+        return self.dictionary
+
+class RecipeFile(ConfigFile):
+    """
+    This object is for image bb file.
+    """
+    def __init__(self, pathfilename):
+        ConfigFile.__init__(self, pathfilename, ".bb", "# Recipe generated by Hob\n\ninherit core-image\n")
+
+class TemplateMgr(gobject.GObject):
+
+    __gRecipeVars__ = ["DEPENDS", "IMAGE_INSTALL"]
+
+    def __init__(self):
+        gobject.GObject.__init__(self)
+        self.template_hob = None
+        self.bblayers_conf = None
+        self.local_conf = None
+        self.image_bb = None
+
+    @classmethod
+    def convert_to_template_pathfilename(cls, filename, path):
+        return "%s/%s%s%s" % (path, "template-", filename, ".hob")
+
+    @classmethod
+    def convert_to_image_pathfilename(cls, filename, path):
+        return "%s/%s%s%s" % (path, "hob-image-", filename, ".bb")
+
+    def open(self, filename, path):
+        self.template_hob = HobTemplateFile(TemplateMgr.convert_to_template_pathfilename(filename, path))
+        self.image_bb = RecipeFile(TemplateMgr.convert_to_image_pathfilename(filename, path))
+
+    def setVar(self, var, val):
+        if var in TemplateMgr.__gRecipeVars__:
+            self.image_bb.setVar(var, val)
+
+        self.template_hob.setVar(var, val)
+
+    def save(self):
+        self.image_bb.save()
+        self.template_hob.save()
+
+    def getVersion(self, path):
+        return HobTemplateFile(path).getVersion()
+
+    def load(self, path):
+        self.template_hob = HobTemplateFile(path)
+        self.dictionary = self.template_hob.load()
+
+    def getVar(self, var):
+        return self.template_hob.getVar(var)
+
+    def destroy(self):
+        if self.template_hob:
+            del self.template_hob
+            template_hob = None
+        if self.image_bb:
+            del self.image_bb
+            self.image_bb = None

bitbake/lib/bb/ui/depexp.py

@@ -154,7 +154,7 @@ class DepExplorer(gtk.Window):
 
     def on_cursor_changed(self, selection):
         (model, it) = selection.get_selected()
-        if it is None:
+        if iter is None:
             current_package = None
         else:
             current_package = model.get_value(it, COL_PKG_NAME)
@@ -163,17 +163,23 @@ class DepExplorer(gtk.Window):
         self.revdep_treeview.set_current_package(current_package)
 
 
-    def parse(self, depgraph):
-        for package in depgraph["pn"]:
-            self.pkg_model.insert(0, (package,))
+def parse(depgraph, pkg_model, depends_model):
+    for package in depgraph["pn"]:
+        pkg_model.set(pkg_model.append(), COL_PKG_NAME, package)
 
-        for package in depgraph["depends"]:
-            for depend in depgraph["depends"][package]:
-                self.depends_model.insert (0, (TYPE_DEP, package, depend))
+    for package in depgraph["depends"]:
+        for depend in depgraph["depends"][package]:
+            depends_model.set (depends_model.append(),
+                              COL_DEP_TYPE, TYPE_DEP,
+                              COL_DEP_PARENT, package,
+                              COL_DEP_PACKAGE, depend)
 
-        for package in depgraph["rdepends-pn"]:
-            for rdepend in depgraph["rdepends-pn"][package]:
-                self.depends_model.insert (0, (TYPE_RDEP, package, rdepend))
+    for package in depgraph["rdepends-pn"]:
+        for rdepend in depgraph["rdepends-pn"][package]:
+            depends_model.set (depends_model.append(),
+                              COL_DEP_TYPE, TYPE_RDEP,
+                              COL_DEP_PARENT, package,
+                              COL_DEP_PACKAGE, rdepend)
 
 
 class gtkthread(threading.Thread):
@@ -190,18 +196,16 @@ class gtkthread(threading.Thread):
         gtkthread.quit.set()
 
 
-def main(server, eventHandler, params):
+def main(server, eventHandler):
     try:
-        params.updateFromServer(server)
-        cmdline = params.parseActions()
-        if not cmdline:
+        cmdline, error = server.runCommand(["getCmdLineAction"])
+        if error:
+            print("Error getting bitbake commandline: %s" % error)
+            return 1
+        elif not cmdline:
             print("Nothing to do.  Use 'bitbake world' to build everything, or run 'bitbake --help' for usage information.")
             return 1
-        if 'msg' in cmdline and cmdline['msg']:
-            logger.error(cmdline['msg'])
-            return 1
-        cmdline = cmdline['action']
-        if not cmdline or cmdline[0] != "generateDotGraph":
+        elif not cmdline or cmdline[0] != "generateDotGraph":
             print("This UI is only compatible with the -g option")
             return 1
         ret, error = server.runCommand(["generateDepTreeEvent", cmdline[1], cmdline[2]])
@@ -287,7 +291,7 @@ def main(server, eventHandler, params):
 
             if isinstance(event, bb.event.DepTreeGenerated):
                 gtk.gdk.threads_enter()
-                dep.parse(event._depgraph)
+                parse(event._depgraph, dep.pkg_model, dep.depends_model)
                 gtk.gdk.threads_leave()
 
             if isinstance(event, bb.command.CommandCompleted):
@@ -314,7 +318,7 @@ def main(server, eventHandler, params):
                 break
             if shutdown == 1:
                 print("\nSecond Keyboard Interrupt, stopping...\n")
-                _, error = server.runCommand(["stateForceShutdown"])
+                _, error = server.runCommand(["stateStop"])
                 if error:
                     print('Unable to cleanly stop: %s' % error)
             if shutdown == 0:

bitbake/lib/bb/ui/goggle.py

@@ -63,7 +63,7 @@ class MainWindow (gtk.Window):
         scrolled_window.add (self.cur_build_tv)
 
 
-def main (server, eventHandler, params):
+def main (server, eventHandler):
     gobject.threads_init()
     gtk.gdk.threads_init()
 
@@ -80,15 +80,13 @@ def main (server, eventHandler, params):
     running_build.connect ("build-failed", running_build_failed_cb)
 
     try:
-        params.updateFromServer(server)
-        cmdline = params.parseActions()
-        if not cmdline:
+        cmdline, error = server.runCommand(["getCmdLineAction"])
+        if error:
+            print("Error getting bitbake commandline: %s" % error)
+            return 1
+        elif not cmdline:
             print("Nothing to do.  Use 'bitbake world' to build everything, or run 'bitbake --help' for usage information.")
             return 1
-        if 'msg' in cmdline and cmdline['msg']:
-            logger.error(cmdline['msg'])
-            return 1
-        cmdline = cmdline['action']
         ret, error = server.runCommand(cmdline)
         if error:
             print("Error running command '%s': %s" % (cmdline, error))
@@ -117,5 +115,5 @@ def main (server, eventHandler, params):
     except KeyboardInterrupt:
         pass
     finally:
-        server.runCommand(["stateForceShutdown"])
+        server.runCommand(["stateStop"])
 

bitbake/lib/bb/ui/hob.py

@@ -46,7 +46,7 @@ from bb.ui.crumbs.hoblistmodel import RecipeListModel, PackageListModel
 from bb.ui.crumbs.hobeventhandler import HobHandler
 from bb.ui.crumbs.builder import Builder
 
-featureSet = [bb.cooker.CookerFeatures.HOB_EXTRA_CACHES]
+extraCaches = ['bb.cache_extra:HobRecipeInfo']
 
 def event_handle_idle_func(eventHandler, hobHandler):
     # Consume as many messages as we can in the time available to us
@@ -58,21 +58,7 @@ def event_handle_idle_func(eventHandler, hobHandler):
         event = eventHandler.getEvent()
     return True
 
-_evt_list = [ "bb.runqueue.runQueueExitWait", "bb.event.LogExecTTY", "logging.LogRecord",
-              "bb.build.TaskFailed", "bb.build.TaskBase", "bb.event.ParseStarted",
-              "bb.event.ParseProgress", "bb.event.ParseCompleted", "bb.event.CacheLoadStarted",
-              "bb.event.CacheLoadProgress", "bb.event.CacheLoadCompleted", "bb.command.CommandFailed",
-              "bb.command.CommandExit", "bb.command.CommandCompleted",  "bb.cooker.CookerExit",
-              "bb.event.MultipleProviders", "bb.event.NoProvider", "bb.runqueue.sceneQueueTaskStarted",
-              "bb.runqueue.runQueueTaskStarted", "bb.runqueue.runQueueTaskFailed", "bb.runqueue.sceneQueueTaskFailed",
-              "bb.event.BuildBase", "bb.build.TaskStarted", "bb.build.TaskSucceeded", "bb.build.TaskFailedSilent",
-              "bb.event.SanityCheckPassed", "bb.event.SanityCheckFailed", "bb.event.PackageInfo",
-              "bb.event.TargetsTreeGenerated", "bb.event.ConfigFilesFound", "bb.event.ConfigFilePathFound",
-              "bb.event.FilesMatchingFound", "bb.event.NetworkTestFailed", "bb.event.NetworkTestPassed",
-              "bb.event.BuildStarted", "bb.event.BuildCompleted", "bb.event.DiskFull"]
-
-def main (server, eventHandler, params):
-    params.updateFromServer(server)
+def main (server = None, eventHandler = None):
     gobject.threads_init()
 
     # That indicates whether the Hob and the bitbake server are
@@ -81,8 +67,6 @@ def main (server, eventHandler, params):
     recipe_model = RecipeListModel()
     package_model = PackageListModel()
 
-    llevel, debug_domains = bb.msg.constructLogOptions()
-    server.runCommand(["setEventMask", server.getEventHandle(), llevel, debug_domains, _evt_list])
     hobHandler = HobHandler(server, recipe_model, package_model)
     builder = Builder(hobHandler, recipe_model, package_model)
 

bitbake/lib/bb/ui/knotty.py

@@ -201,11 +201,11 @@ class TerminalFilter(object):
             content = "No currently running tasks (%s of %s)" % (self.helper.tasknumber_current, self.helper.tasknumber_total)
         else:
             content = "Currently %s running tasks (%s of %s):" % (len(activetasks), self.helper.tasknumber_current, self.helper.tasknumber_total)
-        print(content)
+        print content
         lines = 1 + int(len(content) / (self.columns + 1))
         for tasknum, task in enumerate(tasks):
             content = "%s: %s" % (tasknum, task)
-            print(content)
+            print content
             lines = lines + 1 + int(len(content) / (self.columns + 1))
         self.footer_present = lines
         self.lastpids = runningpids[:]
@@ -216,34 +216,21 @@ class TerminalFilter(object):
             fd = sys.stdin.fileno()
             self.termios.tcsetattr(fd, self.termios.TCSADRAIN, self.stdinbackup)
 
-def _log_settings_from_server(server):
+def main(server, eventHandler, tf = TerminalFilter):
+
     # Get values of variables which control our output
     includelogs, error = server.runCommand(["getVariable", "BBINCLUDELOGS"])
     if error:
         logger.error("Unable to get the value of BBINCLUDELOGS variable: %s" % error)
-        raise BaseException(error)
+        return 1
     loglines, error = server.runCommand(["getVariable", "BBINCLUDELOGS_LINES"])
     if error:
         logger.error("Unable to get the value of BBINCLUDELOGS_LINES variable: %s" % error)
-        raise BaseException(error)
+        return 1
     consolelogfile, error = server.runCommand(["getVariable", "BB_CONSOLELOG"])
     if error:
         logger.error("Unable to get the value of BB_CONSOLELOG variable: %s" % error)
-        raise BaseException(error)
-    return includelogs, loglines, consolelogfile
-
-_evt_list = [ "bb.runqueue.runQueueExitWait", "bb.event.LogExecTTY", "logging.LogRecord",
-              "bb.build.TaskFailed", "bb.build.TaskBase", "bb.event.ParseStarted",
-              "bb.event.ParseProgress", "bb.event.ParseCompleted", "bb.event.CacheLoadStarted",
-              "bb.event.CacheLoadProgress", "bb.event.CacheLoadCompleted", "bb.command.CommandFailed",
-              "bb.command.CommandExit", "bb.command.CommandCompleted",  "bb.cooker.CookerExit",
-              "bb.event.MultipleProviders", "bb.event.NoProvider", "bb.runqueue.sceneQueueTaskStarted",
-              "bb.runqueue.runQueueTaskStarted", "bb.runqueue.runQueueTaskFailed", "bb.runqueue.sceneQueueTaskFailed",
-              "bb.event.BuildBase", "bb.build.TaskStarted", "bb.build.TaskSucceeded", "bb.build.TaskFailedSilent"]
-
-def main(server, eventHandler, params, tf = TerminalFilter):
-
-    includelogs, loglines, consolelogfile = _log_settings_from_server(server)
+        return 1
 
     if sys.stdin.isatty() and sys.stdout.isatty():
         log_exec_tty = True
@@ -258,12 +245,7 @@ def main(server, eventHandler, params, tf = TerminalFilter):
     bb.msg.addDefaultlogFilter(console)
     console.setFormatter(format)
     logger.addHandler(console)
-
-    if params.options.remote_server and params.options.kill_server:
-        server.terminateServer()
-        return
-
-    if consolelogfile and not params.options.show_environment:
+    if consolelogfile:
         bb.utils.mkdirhier(os.path.dirname(consolelogfile))
         conlogformat = bb.msg.BBLogFormatter(format_str)
         consolelog = logging.FileHandler(consolelogfile)
@@ -271,27 +253,24 @@ def main(server, eventHandler, params, tf = TerminalFilter):
         consolelog.setFormatter(conlogformat)
         logger.addHandler(consolelog)
 
-    llevel, debug_domains = bb.msg.constructLogOptions()
-    server.runCommand(["setEventMask", server.getEventHandle(), llevel, debug_domains, _evt_list])
-
-    if not params.observe_only:
-        params.updateFromServer(server)
-        cmdline = params.parseActions()
-        if not cmdline:
+    try:
+        cmdline, error = server.runCommand(["getCmdLineAction"])
+        if error:
+            logger.error("Unable to get bitbake commandline arguments: %s" % error)
+            return 1
+        elif not cmdline:
             print("Nothing to do.  Use 'bitbake world' to build everything, or run 'bitbake --help' for usage information.")
             return 1
-        if 'msg' in cmdline and cmdline['msg']:
-            logger.error(cmdline['msg'])
-            return 1
-
-        ret, error = server.runCommand(cmdline['action'])
+        ret, error = server.runCommand(cmdline)
         if error:
             logger.error("Command '%s' failed: %s" % (cmdline, error))
             return 1
         elif ret != True:
             logger.error("Command '%s' failed: returned %s" % (cmdline, ret))
             return 1
-
+    except xmlrpclib.Fault as x:
+        logger.error("XMLRPC Fault getting commandline:\n %s" % x)
+        return 1
 
     parseprogress = None
     cacheprogress = None
@@ -306,10 +285,8 @@ def main(server, eventHandler, params, tf = TerminalFilter):
 
     while True:
         try:
-            event = eventHandler.waitEvent(0)
-            if event is None:
-                termfilter.updateFooter()
-                event = eventHandler.waitEvent(0.25)
+            termfilter.updateFooter()
+            event = eventHandler.waitEvent(0.25)
             if event is None:
                 if main.shutdown > 1:
                     break
@@ -323,7 +300,7 @@ def main(server, eventHandler, params, tf = TerminalFilter):
                 if log_exec_tty:
                     tries = event.retries
                     while tries:
-                        print("Trying to run: %s" % event.prog)
+                        print "Trying to run: %s" % event.prog
                         if os.system(event.prog) == 0:
                             break
                         time.sleep(event.sleep_delay)
@@ -340,7 +317,7 @@ def main(server, eventHandler, params, tf = TerminalFilter):
                 elif event.levelno == format.WARNING:
                     warnings = warnings + 1
                 # For "normal" logging conditions, don't show note logs from tasks
-                # but do show them if the user has changed the default log level to
+                # but do show them if the user has changed the default log level to 
                 # include verbose/debug messages
                 if event.taskpid != 0 and event.levelno <= format.NOTE:
                     continue
@@ -405,9 +382,8 @@ def main(server, eventHandler, params, tf = TerminalFilter):
 
             if isinstance(event, bb.command.CommandFailed):
                 return_value = event.exitcode
-                if event.error:
-                    errors = errors + 1
-                    logger.error("Command execution failed: %s", event.error)
+                errors = errors + 1
+                logger.error("Command execution failed: %s", event.error)
                 main.shutdown = 2
                 continue
             if isinstance(event, bb.command.CommandExit):
@@ -431,15 +407,10 @@ def main(server, eventHandler, params, tf = TerminalFilter):
                 else:
                     r = ""
 
-                extra = ''
-                if not event._reasons:
-                    if event._close_matches:
-                        extra = ". Close matches:\n  %s" % '\n  '.join(event._close_matches)
-
                 if event._dependees:
-                    logger.error("Nothing %sPROVIDES '%s' (but %s %sDEPENDS on or otherwise requires it)%s", r, event._item, ", ".join(event._dependees), r, extra)
+                    logger.error("Nothing %sPROVIDES '%s' (but %s %sDEPENDS on or otherwise requires it)", r, event._item, ", ".join(event._dependees), r)
                 else:
-                    logger.error("Nothing %sPROVIDES '%s'%s", r, event._item, extra)
+                    logger.error("Nothing %sPROVIDES '%s'", r, event._item)
                 if event._reasons:
                     for reason in event._reasons:
                         logger.error("%s", reason)
@@ -472,12 +443,8 @@ def main(server, eventHandler, params, tf = TerminalFilter):
                              event.taskid, event.taskstring, event.exitcode)
                 continue
 
-            if isinstance(event, bb.event.DepTreeGenerated):
-                continue
-
             # ignore
             if isinstance(event, (bb.event.BuildBase,
-                                  bb.event.MetadataEvent,
                                   bb.event.StampUpdate,
                                   bb.event.ConfigParsed,
                                   bb.event.RecipeParsed,
@@ -499,15 +466,12 @@ def main(server, eventHandler, params, tf = TerminalFilter):
                 pass
         except KeyboardInterrupt:
             termfilter.clearFooter()
-            if params.observe_only:
-                print("\nKeyboard Interrupt, exiting observer...")
-                main.shutdown = 2
-            if not params.observe_only and main.shutdown == 1:
+            if main.shutdown == 1:
                 print("\nSecond Keyboard Interrupt, stopping...\n")
-                _, error = server.runCommand(["stateForceShutdown"])
+                _, error = server.runCommand(["stateStop"])
                 if error:
                     logger.error("Unable to cleanly stop: %s" % error)
-            if not params.observe_only and main.shutdown == 0:
+            if main.shutdown == 0:
                 print("\nKeyboard Interrupt, closing down...\n")
                 interrupted = True
                 _, error = server.runCommand(["stateShutdown"])
@@ -525,7 +489,7 @@ def main(server, eventHandler, params, tf = TerminalFilter):
     if warnings:
         summary += pluralise("\nSummary: There was %s WARNING message shown.",
                              "\nSummary: There were %s WARNING messages shown.", warnings)
-    if return_value and errors:
+    if return_value:
         summary += pluralise("\nSummary: There was %s ERROR message shown, returning a non-zero exit code.",
                              "\nSummary: There were %s ERROR messages shown, returning a non-zero exit code.", errors)
     if summary:

bitbake/lib/bb/ui/ncurses.py

@@ -196,7 +196,7 @@ class NCursesUI:
 #            t.start()
 
     #-------------------------------------------------------------------------#
-    def main(self, stdscr, server, eventHandler, params):
+    def main(self, stdscr, server, eventHandler):
     #-------------------------------------------------------------------------#
         height, width = stdscr.getmaxyx()
 
@@ -236,15 +236,13 @@ class NCursesUI:
         shutdown = 0
 
         try:
-            params.updateFromServer(server)
-            cmdline = params.parseActions()
+            cmdline, error = server.runCommand(["getCmdLineAction"])
             if not cmdline:
                 print("Nothing to do.  Use 'bitbake world' to build everything, or run 'bitbake --help' for usage information.")
-                return 1
-            if 'msg' in cmdline and cmdline['msg']:
-                logger.error(cmdline['msg'])
-                return 1
-            cmdline = cmdline['action']
+                return
+            elif error:
+                print("Error getting bitbake commandline: %s" % error)
+                return
             ret, error = server.runCommand(cmdline)
             if error:
                 print("Error running command '%s': %s" % (cmdline, error))
@@ -350,7 +348,7 @@ class NCursesUI:
                     exitflag = True
                 if shutdown == 1:
                     mw.appendText("Second Keyboard Interrupt, stopping...\n")
-                    _, error = server.runCommand(["stateForceShutdown"])
+                    _, error = server.runCommand(["stateStop"])
                     if error:
                         print("Unable to cleanly stop: %s" % error)
                 if shutdown == 0:

bitbake/lib/bb/ui/toasterui.py

@@ -1,272 +0,0 @@
-#
-# BitBake ToasterUI Implementation
-# based on (No)TTY UI Implementation by Richard Purdie
-#
-# Handling output to TTYs or files (no TTY)
-#
-# Copyright (C) 2006-2012 Richard Purdie
-# Copyright (C) 2013      Intel Corporation
-#
-# 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.
-
-from __future__ import division
-try:
-    import bb
-except RuntimeError as exc:
-    sys.exit(str(exc))
-
-from bb.ui import uihelper
-from bb.ui.buildinfohelper import BuildInfoHelper
-
-import bb.msg
-import copy
-import fcntl
-import logging
-import os
-import progressbar
-import signal
-import struct
-import sys
-import time
-import xmlrpclib
-
-featureSet = [bb.cooker.CookerFeatures.HOB_EXTRA_CACHES, bb.cooker.CookerFeatures.SEND_DEPENDS_TREE]
-
-logger = logging.getLogger("BitBake")
-interactive = sys.stdout.isatty()
-
-
-
-def _log_settings_from_server(server):
-    # Get values of variables which control our output
-    includelogs, error = server.runCommand(["getVariable", "BBINCLUDELOGS"])
-    if error:
-        logger.error("Unable to get the value of BBINCLUDELOGS variable: %s" % error)
-        raise BaseException(error)
-    loglines, error = server.runCommand(["getVariable", "BBINCLUDELOGS_LINES"])
-    if error:
-        logger.error("Unable to get the value of BBINCLUDELOGS_LINES variable: %s" % error)
-        raise BaseException(error)
-    return includelogs, loglines
-
-def main(server, eventHandler, params ):
-
-    includelogs, loglines = _log_settings_from_server(server)
-
-    # verify and warn
-    build_history_enabled = True
-    inheritlist, error = server.runCommand(["getVariable", "INHERIT"])
-    if not "buildhistory" in inheritlist.split(" "):
-        logger.warn("buildhistory is not enabled. Please enable INHERIT += \"buildhistory\" to see image details.")
-        build_history_enabled = False
-
-    helper = uihelper.BBUIHelper()
-
-    console = logging.StreamHandler(sys.stdout)
-    format_str = "%(levelname)s: %(message)s"
-    format = bb.msg.BBLogFormatter(format_str)
-    bb.msg.addDefaultlogFilter(console)
-    console.setFormatter(format)
-    logger.addHandler(console)
-
-    if not params.observe_only:
-        logger.error("ToasterUI can only work in observer mode")
-        return
-
-
-    main.shutdown = 0
-    interrupted = False
-    return_value = 0
-    errors = 0
-    warnings = 0
-    taskfailures = []
-
-    buildinfohelper = BuildInfoHelper(server, build_history_enabled)
-    buildinfohelper.store_layer_info()
-
-
-    while True:
-        try:
-            event = eventHandler.waitEvent(0.25)
-
-            if event is None:
-                if main.shutdown > 0:
-                    break
-                continue
-
-            helper.eventHandler(event)
-
-            if isinstance(event, bb.event.BuildStarted):
-                buildinfohelper.store_started_build(event)
-
-            if isinstance(event, (bb.build.TaskStarted, bb.build.TaskSucceeded, bb.build.TaskFailedSilent)):
-                buildinfohelper.update_and_store_task(event)
-                continue
-
-            if isinstance(event, bb.event.LogExecTTY):
-                logger.warn(event.msg)
-                continue
-
-            if isinstance(event, logging.LogRecord):
-                buildinfohelper.store_log_event(event)
-                if event.levelno >= format.ERROR:
-                    errors = errors + 1
-                    return_value = 1
-                elif event.levelno == format.WARNING:
-                    warnings = warnings + 1
-                # For "normal" logging conditions, don't show note logs from tasks
-                # but do show them if the user has changed the default log level to
-                # include verbose/debug messages
-                if event.taskpid != 0 and event.levelno <= format.NOTE:
-                    continue
-
-                logger.handle(event)
-                continue
-
-            if isinstance(event, bb.build.TaskFailed):
-                buildinfohelper.update_and_store_task(event)
-                return_value = 1
-                logfile = event.logfile
-                if logfile and os.path.exists(logfile):
-                    bb.error("Logfile of failure stored in: %s" % logfile)
-                continue
-
-            # these events are unprocessed now, but may be used in the future to log
-            # timing and error informations from the parsing phase in Toaster
-            if isinstance(event, bb.event.ParseStarted):
-                continue
-            if isinstance(event, bb.event.ParseProgress):
-                continue
-            if isinstance(event, bb.event.ParseCompleted):
-                continue
-            if isinstance(event, bb.event.CacheLoadStarted):
-                continue
-            if isinstance(event, bb.event.CacheLoadProgress):
-                continue
-            if isinstance(event, bb.event.CacheLoadCompleted):
-                continue
-            if isinstance(event, bb.event.MultipleProviders):
-                continue
-            if isinstance(event, bb.event.NoProvider):
-                return_value = 1
-                errors = errors + 1
-                if event._runtime:
-                    r = "R"
-                else:
-                    r = ""
-
-                if event._dependees:
-                    text = "Nothing %sPROVIDES '%s' (but %s %sDEPENDS on or otherwise requires it)" % (r, event._item, ", ".join(event._dependees), r)
-                else:
-                    text = "Nothing %sPROVIDES '%s'" % (r, event._item)
-
-                logger.error(text)
-                if event._reasons:
-                    for reason in event._reasons:
-                        logger.error("%s", reason)
-                        text += reason
-                buildinfohelper.store_log_error(text)
-                continue
-
-            if isinstance(event, bb.event.ConfigParsed):
-                continue
-            if isinstance(event, bb.event.RecipeParsed):
-                continue
-
-            # end of saved events
-
-            if isinstance(event, (bb.runqueue.sceneQueueTaskStarted, bb.runqueue.runQueueTaskStarted, bb.runqueue.runQueueTaskSkipped)):
-                buildinfohelper.store_started_task(event)
-                continue
-
-            if isinstance(event, bb.runqueue.runQueueTaskCompleted):
-                buildinfohelper.update_and_store_task(event)
-                continue
-
-            if isinstance(event, bb.runqueue.runQueueTaskFailed):
-                buildinfohelper.update_and_store_task(event)
-                taskfailures.append(event.taskstring)
-                logger.error("Task %s (%s) failed with exit code '%s'",
-                             event.taskid, event.taskstring, event.exitcode)
-                continue
-
-            if isinstance(event, (bb.runqueue.sceneQueueTaskCompleted, bb.runqueue.sceneQueueTaskFailed)):
-                buildinfohelper.update_and_store_task(event)
-                continue
-
-
-            if isinstance(event, (bb.event.TreeDataPreparationStarted, bb.event.TreeDataPreparationCompleted)):
-                continue
-
-            if isinstance(event, (bb.event.BuildCompleted)):
-                buildinfohelper.read_target_package_dep_data(event)
-                buildinfohelper.update_build_information(event, errors, warnings, taskfailures)
-                continue
-
-            if isinstance(event, (bb.command.CommandCompleted,
-                                  bb.command.CommandFailed,
-                                  bb.command.CommandExit)):
-
-                buildinfohelper.update_build_information(event, errors, warnings, taskfailures)
-
-                # we start a new build info
-                errors = 0
-                warnings = 0
-                taskfailures = []
-                buildinfohelper = BuildInfoHelper(server, build_history_enabled)
-                buildinfohelper.store_layer_info()
-                continue
-
-            if isinstance(event, bb.event.MetadataEvent):
-                if event.type == "SinglePackageInfo":
-                    buildinfohelper.store_build_package_information(event)
-                continue
-
-            # ignore
-            if isinstance(event, (bb.event.BuildBase,
-                                  bb.event.StampUpdate,
-                                  bb.event.RecipePreFinalise,
-                                  bb.runqueue.runQueueEvent,
-                                  bb.runqueue.runQueueExitWait,
-                                  bb.event.OperationProgress,
-                                  bb.command.CommandFailed,
-                                  bb.command.CommandExit,
-                                  bb.command.CommandCompleted,
-                                  bb.cooker.CookerExit)):
-                continue
-
-            if isinstance(event, bb.event.DepTreeGenerated):
-                buildinfohelper.store_dependency_information(event)
-                continue
-
-            logger.error("Unknown event: %s", event)
-
-        except EnvironmentError as ioerror:
-            # ignore interrupted io
-            if ioerror.args[0] == 4:
-                pass
-        except KeyboardInterrupt:
-            main.shutdown = 1
-            pass
-        except Exception as e:
-            logger.error(e)
-            import traceback
-            traceback.print_exc()
-            pass
-
-    if interrupted:
-        if return_value == 0:
-            return_value = 1
-
-    return return_value

bitbake/lib/bb/ui/uievent.py

@@ -28,7 +28,7 @@ import socket, threading, pickle
 from SimpleXMLRPCServer import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler
 
 class BBUIEventQueue:
-    def __init__(self, BBServer, clientinfo=("localhost, 0"), featureset=[]):
+    def __init__(self, BBServer, clientinfo=("localhost, 0")):
 
         self.eventQueue = []
         self.eventQueueLock = threading.Lock()
@@ -44,10 +44,7 @@ class BBUIEventQueue:
         server.register_function( self.send_event, "event.sendpickle" )
         server.socket.settimeout(1)
 
-        self.EventHandle = self.BBServer.registerEventHandler(self.host, self.port, featureset)
-
-        if (self.EventHandle == None):
-            bb.fatal("Could not register UI event handler")
+        self.EventHandle = self.BBServer.registerEventHandler(self.host, self.port)
 
         self.server = server
 
@@ -87,7 +84,6 @@ class BBUIEventQueue:
 
     def startCallbackHandler(self):
 
-        self.server.timeout = 1
         while not self.server.quit:
             self.server.handle_request()
         self.server.server_close()

bitbake/lib/bb/utils.py

@@ -27,31 +27,17 @@ import bb
 import bb.msg
 import multiprocessing
 import fcntl
-import subprocess
-import glob
-import traceback
-import errno
 from commands import getstatusoutput
 from contextlib import contextmanager
 
 logger = logging.getLogger("BitBake.Util")
 
-def clean_context():
-    return {
-        "os": os,
-        "bb": bb,
-        "time": time,
-    }
-
-def get_context():
-    return _context
-    
-
-def set_context(ctx):
-    _context = ctx
-
 # Context used in better_exec, eval
-_context = clean_context()
+_context = {
+    "os": os,
+    "bb": bb,
+    "time": time,
+}
 
 def explode_version(s):
     r = []
@@ -250,16 +236,14 @@ def _print_trace(body, line):
     """
     Print the Environment of a Text Body
     """
-    error = []
     # print the environment of the method
     min_line = max(1, line-4)
     max_line = min(line + 4, len(body))
-    for i in range(min_line, max_line + 1):
+    for i in xrange(min_line, max_line + 1):
         if line == i:
-            error.append(' *** %.4d:%s' % (i, body[i-1].rstrip()))
+            logger.error(' *** %.4d:%s', i, body[i-1])
         else:
-            error.append('     %.4d:%s' % (i, body[i-1].rstrip()))
-    return error
+            logger.error('     %.4d:%s', i, body[i-1])
 
 def better_compile(text, file, realfile, mode = "exec"):
     """
@@ -269,78 +253,22 @@ def better_compile(text, file, realfile, mode = "exec"):
     try:
         return compile(text, file, mode)
     except Exception as e:
-        error = []
         # split the text into lines again
         body = text.split('\n')
-        error.append("Error in compiling python function in %s:\n" % realfile)
+        logger.error("Error in compiling python function in %s", realfile)
+        logger.error(str(e))
         if e.lineno:
-            error.append("The code lines resulting in this error were:")
-            error.extend(_print_trace(body, e.lineno))
+            logger.error("The lines leading to this error were:")
+            logger.error("\t%d:%s:'%s'", e.lineno, e.__class__.__name__, body[e.lineno-1])
+            _print_trace(body, e.lineno)
         else:
-            error.append("The function causing this error was:")
+            logger.error("The function causing this error was:")
             for line in body:
-                error.append(line)
-        error.append("%s: %s" % (e.__class__.__name__, str(e)))
-
-        logger.error("\n".join(error))
+                logger.error(line)
 
         e = bb.BBHandledException(e)
         raise e
 
-def _print_exception(t, value, tb, realfile, text, context):
-    error = []
-    try:
-        exception = traceback.format_exception_only(t, value)
-        error.append('Error executing a python function in %s:\n' % realfile)
-
-        # Strip 'us' from the stack (better_exec call)
-        tb = tb.tb_next
-
-        textarray = text.split('\n')
-
-        linefailed = tb.tb_lineno
-
-        tbextract = traceback.extract_tb(tb)
-        tbformat = traceback.format_list(tbextract)
-        error.append("The stack trace of python calls that resulted in this exception/failure was:")
-        error.append("File: '%s', lineno: %s, function: %s" % (tbextract[0][0], tbextract[0][1], tbextract[0][2]))
-        error.extend(_print_trace(textarray, linefailed))
-
-        # See if this is a function we constructed and has calls back into other functions in
-        # "text". If so, try and improve the context of the error by diving down the trace
-        level = 0
-        nexttb = tb.tb_next
-        while nexttb is not None and (level+1) < len(tbextract):
-            error.append("File: '%s', lineno: %s, function: %s" % (tbextract[level+1][0], tbextract[level+1][1], tbextract[level+1][2]))
-            if tbextract[level][0] == tbextract[level+1][0] and tbextract[level+1][2] == tbextract[level][0]:
-                # The code was possibly in the string we compiled ourselves
-                error.extend(_print_trace(textarray, tbextract[level+1][1]))
-            elif tbextract[level+1][0].startswith("/"):
-                # The code looks like it might be in a file, try and load it
-                try:
-                    with open(tbextract[level+1][0], "r") as f:
-                        text = f.readlines()
-                        error.extend(_print_trace(text, tbextract[level+1][1]))
-                except:
-                    error.append(tbformat[level+1])
-            elif "d" in context and tbextract[level+1][2]:
-                # Try and find the code in the datastore based on the functionname
-                d = context["d"]
-                functionname = tbextract[level+1][2]
-                text = d.getVar(functionname, True)
-                if text:
-                    error.extend(_print_trace(text.split('\n'), tbextract[level+1][1]))
-                else:
-                    error.append(tbformat[level+1])
-            else:
-                error.append(tbformat[level+1])
-            nexttb = tb.tb_next
-            level = level + 1
-
-        error.append("Exception: %s" % ''.join(exception))
-    finally:
-        logger.error("\n".join(error))
-
 def better_exec(code, context, text = None, realfile = "<code>"):
     """
     Similiar to better_compile, better_exec will
@@ -353,25 +281,64 @@ def better_exec(code, context, text = None, realfile = "<code>"):
     if not hasattr(code, "co_filename"):
         code = better_compile(code, realfile, realfile)
     try:
-        exec(code, get_context(), context)
+        exec(code, _context, context)
     except Exception as e:
         (t, value, tb) = sys.exc_info()
 
         if t in [bb.parse.SkipPackage, bb.build.FuncFailed]:
             raise
-        try:
-            _print_exception(t, value, tb, realfile, text, context)
-        except Exception as e:
-            logger.error("Exception handler error: %s" % str(e))
+
+        import traceback
+        exception = traceback.format_exception_only(t, value)
+        logger.error('Error executing a python function in %s:\n%s',
+                     realfile, ''.join(exception))
+
+        # Strip 'us' from the stack (better_exec call)
+        tb = tb.tb_next
+
+        textarray = text.split('\n')
+        linefailed = traceback.tb_lineno(tb)
+
+        tbextract = traceback.extract_tb(tb)
+        tbformat = "\n".join(traceback.format_list(tbextract))
+        logger.error("The stack trace of python calls that resulted in this exception/failure was:")
+        for line in tbformat.split('\n'):
+            logger.error(line)
+
+        logger.error("The code that was being executed was:")
+        _print_trace(textarray, linefailed)
+        logger.error("[From file: '%s', lineno: %s, function: %s]", tbextract[0][0], tbextract[0][1], tbextract[0][2])
+
+        # See if this is a function we constructed and has calls back into other functions in
+        # "text". If so, try and improve the context of the error by diving down the trace
+        level = 0
+        nexttb = tb.tb_next
+        while nexttb is not None and (level+1) < len(tbextract):
+            if tbextract[level][0] == tbextract[level+1][0] and tbextract[level+1][2] == tbextract[level][0]:
+                _print_trace(textarray, tbextract[level+1][1])
+                logger.error("[From file: '%s', lineno: %s, function: %s]", tbextract[level+1][0], tbextract[level+1][1], tbextract[level+1][2])
+            elif "d" in context and tbextract[level+1][2]:
+                d = context["d"]
+                functionname = tbextract[level+1][2]
+                text = d.getVar(functionname, True)
+                if text:
+                    _print_trace(text.split('\n'), tbextract[level+1][1])
+                    logger.error("[From file: '%s', lineno: %s, function: %s]", tbextract[level+1][0], tbextract[level+1][1], tbextract[level+1][2])
+                else:
+                    break
+            else:
+                 break
+            nexttb = tb.tb_next
+            level = level + 1
 
         e = bb.BBHandledException(e)
         raise e
 
 def simple_exec(code, context):
-    exec(code, get_context(), context)
+    exec(code, _context, context)
 
 def better_eval(source, locals):
-    return eval(source, get_context(), locals)
+    return eval(source, _context, locals)
 
 @contextmanager
 def fileslocked(files):
@@ -427,10 +394,6 @@ def lockfile(name, shared=False, retry=True):
                     return lf
             lf.close()
         except Exception:
-            try:
-                lf.close()
-            except Exception:
-                pass
             pass
         if not retry:
             return None
@@ -460,9 +423,8 @@ def md5_file(filename):
         import md5
         m = md5.new()
 
-    with open(filename, "rb") as f:
-        for line in f:
-            m.update(line)
+    for line in open(filename):
+        m.update(line)
     return m.hexdigest()
 
 def sha256_file(filename):
@@ -478,9 +440,8 @@ def sha256_file(filename):
         return None
 
     s = hashlib.sha256()
-    with open(filename, "rb") as f:
-        for line in f:
-            s.update(line)
+    for line in open(filename):
+        s.update(line)
     return s.hexdigest()
 
 def preserved_envvars_exported():
@@ -532,8 +493,6 @@ def approved_variables():
     Determine and return the list of whitelisted variables which are approved
     to remain in the envrionment.
     """
-    if 'BB_PRESERVE_ENV' in os.environ:
-        return os.environ.keys()
     approved = []
     if 'BB_ENV_WHITELIST' in os.environ:
         approved = os.environ['BB_ENV_WHITELIST'].split()
@@ -580,9 +539,11 @@ def remove(path, recurse=False):
     if not path:
         return
     if recurse:
+        import subprocess, glob
         # shutil.rmtree(name) would be ideal but its too slow
         subprocess.call(['rm', '-rf'] + glob.glob(path))
         return
+    import os, errno, glob
     for name in glob.glob(path):
         try:
             os.unlink(name)
@@ -724,7 +685,7 @@ def copyfile(src, dest, newmtime = None, sstat = None):
         if not sstat:
             sstat = os.lstat(src)
     except Exception as e:
-        logger.warn("copyfile: stat of %s failed (%s)" % (src, e))
+        print("copyfile: Stating source file failed...", e)
         return False
 
     destexists = 1
@@ -751,7 +712,7 @@ def copyfile(src, dest, newmtime = None, sstat = None):
             #os.lchown(dest,sstat[stat.ST_UID],sstat[stat.ST_GID])
             return os.lstat(dest)
         except Exception as e:
-            logger.warn("copyfile: failed to create symlink %s to %s (%s)" % (dest, target, e))
+            print("copyfile: failed to properly create symlink:", dest, "->", target, e)
             return False
 
     if stat.S_ISREG(sstat[stat.ST_MODE]):
@@ -766,7 +727,7 @@ def copyfile(src, dest, newmtime = None, sstat = None):
             shutil.copyfile(src, dest + "#new")
             os.rename(dest + "#new", dest)
         except Exception as e:
-            logger.warn("copyfile: copy %s to %s failed (%s)" % (src, dest, e))
+            print('copyfile: copy', src, '->', dest, 'failed.', e)
             return False
         finally:
             if srcchown:
@@ -777,13 +738,13 @@ def copyfile(src, dest, newmtime = None, sstat = None):
         #we don't yet handle special, so we need to fall back to /bin/mv
         a = getstatusoutput("/bin/cp -f " + "'" + src + "' '" + dest + "'")
         if a[0] != 0:
-            logger.warn("copyfile: failed to copy special file %s to %s (%s)" % (src, dest, a))
+            print("copyfile: Failed to copy special file:" + src + "' to '" + dest + "'", a)
             return False # failure
     try:
         os.lchown(dest, sstat[stat.ST_UID], sstat[stat.ST_GID])
         os.chmod(dest, stat.S_IMODE(sstat[stat.ST_MODE])) # Sticky is reset on chown
     except Exception as e:
-        logger.warn("copyfile: failed to chown/chmod %s (%s)" % (dest, e))
+        print("copyfile: Failed to chown/chmod/unlink", dest, e)
         return False
 
     if newmtime:
@@ -862,8 +823,11 @@ def process_profilelog(fn):
     pout.close()  
 
 #
-# Was present to work around multiprocessing pool bugs in python < 2.7.3
+# Work around multiprocessing pool bugs in python < 2.7.3
 #
 def multiprocessingpool(*args, **kwargs):
-    return multiprocessing.Pool(*args, **kwargs)
+    if sys.version_info < (2, 7, 3):
+        return bb.compat.Pool(*args, **kwargs)
+    else:
+        return multiprocessing.pool.Pool(*args, **kwargs)
 

bitbake/lib/prserv/__init__.py

@@ -10,5 +10,5 @@ def init_logger(logfile, loglevel):
     FORMAT = '%(asctime)-15s %(message)s'
     logging.basicConfig(level=numeric_level, filename=logfile, format=FORMAT)
 
-class NotFoundError(Exception):
+class NotFoundError(StandardError):
     pass

bitbake/lib/prserv/db.py

@@ -2,7 +2,6 @@ import logging
 import os.path
 import errno
 import prserv
-import time
 
 try:
     import sqlite3
@@ -15,7 +14,7 @@ sqlversion = sqlite3.sqlite_version_info
 if sqlversion[0] < 3 or (sqlversion[0] == 3 and sqlversion[1] < 3):
     raise Exception("sqlite3 version 3.3.0 or later is required.")
 
-class PRTable(object):
+class PRTable():
     def __init__(self, conn, table, nohist):
         self.conn = conn
         self.nohist = nohist
@@ -33,20 +32,16 @@ class PRTable(object):
 
     def _execute(self, *query):
         """Execute a query, waiting to acquire a lock if necessary"""
-        start = time.time()
-        end = start + 20
+        count = 0
         while True:
             try:
                 return self.conn.execute(*query)
             except sqlite3.OperationalError as exc:
-                if 'is locked' in str(exc) and end > time.time():
+                if 'database is locked' in str(exc) and count < 500:
+                    count = count + 1
                     continue
                 raise exc
 
-    def sync(self):
-        self.conn.commit()
-        self._execute("BEGIN EXCLUSIVE TRANSACTION")
-
     def _getValueHist(self, version, pkgarch, checksum):
         data=self._execute("SELECT value FROM %s WHERE version=? AND pkgarch=? AND checksum=?;" % self.table,
                            (version, pkgarch, checksum))
@@ -56,9 +51,11 @@ class PRTable(object):
         else:
             #no value found, try to insert
             try:
-                self._execute("INSERT INTO %s VALUES (?, ?, ?, (select ifnull(max(value)+1,0) from %s where version=? AND pkgarch=?));"
+                self._execute("BEGIN")
+                self._execute("INSERT OR ROLLBACK INTO %s VALUES (?, ?, ?, (select ifnull(max(value)+1,0) from %s where version=? AND pkgarch=?));"
                            % (self.table,self.table),
                            (version,pkgarch, checksum,version, pkgarch))
+                self.conn.commit()
             except sqlite3.IntegrityError as exc:
                 logger.error(str(exc))
 
@@ -82,9 +79,11 @@ class PRTable(object):
         else:
             #no value found, try to insert
             try:
+                self._execute("BEGIN")
                 self._execute("INSERT OR REPLACE INTO %s VALUES (?, ?, ?, (select ifnull(max(value)+1,0) from %s where version=? AND pkgarch=?));"
                                % (self.table,self.table),
                                (version, pkgarch, checksum, version, pkgarch))
+                self.conn.commit()
             except sqlite3.IntegrityError as exc:
                 logger.error(str(exc))
                 self.conn.rollback()
@@ -113,8 +112,10 @@ class PRTable(object):
         else:
             #no value found, try to insert
             try:
-                self._execute("INSERT INTO %s VALUES (?, ?, ?, ?);"  % (self.table),
+                self._execute("BEGIN")
+                self._execute("INSERT OR ROLLBACK INTO %s VALUES (?, ?, ?, ?);"  % (self.table),
                            (version, pkgarch, checksum, value))
+                self.conn.commit()
             except sqlite3.IntegrityError as exc:
                 logger.error(str(exc))
 
@@ -128,14 +129,18 @@ class PRTable(object):
     def _importNohist(self, version, pkgarch, checksum, value):
         try:
             #try to insert
-            self._execute("INSERT INTO %s VALUES (?, ?, ?, ?);"  % (self.table),
+            self._execute("BEGIN")
+            self._execute("INSERT OR ROLLBACK INTO %s VALUES (?, ?, ?, ?);"  % (self.table),
                            (version, pkgarch, checksum,value))
+            self.conn.commit()
         except sqlite3.IntegrityError as exc:
             #already have the record, try to update
             try:
+                self._execute("BEGIN")
                 self._execute("UPDATE %s SET value=? WHERE version=? AND pkgarch=? AND checksum=? AND value<?"  
                               % (self.table),
                                (value,version,pkgarch,checksum,value))
+                self.conn.commit()
             except sqlite3.IntegrityError as exc:
                 logger.error(str(exc))
 
@@ -218,7 +223,7 @@ class PRData(object):
         except OSError as e:
             if e.errno != errno.EEXIST:
                 raise e
-        self.connection=sqlite3.connect(self.filename, isolation_level="EXCLUSIVE", check_same_thread = False)
+        self.connection=sqlite3.connect(self.filename, isolation_level="DEFERRED")
         self.connection.row_factory=sqlite3.Row
         self._tables={}
 

bitbake/lib/prserv/serv.py

@@ -2,8 +2,6 @@ import os,sys,logging
 import signal, time, atexit, threading
 from SimpleXMLRPCServer import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler
 import xmlrpclib
-import threading
-import Queue
 
 try:
     import sqlite3
@@ -33,17 +31,19 @@ class Handler(SimpleXMLRPCRequestHandler):
 PIDPREFIX = "/tmp/PRServer_%s_%s.pid"
 singleton = None
 
-
 class PRServer(SimpleXMLRPCServer):
     def __init__(self, dbfile, logfile, interface, daemon=True):
         ''' constructor '''
         SimpleXMLRPCServer.__init__(self, interface,
+                                    requestHandler=SimpleXMLRPCRequestHandler,
                                     logRequests=False, allow_none=True)
         self.dbfile=dbfile
         self.daemon=daemon
         self.logfile=logfile
         self.working_thread=None
         self.host, self.port = self.socket.getsockname()
+        self.db=prserv.db.PRData(dbfile)
+        self.table=self.db["PRMAIN"]
         self.pidfile=PIDPREFIX % (self.host, self.port)
 
         self.register_function(self.getPR, "getPR")
@@ -53,32 +53,6 @@ class PRServer(SimpleXMLRPCServer):
         self.register_function(self.importone, "importone")
         self.register_introspection_functions()
 
-        self.db = prserv.db.PRData(self.dbfile)
-        self.table = self.db["PRMAIN"]
-
-        self.requestqueue = Queue.Queue()
-        self.handlerthread = threading.Thread(target = self.process_request_thread)
-        self.handlerthread.daemon = False
-
-    def process_request_thread(self):
-        """Same as in BaseServer but as a thread.
-
-        In addition, exception handling is done here.
-
-        """
-        while True:
-            (request, client_address) = self.requestqueue.get()
-            try:
-                self.finish_request(request, client_address)
-                self.shutdown_request(request)
-            except:
-                self.handle_error(request, client_address)
-                self.shutdown_request(request)
-                self.table.sync()
-
-    def process_request(self, request, client_address):
-        self.requestqueue.put((request, client_address))
-
     def export(self, version=None, pkgarch=None, checksum=None, colinfo=True):
         try:
             return self.table.export(version, pkgarch, checksum, colinfo)
@@ -116,11 +90,9 @@ class PRServer(SimpleXMLRPCServer):
         logger.info("Started PRServer with DBfile: %s, IP: %s, PORT: %s, PID: %s" %
                      (self.dbfile, self.host, self.port, str(os.getpid())))
 
-        self.handlerthread.start()
         while not self.quit:
             self.handle_request()
 
-        self.table.sync()
         logger.info("PRServer: stopping...")
         self.server_close()
         return
@@ -171,11 +143,6 @@ class PRServer(SimpleXMLRPCServer):
         os.dup2(so.fileno(),sys.stdout.fileno())
         os.dup2(se.fileno(),sys.stderr.fileno())
 
-        # Clear out all log handlers prior to the fork() to avoid calling
-        # event handlers not part of the PRserver
-        for logger_iter in logging.Logger.manager.loggerDict.keys():
-            logging.getLogger(logger_iter).handlers = []
-
         # Ensure logging makes it to the logfile
         streamhandler = logging.StreamHandler()
         streamhandler.setLevel(logging.DEBUG)
@@ -190,10 +157,10 @@ class PRServer(SimpleXMLRPCServer):
         pf.close()
 
         self.work_forever()
-        self.delpid()
+        self.delpid
         os._exit(0)
 
-class PRServSingleton(object):
+class PRServSingleton():
     def __init__(self, dbfile, logfile, interface):
         self.dbfile = dbfile
         self.logfile = logfile
@@ -205,19 +172,23 @@ class PRServSingleton(object):
         self.prserv = PRServer(self.dbfile, self.logfile, self.interface)
         self.prserv.start()
         self.host, self.port = self.prserv.getinfo()
+        del self.prserv.db
 
     def getinfo(self):
         return (self.host, self.port)
 
-class PRServerConnection(object):
+class PRServerConnection():
     def __init__(self, host, port):
         if is_local_special(host, port):
             host, port = singleton.getinfo()
         self.host = host
         self.port = port
-        self.connection, self.transport = bb.server.xmlrpc._create_server(self.host, self.port)
+        self.connection = bb.server.xmlrpc._create_server(self.host, self.port)
 
     def terminate(self):
+        # Don't wait for server indefinitely
+        import socket
+        socket.setdefaulttimeout(2)
         try:
             logger.info("Terminating PRServer...")
             self.connection.quit()
@@ -236,9 +207,6 @@ class PRServerConnection(object):
     def importone(self, version, pkgarch, checksum, value):
         return self.connection.importone(version, pkgarch, checksum, value)
 
-    def getinfo(self):
-        return self.host, self.port
-
 def start_daemon(dbfile, host, port, logfile):
     pidfile = PIDPREFIX % (host, port)
     try:
@@ -303,7 +271,7 @@ def auto_start(d):
 
     host_params = filter(None, (d.getVar('PRSERV_HOST', True) or '').split(':'))
     if not host_params:
-        return None
+        return True
 
     if len(host_params) != 2:
         logger.critical('\n'.join(['PRSERV_HOST: incorrect format',
@@ -328,11 +296,7 @@ def auto_start(d):
         port = int(host_params[1])
 
     try:
-        connection = PRServerConnection(host,port)
-        connection.ping()
-        realhost, realport = connection.getinfo()
-        return str(realhost) + ":" + str(realport)
-        
+        return PRServerConnection(host,port).ping()
     except Exception:
         logger.critical("PRservice %s:%d not available" % (host, port))
         raise PRServiceConfigError

bitbake/lib/toaster/bldviewer/api.py

@@ -1,37 +0,0 @@
-#
-# BitBake Toaster Implementation
-#
-# Copyright (C) 2013        Intel Corporation
-#
-# 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.
-
-from django.conf.urls import patterns, include, url
-
-
-urlpatterns = patterns('bldviewer.views',
-        url(r'^builds$', 'model_explorer',  {'model_name':'build'}, name='builds'),
-        url(r'^targets$', 'model_explorer',  {'model_name':'target'}, name='targets'),
-        url(r'^tasks$', 'model_explorer', {'model_name':'task'}, name='task'),
-        url(r'^task_dependencies$', 'model_explorer',  {'model_name':'task_dependency'}, name='task_dependencies'),
-        url(r'^packages$', 'model_explorer',  {'model_name':'build_package'}, name='build_packages'),
-        url(r'^package_dependencies$', 'model_explorer',  {'model_name':'build_package_dependency'}, name='build_package_dependencies'),
-        url(r'^target_packages$', 'model_explorer',  {'model_name':'target_package'}, name='target_packages'),
-        url(r'^package_files$', 'model_explorer',  {'model_name':'build_file'}, name='build_files'),
-        url(r'^layers$', 'model_explorer', {'model_name':'layer'}, name='layer'),
-        url(r'^layerversions$', 'model_explorer', {'model_name':'layerversion'}, name='layerversion'),
-        url(r'^recipes$', 'model_explorer', {'model_name':'recipe'}, name='recipe'),
-        url(r'^recipe_dependencies$', 'model_explorer',  {'model_name':'recipe_dependency'}, name='recipe_dependencies'),
-        url(r'^variables$', 'model_explorer',  {'model_name':'variable'}, name='variables'),
-        url(r'^logmessages$', 'model_explorer',  {'model_name':'logmessage'}, name='logmessages'),
-)

bitbake/lib/toaster/bldviewer/templates/base.html

@@ -1,30 +0,0 @@
-<!DOCTYPE html>
-{% load static %}
-<html>
-	<head>
-		<title>Toaster Simple Explorer</title>
-<script src="{% static 'js/jquery-2.0.3.js' %}">
-</script>
-<script src="{% static 'js/bootstrap.js' %}">
-</script>
-<link href="{% static 'css/bootstrap.css' %}" rel="stylesheet" type="text/css">
-	</head>
-
-<body style="height: 100%">
-<div style="width:100%; height: 100%; position:absolute">
-<div style="width: 100%; height: 3em" class="nav">
-    <ul class="nav nav-tabs">
-        <li><a href="{% url all-builds %}">All Builds</a></li>
-        <li><a href="{% url all-layers %}">All Layers</a></li>
-    </ul>
-</div>
-
-<div style="overflow-y:scroll; width: 100%; position: absolute; top: 3em; bottom:70px ">
-{% block pagecontent %}
-{% endblock %}
-</div>
-<div class="navbar" style="position: absolute; bottom: 0; width:100%"><br/>About Toaster | Yocto Project </div>
-</div>
-</body>
-</html>
-

bitbake/lib/toaster/bldviewer/templates/basebuildpage.html

@@ -1,17 +0,0 @@
-{% extends "basetable.html" %}
-
-{% block pagename %}
-<ul class="nav nav-tabs" style="display: inline-block">
-  <li><a>Build {{build.target_set.all|join:"&nbsp;"}} at {{build.started_on}} : </a></li>
-  <li><a href="{% url task build.id %}"> Tasks </a></li>
-  <li><a href="{% url bpackage build.id %}"> Build Packages </a></li>
-    {% for t in build.target_set.all %}
-        {% if t.is_image %}
-  <li><a href="{% url tpackage build.id t.pk %}"> Packages for {{t.target}} </a> </li>
-        {% endif %}
-    {% endfor %}
-  <li><a href="{% url configuration build.id %}"> Configuration </a> </li>
-</ul>
-     <h1>Toaster - Build {% block pagetitle %} {% endblock %}</h1>
-{% endblock %}
-

bitbake/lib/toaster/bldviewer/templates/basetable.html

@@ -1,46 +0,0 @@
-{% extends "base.html" %}
-
-{% block pagecontent %}
-<script>
-function showhideTableColumn(i, sh) {
-    if (sh)
-        $('td:nth-child('+i+'),th:nth-child('+i+')').show();
-    else
-        $('td:nth-child('+i+'),th:nth-child('+i+')').hide();
-}
-
-
-function filterTableRows(test) {
-    if (test.length > 0) {
-        var r = test.split(/[ ,]+/).map(function (e) { return new RegExp(e, 'i') });
-        $('tr.data').map( function (i, el) {
-            (! r.map(function (j) { return j.test($(el).html())}).reduce(function (c, p) { return c && p;} )) ? $(el).hide() : $(el).show();
-        });
-    } else
-    {
-        $('tr.data').show();
-    }
-}
-</script>
-<div style="margin-bottom: 0.5em">
-
-    {% block pagename %}
-    {% endblock %}
-    <div align="left" style="display:inline-block; width: 40%; margin-left: 2em"> Search: <input type="search" id="filterstring" style="width: 80%" onkeyup="filterTableRows($('#filterstring').val())" autocomplete="off">
-    </div>
-    {% if hideshowcols %}
-    <div align="right" style="display: inline-block; width: 40%">Show/Hide columns:
-    {% for i in hideshowcols %}
-        <span>{{i.name}} <input type="checkbox" id="ct{{i.name}}" onchange="showhideTableColumn({{i.order}}, $('#ct{{i.name}}').is(':checked'))" checked autocomplete="off"></span> |
-    {% endfor %}
-    </div>
-    {% endif %}
-</div>
-<div>
-    <table class="table table-striped table-condensed" style="width:95%">
-{% block pagetable %}
-{% endblock %}
-    </table>
-</div>
-
-{% endblock %}

bitbake/lib/toaster/bldviewer/templates/bfile.html

@@ -1,24 +0,0 @@
-{% extends "basebuildpage.html" %}
-
-{% block pagetitle %}Files for package {{files.0.bpackage.name}} {% endblock %}
-{% block pagetable %}
-    {% if not files %}
-        <p>No files were recorded for this package!</p>
-    {% else %}
-
-            <tr>
-            <th>Name</th>
-            <th>Size (Bytes)</th>
-            </tr>
-
-            {% for file in files %}
-
-            <tr class="data">
-            <td>{{file.path}}</td>
-            <td>{{file.size}}</td>
-
-            {% endfor %}
-
-    {% endif %}
-
-{% endblock %}

bitbake/lib/toaster/bldviewer/templates/bpackage.html

@@ -1,44 +0,0 @@
-{% extends "basebuildpage.html" %}
-
-{% block pagetitle %}Packages{% endblock %}
-{% block pagetable %}
-    {% if not packages %}
-        <p>No packages were recorded for this target!</p>
-    {% else %}
-
-            <tr>
-            <th>Name</th>
-            <th>Version</th>
-            <th>Recipe</th>
-            <th>Summary</th>
-            <th>Section</th>
-            <th>Description</th>
-            <th>Size on host disk (KBytes)</th>
-            <th>License</th>
-            <th>Dependencies List (all)</th>
-            </tr>
-
-            {% for package in packages %}
-
-            <tr class="data">
-                <td><a name="#{{package.name}}" href="{% url bfile build.pk package.pk %}">{{package.name}} ({{package.filelist_bpackage.count}} files)</a></td>
-                <td>{{package.version}}-{{package.revision}}</td>
-                <td><a href="{% url layer_versions_recipes package.recipe.layer_version_id %}#{{package.recipe.name}}">{{package.recipe.name}}</a>{{package.package_name}}</a></td>
-
-            <td>{{package.summary}}</td>
-            <td>{{package.section}}</td>
-            <td>{{package.description}}</td>
-            <td>{{package.size}}</td>
-            <td>{{package.license}}</td>
-            <td>
-        <div style="height: 3em; overflow:auto">
-            {% for bpd in package.bpackage_dependencies_package.all %}
-                {{bpd.dep_type}}: {{bpd.depends_on}} <br/>
-            {% endfor %}
-        </div>
-            </td>
-            {% endfor %}
-
-    {% endif %}
-
-{% endblock %}

bitbake/lib/toaster/bldviewer/templates/build.html

@@ -1,43 +0,0 @@
-{% extends "basetable.html" %}
-
-{% block pagename %}
-    <h1>Toaster - Builds</h1>
-{% endblock %}
-
-{% block pagetable %}
-
-    {% load projecttags %}
-        <tr>
-            <th>Outcome</th>
-            <th>Started On</th>
-            <th>Completed On</th>
-            <th>Target</th>
-            <th>Machine</th>
-            <th>Time</th>
-            <th>Errors</th>
-            <th>Warnings</th>
-            <th>Output</th>
-            <th>Log</th>
-            <th>Bitbake Version</th>
-            <th>Build Name</th>
-        </tr>
-        {% for build in builds %}
-        <tr class="data">
-            <td><a href="{% url configuration build.id %}">{{build.get_outcome_display}}</a></td>
-            <td>{{build.started_on}}</td>
-            <td>{{build.completed_on}}</td>
-            <td>{% for t in build.target_set.all %}<a href="{% url tpackage build.id t.id %}">{{t.target}}</a>{% if t.is_image %} (Img){% endif %}<br/>{% endfor %}</td>
-            <td>{{build.machine}}</td>
-            <td>{% time_difference build.started_on build.completed_on %}</td>
-            <td>{{build.errors_no}}:{% if  build.errors_no %}{% for error in logs %}{% if error.build == build %}{% if error.level == 2 %}<p>{{error.message}}</p>{% endif %}{% endif %}{% endfor %}{% else %}None{% endif %}</td>
-            <td>{{build.warnings_no}}:{% if  build.warnings_no %}{% for warning in logs %}{% if warning.build == build %}{% if warning.level == 1 %}<p>{{warning.message}}</p>{% endif %}{% endif %}{% endfor %}{% else %}None{% endif %}</td>
-            <td>{% if build.outcome == 0 %}{% for t in build.target_set.all %}{% if t.is_image %}{{build.image_fstypes}}{% endif %}{% endfor %}{% endif %}</td>
-            <td>{{build.cooker_log_path}}</td>
-            <td>{{build.bitbake_version}}</td>
-            <td>{{build.build_name}}</td>
-        </tr>
-
-        {% endfor %}
-{% endblock %}
-
-

bitbake/lib/toaster/bldviewer/templates/configuration.html

@@ -1,20 +0,0 @@
-{% extends "basebuildpage.html" %}
-
-{% block pagetitle %}Configuration{% endblock %}
-{% block pagetable %}
-
-            <tr>
-            <th>Name</th>
-            <th>Value</th>
-            <th>Description</th>
-            </tr>
-
-            {% for variable in configuration %}
-
-            <tr class="data">
-                <td>{{variable.variable_name}}</td>
-                <td>{{variable.variable_value}}</td>
-                <td>{% if variable.description %}{{variable.description}}{% endif %}</td>
-            {% endfor %}
-
-{% endblock %}

bitbake/lib/toaster/bldviewer/templates/layer.html

@@ -1,34 +0,0 @@
-{% extends "basetable.html" %}
-
-{% block pagename %}
-    <h1>Toaster - Layers</h1>
-{% endblock %}
-
-{% block pagetable %}
-    {% load projecttags %}
-
-        <tr>
-            <th>Name</th>
-            <th>Local Path</th>
-            <th>Layer Index URL</th>
-            <th>Known Versions</th>
-        </tr>
-
-        {% for layer in layers %}
-
-        <tr class="data">
-            <td>{{layer.name}}</td>
-            <td>{{layer.local_path}}</td>
-            <td><a href='{{layer.layer_index_url}}'>{{layer.layer_index_url}}</a></td>
-            <td><table>
-            {% for lv in layer.versions %}
-                <tr><td>
-        <a href="{% url layer_versions_recipes lv.id %}">({{lv.priority}}){{lv.branch}}:{{lv.commit}} ({{lv.count}} recipes)</a>
-                </td></tr>
-            {% endfor %}
-            </table></td>
-        </tr>
-
-        {% endfor %}
-
-{% endblock %}

bitbake/lib/toaster/bldviewer/templates/package.html

@@ -1,36 +0,0 @@
-{% extends "basebuildpage.html" %}
-
-{% block pagetable %}
-    {% if not packages %}
-        <p>No packages were recorded for this target!</p>
-    {% else %}
-
-            <tr>
-            <th>Name</th>
-            <th>Version</th>
-            <th>Size (Bytes)</th>
-            <th>Recipe</th>
-            <th>Depends on</th>
-            </tr>
-
-            {% for package in packages %}
-
-            <tr class="data">
-                <td><a name="#{{package.name}}">{{package.name}}</a></td>
-                <td>{{package.version}}</td>
-                <td>{{package.size}}</td>
-                <td>{%if package.recipe %}<a name="{{package.recipe.name}}.{{package.package_name}}">
-                <a href="{% url layer_versions_recipes package.recipe.layer_version_id %}#{{package.recipe.name}}">{{package.recipe.name}}</a>{{package.package_name}}</a>{%endif%}</td>
-                <td>
-            <div style="height: 4em; overflow:auto">
-                    {% for d in package.tpackage_dependencies_package.all %}
-                    <a href="#{{d.name}}">{{d.depends_on.name}}</a><br/>
-                    {% endfor %}
-            </div>
-                </td>
-
-            {% endfor %}
-
-    {% endif %}
-
-{% endblock %}

bitbake/lib/toaster/bldviewer/templates/recipe.html

@@ -1,54 +0,0 @@
-{% extends "basetable.html" %}
-
-{% block pagename %}
-<ul class="nav nav-tabs" style="display: inline-block">
-  <li><a>Layer  {{layer_version.layer.name}}&nbsp;:&nbsp;{{layer_version.branch}}&nbsp;:&nbsp;{{layer_version.commit}}&nbsp;:&nbsp;{{layer_version.priority}}</a></li>
-</ul>
-    <h1>Toaster - Recipes for a Layer</h1>
-{% endblock %}
-
-{% block pagetable %}
-    {% load projecttags %}
-
-        <tr>
-        </tr>
-            <th>Name</th>
-            <th>Version</th>
-            <th>Summary</th>
-            <th>Description</th>
-            <th>Section</th>
-            <th>License</th>
-            <th>License file</th>
-            <th>Homepage</th>
-            <th>Bugtracker</th>
-            <th>Author</th>
-            <th>File_path</th>
-            <th style="width: 30em">Recipe Dependency</th>
-
-
-        {% for recipe in recipes %}
-
-        <tr class="data">
-            <td><a name="{{recipe.name}}">{{recipe.name}}</a></td>
-            <td>{{recipe.version}}</td>
-            <td>{{recipe.summary}}</td>
-            <td>{{recipe.description}}</td>
-            <td>{{recipe.section}}</td>
-            <td>{{recipe.license}}</td>
-            <td>{{recipe.licensing_info}}</td>
-            <td>{{recipe.homepage}}</td>
-            <td>{{recipe.bugtracker}}</td>
-            <td>{{recipe.author}}</td>
-            <td>{{recipe.file_path}}</td>
-            <td>
-        <div style="height: 5em; overflow:auto">
-            {% for rr in recipe.r_dependencies_recipe.all %}
-                <a href="#{{rr.depends_on.name}}">{{rr.depends_on.name}}</a><br/>
-            {% endfor %}
-        </div>
-            </td>
-        </tr>
-
-        {% endfor %}
-
-{% endblock %}

bitbake/lib/toaster/bldviewer/templates/task.html

@@ -1,63 +0,0 @@
-{% extends "basebuildpage.html" %}
-
-{% block pagetitle %}Tasks{% endblock %}
-{% block pagetable %}
-    {% if not tasks %}
-        <p>No tasks were executed in this build!</p>
-    {% else %}
-
-            <tr>
-            <th>Order</th>
-            <th>Task</th>
-            <th>Recipe Version</th>
-            <th>Task Type</th>
-            <th>Checksum</th>
-            <th>Outcome</th>
-            <th>Message</th>
-            <th>Logfile</th>
-            <th>Time</th>
-            <th>CPU usage</th>
-            <th>Disk I/O</th>
-            <th>Script type</th>
-            <th>File path</th>
-            <th>Depends</th>
-            </tr>
-
-            {% for task in tasks %}
-
-            <tr class="data">
-                <td>{{task.order}}</td>
-                <td><a name="{{task.recipe.name}}.{{task.task_name}}">
-                <a href="{% url layer_versions_recipes task.recipe.layer_version_id %}#{{task.recipe.name}}">{{task.recipe.name}}</a>.{{task.task_name}}</a></td>
-                <td>{{task.recipe.version}}</td>
-
-                {% if task.task_executed %}
-                <td>Executed</td>
-                {% else %}
-                <td>Prebuilt</td>
-                {% endif %}
-
-                <td>{{task.sstate_checksum}}</td>
-                <td>{{task.get_outcome_display}}{% if task.provider %}</br>(by <a href="#{{task.provider.recipe.name}}.{{task.provider.task_name}}">{{task.provider.recipe.name}}.{{task.provider.task_name}}</a>){% endif %}</td>
-                <td><p>{{task.message}}</td>
-                <td><a target="_fileview" href="file:///{{task.logfile}}">{{task.logfile}}</a></td>
-                <td>{{task.elapsed_time}}</td>
-                <td>{{task.cpu_usage}}</td>
-                <td>{{task.disk_io}}</td>
-                <td>{{task.get_script_type_display}}</td>
-                <td><a target="_fileview" href="file:///{{task.recipe.file_path}}">{{task.recipe.file_path}}</a></td>
-                <td>
-            <div style="height: 3em; overflow:auto">
-                {% for tt in task.task_dependencies_task.all %}
-                    <a href="#{{tt.depends_on.recipe.name}}.{{tt.depends_on.task_name}}">
-                    {{tt.depends_on.recipe.name}}.{{tt.depends_on.task_name}}</a><br/>
-                {% endfor %}
-            </div>
-                </td>
-                </tr>
-
-            {% endfor %}
-
-    {% endif %}
-
-{% endblock %}

bitbake/lib/toaster/bldviewer/templatetags/projecttags.py

@@ -1,26 +0,0 @@
-#
-# BitBake Toaster Implementation
-#
-# Copyright (C) 2013        Intel Corporation
-#
-# 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.
-
-from datetime import datetime
-from django import template
-
-register = template.Library()
-
-@register.simple_tag
-def time_difference(start_time, end_time):
-    return end_time - start_time

bitbake/lib/toaster/bldviewer/urls.py

@@ -1,32 +0,0 @@
-#
-# BitBake Toaster Implementation
-#
-# Copyright (C) 2013        Intel Corporation
-#
-# 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.
-
-from django.conf.urls import patterns, include, url
-from django.views.generic.simple import redirect_to
-
-urlpatterns = patterns('bldviewer.views',
-        url(r'^builds/$', 'build', name='all-builds'),
-        url(r'^build/(?P<build_id>\d+)/task/$', 'task', name='task'),
-        url(r'^build/(?P<build_id>\d+)/packages/$', 'bpackage', name='bpackage'),
-        url(r'^build/(?P<build_id>\d+)/package/(?P<package_id>\d+)/files/$', 'bfile', name='bfile'),
-        url(r'^build/(?P<build_id>\d+)/target/(?P<target_id>\d+)/packages/$', 'tpackage', name='tpackage'),
-        url(r'^build/(?P<build_id>\d+)/configuration/$', 'configuration', name='configuration'),
-        url(r'^layers/$', 'layer', name='all-layers'),
-        url(r'^layerversions/(?P<layerversion_id>\d+)/recipes/.*$', 'layer_versions_recipes', name='layer_versions_recipes'),
-        url(r'^$', redirect_to, {'url': 'builds/'}),
-)

bitbake/lib/toaster/bldviewer/views.py

@@ -1,260 +0,0 @@
-#
-# BitBake Toaster Implementation
-#
-# Copyright (C) 2013        Intel Corporation
-#
-# 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 operator
-
-from django.db.models import Q
-from django.shortcuts import render
-from orm.models import Build, Target, Task, Layer, Layer_Version, Recipe, Target_Package, LogMessage, Variable
-from orm.models import Task_Dependency, Recipe_Dependency, Build_Package, Build_File, Build_Package_Dependency
-from django.views.decorators.cache import cache_control
-
-@cache_control(no_store=True)
-def build(request):
-    template = 'build.html'
-    build_info = Build.objects.all()
-
-    logs = LogMessage.objects.all()
-
-    context = {'builds': build_info, 'logs': logs ,
-        'hideshowcols' : [
-                {'name': 'Output', 'order':10},
-                {'name': 'Log', 'order':11},
-            ]}
-
-    return render(request, template, context)
-
-
-def _find_task_revdep(task):
-    tp = []
-    for p in Task_Dependency.objects.filter(depends_on=task):
-        tp.append(p.task);
-    return tp
-
-def _find_task_provider(task):
-    task_revdeps = _find_task_revdep(task)
-    for tr in task_revdeps:
-        if tr.outcome != Task.OUTCOME_COVERED:
-            return tr
-    for tr in task_revdeps:
-        trc = _find_task_provider(tr)
-        if trc is not None:
-            return trc
-    return None
-
-def task(request, build_id):
-    template = 'task.html'
-
-    tasks = Task.objects.filter(build=build_id)
-
-    for t in tasks:
-        if t.outcome == Task.OUTCOME_COVERED:
-            t.provider = _find_task_provider(t)
-
-    context = {'build': Build.objects.filter(pk=build_id)[0], 'tasks': tasks}
-
-    return render(request, template, context)
-
-def configuration(request, build_id):
-    template = 'configuration.html'
-    variables = Variable.objects.filter(build=build_id)
-    context = {'build': Build.objects.filter(pk=build_id)[0], 'configuration' : variables}
-    return render(request, template, context)
-
-def bpackage(request, build_id):
-    template = 'bpackage.html'
-    packages = Build_Package.objects.filter(build = build_id)
-    context = {'build': Build.objects.filter(pk=build_id)[0], 'packages' : packages}
-    return render(request, template, context)
-
-def bfile(request, build_id, package_id):
-    template = 'bfile.html'
-    files = Build_File.objects.filter(bpackage = package_id)
-    context = {'build': Build.objects.filter(pk=build_id)[0], 'files' : files}
-    return render(request, template, context)
-
-def tpackage(request, build_id, target_id):
-    template = 'package.html'
-
-    packages = Target_Package.objects.filter(target=target_id)
-
-    context = {'build' : Build.objects.filter(pk=build_id)[0],'packages': packages}
-
-    return render(request, template, context)
-
-def layer(request):
-    template = 'layer.html'
-    layer_info = Layer.objects.all()
-
-    for li in layer_info:
-        li.versions = Layer_Version.objects.filter(layer = li)
-        for liv in li.versions:
-            liv.count = Recipe.objects.filter(layer_version__id = liv.id).count()
-
-    context = {'layers': layer_info}
-
-    return render(request, template, context)
-
-
-def layer_versions_recipes(request, layerversion_id):
-    template = 'recipe.html'
-    recipes = Recipe.objects.filter(layer_version__id = layerversion_id)
-
-    context = {'recipes': recipes,
-            'layer_version' : Layer_Version.objects.filter( id = layerversion_id )[0]
-    }
-
-    return render(request, template, context)
-
-#### API
-
-import json
-from django.core import serializers
-from django.http import HttpResponse, HttpResponseBadRequest
-
-
-def model_explorer(request, model_name):
-
-    DESCENDING = 'desc'
-    response_data = {}
-    model_mapping = {
-        'build': Build,
-        'target': Target,
-        'target_package': Target_Package,
-        'task': Task,
-        'task_dependency': Task_Dependency,
-        'package': Build_Package,
-        'layer': Layer,
-        'layerversion': Layer_Version,
-        'recipe': Recipe,
-        'recipe_dependency': Recipe_Dependency,
-        'build_package': Build_Package,
-        'build_package_dependency': Build_Package_Dependency,
-        'build_file': Build_File,
-        'variable': Variable,
-        'logmessage': LogMessage,
-        }
-
-    if model_name not in model_mapping.keys():
-        return HttpResponseBadRequest()
-
-    model = model_mapping[model_name]
-
-    try:
-        limit = int(request.GET.get('limit', 0))
-    except ValueError:
-        limit = 0
-
-    try:
-        offset = int(request.GET.get('offset', 0))
-    except ValueError:
-        offset = 0
-
-    ordering_string, invalid = _validate_input(request.GET.get('orderby', ''),
-                                               model)
-    if invalid:
-        return HttpResponseBadRequest()
-
-    filter_string, invalid = _validate_input(request.GET.get('filter', ''),
-                                             model)
-    if invalid:
-        return HttpResponseBadRequest()
-
-    search_term = request.GET.get('search', '')
-
-    if filter_string:
-        filter_terms = _get_filtering_terms(filter_string)
-        try:
-            queryset = model.objects.filter(**filter_terms)
-        except ValueError:
-            queryset = []
-    else:
-        queryset = model.objects.all()
-
-    if search_term:
-        queryset = _get_search_results(search_term, queryset, model)
-
-    if ordering_string and queryset:
-        column, order = ordering_string.split(':')
-        if order.lower() == DESCENDING:
-            queryset = queryset.order_by('-' + column)
-        else:
-            queryset = queryset.order_by(column)
-
-    if offset and limit:
-        queryset = queryset[offset:(offset+limit)]
-    elif offset:
-        queryset = queryset[offset:]
-    elif limit:
-        queryset = queryset[:limit]
-
-    if queryset:
-        response_data['count'] = queryset.count()
-    else:
-        response_data['count'] = 0
-
-    response_data['list'] = serializers.serialize('json', queryset)
-
-    return HttpResponse(json.dumps(response_data),
-                        content_type='application/json')
-
-def _get_filtering_terms(filter_string):
-
-    search_terms = filter_string.split(":")
-    keys = search_terms[0].split(',')
-    values = search_terms[1].split(',')
-
-    return dict(zip(keys, values))
-
-def _validate_input(input, model):
-
-    invalid = 0
-
-    if input:
-        input_list = input.split(":")
-
-        # Check we have only one colon
-        if len(input_list) != 2:
-            invalid = 1
-            return None, invalid
-
-        # Check we have an equal number of terms both sides of the colon
-        if len(input_list[0].split(',')) != len(input_list[1].split(',')):
-            invalid = 1
-            return None, invalid
-
-        # Check we are looking for a valid field
-        valid_fields = model._meta.get_all_field_names()
-        for field in input_list[0].split(','):
-            if field not in valid_fields:
-                invalid = 1
-                return None, invalid
-
-    return input, invalid
-
-def _get_search_results(search_term, queryset, model):
-    search_objects = []
-    for st in search_term.split(" "):
-        q_map = map(lambda x: Q(**{x+'__icontains': st}),
-                model.search_allowed_fields)
-
-        search_objects.append(reduce(operator.or_, q_map))
-    search_object = reduce(operator.and_, search_objects)
-    queryset = queryset.filter(search_object)
-
-    return queryset

bitbake/lib/toaster/manage.py

@@ -1,10 +0,0 @@
-#!/usr/bin/env python
-import os
-import sys
-
-if __name__ == "__main__":
-    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "toastermain.settings")
-
-    from django.core.management import execute_from_command_line
-
-    execute_from_command_line(sys.argv)

bitbake/lib/toaster/orm/models.py

@@ -1,260 +0,0 @@
-#
-# BitBake Toaster Implementation
-#
-# Copyright (C) 2013        Intel Corporation
-#
-# 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.
-
-from django.db import models
-from django.utils.encoding import python_2_unicode_compatible
-
-
-class Build(models.Model):
-    SUCCEEDED = 0
-    FAILED = 1
-    IN_PROGRESS = 2
-
-    BUILD_OUTCOME = (
-        (SUCCEEDED, 'Succeeded'),
-        (FAILED, 'Failed'),
-        (IN_PROGRESS, 'In Progress'),
-    )
-
-    search_allowed_fields = ['machine',
-                             'cooker_log_path']
-
-    machine = models.CharField(max_length=100)
-    image_fstypes = models.CharField(max_length=100)
-    distro = models.CharField(max_length=100)
-    distro_version = models.CharField(max_length=100)
-    started_on = models.DateTimeField()
-    completed_on = models.DateTimeField()
-    outcome = models.IntegerField(choices=BUILD_OUTCOME, default=IN_PROGRESS)
-    errors_no = models.IntegerField(default=0)
-    warnings_no = models.IntegerField(default=0)
-    cooker_log_path = models.CharField(max_length=500)
-    build_name = models.CharField(max_length=100)
-    bitbake_version = models.CharField(max_length=50)
-
-@python_2_unicode_compatible
-class Target(models.Model):
-    search_allowed_fields = ['target', 'image_fstypes', 'file_name']
-    build = models.ForeignKey(Build)
-    target = models.CharField(max_length=100)
-    is_image = models.BooleanField(default = False)
-    file_name = models.CharField(max_length=100)
-    file_size = models.IntegerField()
-
-    def __str__(self):
-        return self.target
-
-
-class Task(models.Model):
-
-    SSTATE_NA = 0
-    SSTATE_MISS = 1
-    SSTATE_FAILED = 2
-    SSTATE_RESTORED = 3
-
-    SSTATE_RESULT = (
-        (SSTATE_NA, 'Not Applicable'), # For rest of tasks, but they still need checking.
-        (SSTATE_MISS, 'Missing'), # it is a miss
-        (SSTATE_FAILED, 'Failed'), # there was a pkg, but the script failed
-        (SSTATE_RESTORED, 'Restored'), # succesfully restored
-    )
-
-    CODING_NOEXEC = 0
-    CODING_PYTHON = 1
-    CODING_SHELL = 2
-
-    TASK_CODING = (
-        (CODING_NOEXEC, 'NoExec'),
-        (CODING_PYTHON, 'Python'),
-        (CODING_SHELL, 'Shell'),
-    )
-
-    OUTCOME_SUCCESS = 0
-    OUTCOME_COVERED = 1
-    OUTCOME_SSTATE = 2
-    OUTCOME_EXISTING = 3
-    OUTCOME_FAILED = 4
-    OUTCOME_NA = 5
-
-    TASK_OUTCOME = (
-        (OUTCOME_SUCCESS, 'Succeeded'),
-        (OUTCOME_COVERED, 'Covered'),
-        (OUTCOME_SSTATE, 'Sstate'),
-        (OUTCOME_EXISTING, 'Existing'),
-        (OUTCOME_FAILED, 'Failed'),
-        (OUTCOME_NA, 'Not Available'),
-    )
-
-    build = models.ForeignKey(Build, related_name='task_build')
-    order = models.IntegerField(null=True)
-    task_executed = models.BooleanField(default=False) # True means Executed, False means Prebuilt
-    outcome = models.IntegerField(choices=TASK_OUTCOME, default=OUTCOME_NA)
-    sstate_checksum = models.CharField(max_length=100, blank=True)
-    path_to_sstate_obj = models.FilePathField(max_length=500, blank=True)
-    recipe = models.ForeignKey('Recipe', related_name='build_recipe')
-    task_name = models.CharField(max_length=100)
-    source_url = models.FilePathField(max_length=255, blank=True)
-    work_directory = models.FilePathField(max_length=255, blank=True)
-    script_type = models.IntegerField(choices=TASK_CODING, default=CODING_NOEXEC)
-    line_number = models.IntegerField(default=0)
-    disk_io = models.IntegerField(null=True)
-    cpu_usage = models.DecimalField(max_digits=6, decimal_places=2, null=True)
-    elapsed_time = models.CharField(max_length=50, default=0)
-    sstate_result = models.IntegerField(choices=SSTATE_RESULT, default=SSTATE_NA)
-    message = models.CharField(max_length=240)
-    logfile = models.FilePathField(max_length=255, blank=True)
-
-    class Meta:
-        ordering = ('order', 'recipe' ,)
-
-
-class Task_Dependency(models.Model):
-    task = models.ForeignKey(Task, related_name='task_dependencies_task')
-    depends_on = models.ForeignKey(Task, related_name='task_dependencies_depends')
-
-
-class Build_Package(models.Model):
-    build = models.ForeignKey('Build')
-    recipe = models.ForeignKey('Recipe', null=True)
-    name = models.CharField(max_length=100)
-    version = models.CharField(max_length=100, blank=True)
-    revision = models.CharField(max_length=32, blank=True)
-    summary = models.CharField(max_length=200, blank=True)
-    description = models.CharField(max_length=200, blank=True)
-    size = models.IntegerField(default=0)
-    section = models.CharField(max_length=80, blank=True)
-    license = models.CharField(max_length=80, blank=True)
-
-class Build_Package_Dependency(models.Model):
-    TYPE_RDEPENDS = 0
-    TYPE_RPROVIDES = 1
-    TYPE_RRECOMMENDS = 2
-    TYPE_RSUGGESTS = 3
-    TYPE_RREPLACES = 4
-    TYPE_RCONFLICTS = 5
-    DEPENDS_TYPE = (
-        (TYPE_RDEPENDS, "rdepends"),
-        (TYPE_RPROVIDES, "rprovides"),
-        (TYPE_RRECOMMENDS, "rrecommends"),
-        (TYPE_RSUGGESTS, "rsuggests"),
-        (TYPE_RREPLACES, "rreplaces"),
-        (TYPE_RCONFLICTS, "rconflicts"),
-    )
-    package = models.ForeignKey(Build_Package, related_name='bpackage_dependencies_package')
-    depends_on = models.CharField(max_length=100)   # soft dependency
-    dep_type = models.IntegerField(choices=DEPENDS_TYPE)
-
-
-class Target_Package(models.Model):
-    target = models.ForeignKey('Target')
-    recipe = models.ForeignKey('Recipe', null=True)
-    name = models.CharField(max_length=100)
-    version = models.CharField(max_length=100, blank=True)
-    size = models.IntegerField()
-
-
-class Target_Package_Dependency(models.Model):
-    TYPE_DEPENDS = 0
-    TYPE_RDEPENDS = 1
-    TYPE_RECOMMENDS = 2
-
-    DEPENDS_TYPE = (
-        (TYPE_DEPENDS, "depends"),
-        (TYPE_RDEPENDS, "rdepends"),
-        (TYPE_RECOMMENDS, "recommends"),
-    )
-    package = models.ForeignKey(Target_Package, related_name='tpackage_dependencies_package')
-    depends_on = models.ForeignKey(Target_Package, related_name='tpackage_dependencies_depends')
-    dep_type = models.IntegerField(choices=DEPENDS_TYPE)
-
-
-class Build_File(models.Model):
-    bpackage = models.ForeignKey(Build_Package, related_name='filelist_bpackage')
-    path = models.FilePathField(max_length=255, blank=True)
-    size = models.IntegerField()
-
-class Target_File(models.Model):
-    tpackage = models.ForeignKey(Target_Package, related_name='filelist_tpackage')
-    path = models.FilePathField(max_length=255, blank=True)
-    size = models.IntegerField()
-
-
-class Recipe(models.Model):
-    name = models.CharField(max_length=100, blank=True)
-    version = models.CharField(max_length=100, blank=True)
-    layer_version = models.ForeignKey('Layer_Version', related_name='recipe_layer_version')
-    summary = models.CharField(max_length=100, blank=True)
-    description = models.CharField(max_length=100, blank=True)
-    section = models.CharField(max_length=100, blank=True)
-    license = models.CharField(max_length=200, blank=True)
-    licensing_info = models.TextField(blank=True)
-    homepage = models.URLField(blank=True)
-    bugtracker = models.URLField(blank=True)
-    author = models.CharField(max_length=100, blank=True)
-    file_path = models.FilePathField(max_length=255)
-
-
-class Recipe_Dependency(models.Model):
-    TYPE_DEPENDS = 0
-    TYPE_RDEPENDS = 1
-
-    DEPENDS_TYPE = (
-        (TYPE_DEPENDS, "depends"),
-        (TYPE_RDEPENDS, "rdepends"),
-    )
-    recipe = models.ForeignKey(Recipe, related_name='r_dependencies_recipe')
-    depends_on = models.ForeignKey(Recipe, related_name='r_dependencies_depends')
-    dep_type = models.IntegerField(choices=DEPENDS_TYPE)
-
-class Layer(models.Model):
-    name = models.CharField(max_length=100)
-    local_path = models.FilePathField(max_length=255)
-    layer_index_url = models.URLField()
-
-
-class Layer_Version(models.Model):
-    layer = models.ForeignKey(Layer, related_name='layer_version_layer')
-    branch = models.CharField(max_length=50)
-    commit = models.CharField(max_length=100)
-    priority = models.IntegerField()
-
-
-class Variable(models.Model):
-    build = models.ForeignKey(Build, related_name='variable_build')
-    variable_name = models.CharField(max_length=100)
-    variable_value = models.TextField(blank=True)
-    file = models.FilePathField(max_length=255)
-    changed = models.BooleanField(default=False)
-    human_readable_name = models.CharField(max_length=200)
-    description = models.TextField(blank=True)
-
-
-class LogMessage(models.Model):
-    INFO = 0
-    WARNING = 1
-    ERROR = 2
-
-    LOG_LEVEL = ( (INFO, "info"),
-            (WARNING, "warn"),
-            (ERROR, "error") )
-
-    build = models.ForeignKey(Build)
-    level = models.IntegerField(choices=LOG_LEVEL, default=INFO)
-    message=models.CharField(max_length=240)
-    pathname = models.FilePathField(max_length=255, blank=True)
-    lineno = models.IntegerField(null=True)