2 files changed, 139 insertions, 118 deletions

diff --git a/bitbake/lib/bb/cooker.py b/bitbake/lib/bb/cooker.py
index ca544558f0..daf37ebd45 100644
--- a/bitbake/lib/bb/cooker.py
+++ b/bitbake/lib/bb/cooker.py
@@ -93,15 +93,6 @@ class BBCooker:
 
         self.configuration = configuration
 
-        # 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()
-        savedenv = configuration.params.environment
-        for k in savedenv:
-            self.savedenv.setVar(k, savedenv[k])
-
         self.caches_array = []
         # Currently, only Image Creator hob ui needs extra cache.
         # So, we save Extra Cache class name and container file
@@ -170,16 +161,12 @@ class BBCooker:
         self.parser = None
 
     def initConfigurationData(self):
-        self.configuration.data = bb.data.init()
-        if self.configuration.tracking:
-            self.configuration.data.enableTracking()
-
+        worker = False
         if not self.configuration.server_register_idlecallback:
-            self.configuration.data.setVar("BB_WORKERCONTEXT", "1")
+            worker = True
 
-        filtered_keys = bb.utils.approved_variables()
-        bb.data.inheritFromOS(self.configuration.data, self.savedenv, filtered_keys)
-        self.configuration.data.setVar("BB_ORIGENV", self.savedenv)
+        self.databuilder = bb.cookerdata.CookerDataBuilder(self.configuration.params, worker)
+        self.configuration.data = self.databuilder.data
 
     def enableDataTracking(self):
         self.configuration.data.enableTracking()
@@ -189,15 +176,9 @@ class BBCooker:
 
     def loadConfigurationData(self):
         self.initConfigurationData()
-
-        try:
-            self.parseConfigurationFiles(self.configuration.prefile,
-                                         self.configuration.postfile)
-        except SyntaxError:
-            sys.exit(1)
-        except Exception:
-            logger.exception("Error parsing configuration files")
-            sys.exit(1)
+        self.databuilder.parseBaseConfiguration()
+        self.configuration.data = self.databuilder.data
+        self.configuration.data_hash = self.databuilder.data_hash
 
     def saveConfigurationVar(self, var, val, default_file):
 
@@ -260,7 +241,7 @@ class BBCooker:
             self.configuration.data.varhistory.del_var_history(var)
 
             #add var to the end of default_file
-            default_file = self._findConfigFile(default_file)
+            default_file = bb.cookerdata.findConfigFile(default_file)
 
             with open(default_file, 'r') as f:
                 contents = f.readlines()
@@ -700,7 +681,7 @@ class BBCooker:
         Find the location on disk of configfile and if it exists and was parsed by BitBake
         emit the ConfigFilePathFound event with the path to the file.
         """
-        path = self._findConfigFile(configfile)
+        path = bb.cookerdata.findConfigFile(configfile)
         if not path:
             return
 
@@ -835,76 +816,6 @@ class BBCooker:
         else:
             shell.start( self )
 
-    def _findConfigFile(self, configfile):
-        path = os.getcwd()
-        while path != "/":
-            confpath = os.path.join(path, "conf", configfile)
-            if os.path.exists(confpath):
-                return confpath
-
-            path, _ = os.path.split(path)
-        return None
-
-    def _findLayerConf(self):
-        return self._findConfigFile("bblayers.conf")
-
-    def parseConfigurationFiles(self, prefiles, postfiles):
-        data = self.configuration.data
-        bb.parse.init_parser(data)
-
-        # Parse files for loading *before* bitbake.conf and any includes
-        for f in prefiles:
-            data = _parse(f, data)
-
-        layerconf = self._findLayerConf()
-        if layerconf:
-            parselog.debug(2, "Found bblayers.conf (%s)", layerconf)
-            data = _parse(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(os.path.join(layer, "conf", "layer.conf"), data)
-                data.expandVarref('LAYERDIR')
-
-            data.delVar('LAYERDIR')
-
-        if not data.getVar("BBPATH", True):
-            raise SystemExit("The BBPATH variable is not set")
-
-        data = _parse(os.path.join("conf", "bitbake.conf"), data)
-
-        # Parse files for loading *after* bitbake.conf and any includes
-        for p in postfiles:
-            data = _parse(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))
-
-        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.configuration.prefile,
-                                         self.configuration.postfile)
-        else:
-            bb.parse.init_parser(data)
-            data.setVar('BBINCLUDED',bb.parse.get_file_depends(data))
-            self.configuration.data = data
-            self.configuration.data_hash = data.get_hash()
 
     def handleCollections( self, collections ):
         """Handle collections"""
@@ -1501,26 +1412,6 @@ class CookerCollectFiles(object):
 
         return priorities
 
-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:
-            parselog.critical("Unable to parse %s: %s" % (fn, exc))
-            sys.exit(1)
-    return wrapped
-
-@catch_parse_error
-def _parse(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
-
 class ParsingFailure(Exception):
     def __init__(self, realexception, recipe):
         self.realexception = realexception
diff --git a/bitbake/lib/bb/cookerdata.py b/bitbake/lib/bb/cookerdata.py
index 3c2469ef87..0b436b37e6 100644
--- a/bitbake/lib/bb/cookerdata.py
+++ b/bitbake/lib/bb/cookerdata.py
@@ -126,3 +126,133 @@ class CookerConfiguration(object):
     def setServerRegIdleCallback(self, srcb):
         self.server_register_idlecallback = srcb
 
+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:
+            parselog.critical("Unable to parse %s: %s" % (fn, exc))
+            sys.exit(1)
+    return wrapped
+
+@catch_parse_error
+def _parse(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):
+    path = os.getcwd()
+    while path != "/":
+        confpath = os.path.join(path, "conf", configfile)
+        if os.path.exists(confpath):
+            return confpath
+
+        path, _ = os.path.split(path)
+    return None
+
+class CookerDataBuilder(object):
+
+    def __init__(self, params, worker = False):
+
+        self.prefiles = params.prefile
+        self.postfiles = params.postfile
+        self.tracking = params.tracking
+
+        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()
+        savedenv = params.environment
+        for k in savedenv:
+            self.savedenv.setVar(k, savedenv[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):
+        return findConfigFile("bblayers.conf")
+
+    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(f, data)
+
+        layerconf = self._findLayerConf()
+        if layerconf:
+            parselog.debug(2, "Found bblayers.conf (%s)", layerconf)
+            data = _parse(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(os.path.join(layer, "conf", "layer.conf"), data)
+                data.expandVarref('LAYERDIR')
+
+            data.delVar('LAYERDIR')
+
+        if not data.getVar("BBPATH", True):
+            raise SystemExit("The BBPATH variable is not set")
+
+        data = _parse(os.path.join("conf", "bitbake.conf"), data)
+
+        # Parse files for loading *after* bitbake.conf and any includes
+        for p in postfiles:
+            data = _parse(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))
+
+        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()
+
+
+