bitbake: cooker/bitbake-layers/tinfoil: Fix recipecache typo

(Bitbake rev: 0f5eee689992f84d263cb817dc2ce755a9a075f7)

Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>

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.recpiecache.bbfile_config_priorities:
+            for layer, _, regex, pri in self.bbhandler.cooker.recipecache.bbfile_config_priorities:
                 if regex.match(os.path.join(layerdir, 'test')):
                     layerpri = pri
                     break
@@ -225,9 +225,9 @@ 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.recpiecache.pkg_pn
-        (latest_versions, preferred_versions) = bb.providers.findProviders(self.bbhandler.cooker.configuration.data, self.bbhandler.cooker.recpiecache, pkg_pn)
-        allproviders = bb.providers.allProviders(self.bbhandler.cooker.recpiecache)
+        pkg_pn = self.bbhandler.cooker.recipecache.pkg_pn
+        (latest_versions, preferred_versions) = bb.providers.findProviders(self.bbhandler.cooker.configuration.data, self.bbhandler.cooker.recipecache, pkg_pn)
+        allproviders = bb.providers.allProviders(self.bbhandler.cooker.recipecache)
 
         # Ensure we list skipped recipes
         # We are largely guessing about PN, PV and the preferred version here,
@@ -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.recpiecache.bbfile_config_priorities:
+        for layername, pattern, regex, _ in self.bbhandler.cooker.recipecache.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.recpiecache.bbfile_config_priorities:
+        for layer, _, regex, _ in self.bbhandler.cooker.recipecache.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.recpiecache.bbfile_config_priorities:
+        for layer, _, regex, _ in self.bbhandler.cooker.recipecache.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):

bitbake/lib/bb/cooker.py

@@ -88,7 +88,7 @@ class BBCooker:
     """
 
     def __init__(self, configuration, server_registration_cb, savedenv={}):
-        self.recpiecache = None
+        self.recipecache = None
         self.skiplist = {}
 
         self.server_registration_cb = server_registration_cb
@@ -304,9 +304,9 @@ class BBCooker:
             nice = int(nice) - curnice
             buildlog.verbose("Renice to %s " % os.nice(nice))
 
-        if self.recpiecache:
-            del self.recpiecache
-        self.recpiecache = bb.cache.CacheData(self.caches_array)
+        if self.recipecache:
+            del self.recipecache
+        self.recipecache = bb.cache.CacheData(self.caches_array)
 
         self.handleCollections( self.configuration.data.getVar("BBFILE_COLLECTIONS", True) )
 
@@ -359,8 +359,8 @@ class BBCooker:
 
     def showVersions(self):
 
-        pkg_pn = self.recpiecache.pkg_pn
-        (latest_versions, preferred_versions) = bb.providers.findProviders(self.configuration.data, self.recpiecache, pkg_pn)
+        pkg_pn = self.recipecache.pkg_pn
+        (latest_versions, preferred_versions) = bb.providers.findProviders(self.configuration.data, self.recipecache, pkg_pn)
 
         logger.plain("%-35s %25s %25s", "Recipe Name", "Latest Version", "Preferred Version")
         logger.plain("%-35s %25s %25s\n", "===========", "==============", "=================")
@@ -402,8 +402,8 @@ class BBCooker:
             bb.data.expandKeys(localdata)
 
             taskdata = bb.taskdata.TaskData(self.configuration.abort)
-            taskdata.add_provider(localdata, self.recpiecache, pkgs_to_build[0])
-            taskdata.add_unresolved(localdata, self.recpiecache)
+            taskdata.add_provider(localdata, self.recipecache, pkgs_to_build[0])
+            taskdata.add_unresolved(localdata, self.recipecache)
 
             targetid = taskdata.getbuild_id(pkgs_to_build[0])
             fnid = taskdata.build_targets[targetid][0]
@@ -457,11 +457,11 @@ class BBCooker:
         runlist = []
         current = 0
         for k in pkgs_to_build:
-            taskdata.add_provider(localdata, self.recpiecache, k)
+            taskdata.add_provider(localdata, self.recipecache, k)
             runlist.append([k, "do_%s" % task])
             current += 1
             bb.event.fire(bb.event.TreeDataPreparationProgress(current, len(pkgs_to_build)), self.configuration.data)
-        taskdata.add_unresolved(localdata, self.recpiecache)
+        taskdata.add_unresolved(localdata, self.recipecache)
         bb.event.fire(bb.event.TreeDataPreparationCompleted(len(pkgs_to_build)), self.configuration.data)
         return runlist, taskdata
     
@@ -473,7 +473,7 @@ class BBCooker:
         information.
         """
         runlist, taskdata = self.prepareTreeData(pkgs_to_build, task)
-        rq = bb.runqueue.RunQueue(self, self.configuration.data, self.recpiecache, taskdata, runlist)
+        rq = bb.runqueue.RunQueue(self, self.configuration.data, self.recipecache, taskdata, runlist)
         rq.rqdata.prepare()
 
         seen_fnids = []
@@ -490,15 +490,15 @@ class BBCooker:
             taskname = rq.rqdata.runq_task[task]
             fnid = rq.rqdata.runq_fnid[task]
             fn = taskdata.fn_index[fnid]
-            pn = self.recpiecache.pkg_fn[fn]
-            version  = "%s:%s-%s" % self.recpiecache.pkg_pepvpr[fn]
+            pn = self.recipecache.pkg_fn[fn]
+            version  = "%s:%s-%s" % self.recipecache.pkg_pepvpr[fn]
             if pn not in depend_tree["pn"]:
                 depend_tree["pn"][pn] = {}
                 depend_tree["pn"][pn]["filename"] = fn
                 depend_tree["pn"][pn]["version"] = version
             for dep in rq.rqdata.runq_depends[task]:
                 depfn = taskdata.fn_index[rq.rqdata.runq_fnid[dep]]
-                deppn = self.recpiecache.pkg_fn[depfn]
+                deppn = self.recipecache.pkg_fn[depfn]
                 dotname = "%s.%s" % (pn, rq.rqdata.runq_task[task])
                 if not dotname in depend_tree["tdepends"]:
                     depend_tree["tdepends"][dotname] = []
@@ -515,14 +515,14 @@ class BBCooker:
                 for rdep in taskdata.rdepids[fnid]:
                     depend_tree["rdepends-pn"][pn].append(taskdata.run_names_index[rdep])
 
-                rdepends = self.recpiecache.rundeps[fn]
+                rdepends = self.recipecache.rundeps[fn]
                 for package in rdepends:
                     depend_tree["rdepends-pkg"][package] = []
                     for rdepend in rdepends[package]:
                         depend_tree["rdepends-pkg"][package].append(rdepend)
                     packages.append(package)
 
-                rrecs = self.recpiecache.runrecs[fn]
+                rrecs = self.recipecache.runrecs[fn]
                 for package in rrecs:
                     depend_tree["rrecs-pkg"][package] = []
                     for rdepend in rrecs[package]:
@@ -561,19 +561,19 @@ class BBCooker:
         for task in xrange(len(tasks_fnid)):
             fnid = tasks_fnid[task]
             fn = taskdata.fn_index[fnid]
-            pn = self.recpiecache.pkg_fn[fn]
-            version  = "%s:%s-%s" % self.recpiecache.pkg_pepvpr[fn]
-            summary = self.recpiecache.summary[fn]
-            lic = self.recpiecache.license[fn]
-            section = self.recpiecache.section[fn]
-            description = self.recpiecache.description[fn]
-            homepage = self.recpiecache.homepage[fn]
-            bugtracker = self.recpiecache.bugtracker[fn]
-            files_info = self.recpiecache.files_info[fn]
-            rdepends = self.recpiecache.rundeps[fn]
-            rrecs = self.recpiecache.runrecs[fn]
-            prevision = self.recpiecache.prevision[fn]
-            inherits = self.recpiecache.inherits.get(fn, None)
+            pn = self.recipecache.pkg_fn[fn]
+            version  = "%s:%s-%s" % self.recipecache.pkg_pepvpr[fn]
+            summary = self.recipecache.summary[fn]
+            lic = self.recipecache.license[fn]
+            section = self.recipecache.section[fn]
+            description = self.recipecache.description[fn]
+            homepage = self.recipecache.homepage[fn]
+            bugtracker = self.recipecache.bugtracker[fn]
+            files_info = self.recipecache.files_info[fn]
+            rdepends = self.recipecache.rundeps[fn]
+            rrecs = self.recipecache.runrecs[fn]
+            prevision = self.recipecache.prevision[fn]
+            inherits = self.recipecache.inherits.get(fn, None)
             if pn not in depend_tree["pn"]:
                 depend_tree["pn"][pn] = {}
                 depend_tree["pn"][pn]["filename"] = fn
@@ -599,7 +599,7 @@ class BBCooker:
                     if targetid in taskdata.build_targets and taskdata.build_targets[targetid]:
                         id = taskdata.build_targets[targetid][0]
                         fn_provider = taskdata.fn_index[id]
-                        pn_provider = self.recpiecache.pkg_fn[fn_provider]
+                        pn_provider = self.recipecache.pkg_fn[fn_provider]
                     else:
                         pn_provider = item
                     depend_tree["depends"][pn].append(pn_provider)
@@ -612,7 +612,7 @@ class BBCooker:
                     if targetid in taskdata.run_targets and taskdata.run_targets[targetid]:
                         id = taskdata.run_targets[targetid][0]
                         fn_rprovider = taskdata.fn_index[id]
-                        pn_rprovider = self.recpiecache.pkg_fn[fn_rprovider]
+                        pn_rprovider = self.recipecache.pkg_fn[fn_rprovider]
                     else:
                         pn_rprovider = item
                     depend_tree["rdepends-pn"][pn].append(pn_rprovider)
@@ -693,7 +693,7 @@ class BBCooker:
 
     def show_appends_with_no_recipes( self ):
         recipes = set(os.path.basename(f)
-                      for f in self.recpiecache.pkg_fn.iterkeys())
+                      for f in self.recipecache.pkg_fn.iterkeys())
         recipes |= set(os.path.basename(f)
                       for f in self.skiplist.iterkeys())
         appended_recipes = self.collection.appendlist.iterkeys()
@@ -725,9 +725,9 @@ class BBCooker:
             except:
                 providerlog.critical("Malformed option in PREFERRED_PROVIDERS variable: %s" % p)
                 continue
-            if providee in self.recpiecache.preferred and self.recpiecache.preferred[providee] != provider:
-                providerlog.error("conflicting preferences for %s: both %s and %s specified", providee, provider, self.recpiecache.preferred[providee])
-            self.recpiecache.preferred[providee] = provider
+            if providee in self.recipecache.preferred and self.recipecache.preferred[providee] != provider:
+                providerlog.error("conflicting preferences for %s: both %s and %s specified", providee, provider, self.recipecache.preferred[providee])
+            self.recipecache.preferred[providee] = provider
 
     def findCoreBaseFiles(self, subdir, configfile):
         corebase = self.configuration.data.getVar('COREBASE', True) or ""
@@ -824,10 +824,10 @@ class BBCooker:
         """
         pkg_list = []
 
-        for pfn in self.recpiecache.pkg_fn:
-            inherits = self.recpiecache.inherits.get(pfn, None)
+        for pfn in self.recipecache.pkg_fn:
+            inherits = self.recipecache.inherits.get(pfn, None)
             if inherits and inherits.count(klass) > 0:
-                pkg_list.append(self.recpiecache.pkg_fn[pfn])
+                pkg_list.append(self.recipecache.pkg_fn[pfn])
 
         return pkg_list
 
@@ -854,22 +854,22 @@ class BBCooker:
          Build package list for "bitbake world"
         """
         parselog.debug(1, "collating packages for \"world\"")
-        for f in self.recpiecache.possible_world:
+        for f in self.recipecache.possible_world:
             terminal = True
-            pn = self.recpiecache.pkg_fn[f]
+            pn = self.recipecache.pkg_fn[f]
 
-            for p in self.recpiecache.pn_provides[pn]:
+            for p in self.recipecache.pn_provides[pn]:
                 if p.startswith('virtual/'):
                     parselog.debug(2, "World build skipping %s due to %s provider starting with virtual/", f, p)
                     terminal = False
                     break
-                for pf in self.recpiecache.providers[p]:
-                    if self.recpiecache.pkg_fn[pf] != pn:
+                for pf in self.recipecache.providers[p]:
+                    if self.recipecache.pkg_fn[pf] != pn:
                         parselog.debug(2, "World build skipping %s due to both us and %s providing %s", f, pf, p)
                         terminal = False
                         break
             if terminal:
-                self.recpiecache.world_target.add(pn)
+                self.recipecache.world_target.add(pn)
 
     def interactiveMode( self ):
         """Drop off into a shell"""
@@ -955,7 +955,7 @@ class BBCooker:
     def handleCollections( self, collections ):
         """Handle collections"""
         errors = False
-        self.recpiecache.bbfile_config_priorities = []
+        self.recipecache.bbfile_config_priorities = []
         if collections:
             collection_priorities = {}
             collection_depends = {}
@@ -1045,7 +1045,7 @@ class BBCooker:
                     parselog.error("BBFILE_PATTERN_%s \"%s\" is not a valid regular expression", c, regex)
                     errors = True
                     continue
-                self.recpiecache.bbfile_config_priorities.append((c, regex, cre, collection_priorities[c]))
+                self.recipecache.bbfile_config_priorities.append((c, regex, cre, collection_priorities[c]))
         if errors:
             # We've already printed the actual error(s)
             raise CollectionError("Errors during parsing layer configuration")
@@ -1065,7 +1065,7 @@ class BBCooker:
         if bf.startswith("/") or bf.startswith("../"):
             bf = os.path.abspath(bf)
 
-        self.collection = CookerCollectFiles(self.recpiecache.bbfile_config_priorities)
+        self.collection = CookerCollectFiles(self.recipecache.bbfile_config_priorities)
         filelist, masked = self.collection.collect_bbfiles(self.configuration.data, self.configuration.event_data)
         try:
             os.stat(bf)
@@ -1119,7 +1119,7 @@ class BBCooker:
 
         self.buildSetVars()
 
-        self.recpiecache = bb.cache.CacheData(self.caches_array)
+        self.recipecache = bb.cache.CacheData(self.caches_array)
         infos = bb.cache.Cache.parse(fn, self.collection.get_file_appends(fn), \
                                      self.configuration.data,
                                      self.caches_array)
@@ -1134,27 +1134,27 @@ class BBCooker:
         if info_array[0].skipped:
             bb.fatal("%s was skipped: %s" % (fn, info_array[0].skipreason))
 
-        self.recpiecache.add_from_recipeinfo(fn, info_array)
+        self.recipecache.add_from_recipeinfo(fn, info_array)
 
         # Tweak some variables
         item = info_array[0].pn
-        self.recpiecache.ignored_dependencies = set()
-        self.recpiecache.bbfile_priority[fn] = 1
+        self.recipecache.ignored_dependencies = set()
+        self.recipecache.bbfile_priority[fn] = 1
 
         # Remove external dependencies
-        self.recpiecache.task_deps[fn]['depends'] = {}
-        self.recpiecache.deps[fn] = []
-        self.recpiecache.rundeps[fn] = []
-        self.recpiecache.runrecs[fn] = []
+        self.recipecache.task_deps[fn]['depends'] = {}
+        self.recipecache.deps[fn] = []
+        self.recipecache.rundeps[fn] = []
+        self.recipecache.runrecs[fn] = []
 
         # Invalidate task for target if force mode active
         if self.configuration.force:
             logger.verbose("Invalidate task %s, %s", task, fn)
-            bb.parse.siggen.invalidate_task('do_%s' % task, self.recpiecache, fn)
+            bb.parse.siggen.invalidate_task('do_%s' % task, self.recipecache, fn)
 
         # Setup taskdata structure
         taskdata = bb.taskdata.TaskData(self.configuration.abort)
-        taskdata.add_provider(self.configuration.data, self.recpiecache, item)
+        taskdata.add_provider(self.configuration.data, self.recipecache, item)
 
         buildname = self.configuration.data.getVar("BUILDNAME")
         bb.event.fire(bb.event.BuildStarted(buildname, [item]), self.configuration.event_data)
@@ -1162,7 +1162,7 @@ class BBCooker:
         # Execute the runqueue
         runlist = [[item, "do_%s" % task]]
 
-        rq = bb.runqueue.RunQueue(self, self.configuration.data, self.recpiecache, taskdata, runlist)
+        rq = bb.runqueue.RunQueue(self, self.configuration.data, self.recipecache, taskdata, runlist)
 
         def buildFileIdle(server, rq, abort):
 
@@ -1238,11 +1238,11 @@ class BBCooker:
 
         runlist = []
         for k in targets:
-            taskdata.add_provider(localdata, self.recpiecache, k)
+            taskdata.add_provider(localdata, self.recipecache, k)
             runlist.append([k, "do_%s" % task])
-        taskdata.add_unresolved(localdata, self.recpiecache)
+        taskdata.add_unresolved(localdata, self.recipecache)
 
-        rq = bb.runqueue.RunQueue(self, self.configuration.data, self.recpiecache, taskdata, runlist)
+        rq = bb.runqueue.RunQueue(self, self.configuration.data, self.recipecache, taskdata, runlist)
         if universe:
             rq.rqdata.warn_multi_bb = True
 
@@ -1279,12 +1279,12 @@ class BBCooker:
             self.parseConfiguration ()
 
             ignore = self.configuration.data.getVar("ASSUME_PROVIDED", True) or ""
-            self.recpiecache.ignored_dependencies = set(ignore.split())
+            self.recipecache.ignored_dependencies = set(ignore.split())
 
             for dep in self.configuration.extra_assume_provided:
-                self.recpiecache.ignored_dependencies.add(dep)
+                self.recipecache.ignored_dependencies.add(dep)
 
-            self.collection = CookerCollectFiles(self.recpiecache.bbfile_config_priorities)
+            self.collection = CookerCollectFiles(self.recipecache.bbfile_config_priorities)
             (filelist, masked) = self.collection.collect_bbfiles(self.configuration.data, self.configuration.event_data)
 
             self.configuration.data.renameVar("__depends", "__base_depends")
@@ -1298,7 +1298,7 @@ class BBCooker:
                 sys.exit(1)
             self.show_appends_with_no_recipes()
             self.handlePrefProviders()
-            self.recpiecache.bbfile_priority = self.collection.collection_priorities(self.recpiecache.pkg_fn)
+            self.recipecache.bbfile_priority = self.collection.collection_priorities(self.recipecache.pkg_fn)
             self.state = state.running
             return None
 
@@ -1312,14 +1312,14 @@ class BBCooker:
         if 'world' in pkgs_to_build:
             self.buildWorldTargetList()
             pkgs_to_build.remove('world')
-            for t in self.recpiecache.world_target:
+            for t in self.recipecache.world_target:
                 pkgs_to_build.append(t)
 
         if 'universe' in pkgs_to_build:
             parselog.warn("The \"universe\" target is only intended for testing and may produce errors.")
             parselog.debug(1, "collating packages for \"universe\"")
             pkgs_to_build.remove('universe')
-            for t in self.recpiecache.universe_target:
+            for t in self.recipecache.universe_target:
                 pkgs_to_build.append(t)
 
         return pkgs_to_build
@@ -1837,7 +1837,7 @@ class CookerParser(object):
             if info_array[0].skipped:
                 self.skipped += 1
                 self.cooker.skiplist[virtualfn] = SkippedPackage(info_array[0])
-            self.bb_cache.add_info(virtualfn, info_array, self.cooker.recpiecache,
+            self.bb_cache.add_info(virtualfn, info_array, self.cooker.recipecache,
                                         parsed=parsed)
         return True
 
@@ -1846,4 +1846,4 @@ class CookerParser(object):
                                     self.cooker.collection.get_file_appends(filename),
                                     self.cfgdata, self.cooker.caches_array)
         for vfn, info_array in infos:
-            self.cooker.recpiecache.add_from_recipeinfo(vfn, info_array)
+            self.cooker.recipecache.add_from_recipeinfo(vfn, info_array)

bitbake/lib/bb/tinfoil.py

@@ -71,13 +71,13 @@ class Tinfoil:
         self.logger.setLevel(logging.INFO)
         sys.stderr.write("done.\n")
 
-        self.cooker_data = self.cooker.recpiecache
+        self.cooker_data = self.cooker.recipecache
 
     def prepare(self, config_only = False):
         if not self.cooker_data:
             if config_only:
                 self.cooker.parseConfiguration()
-                self.cooker_data = self.cooker.recpiecache
+                self.cooker_data = self.cooker.recipecache
             else:
                 self.parseRecipes()