parsespin = itertools.cycle( r'|/-\\' )
-__version__ = "1.7.0"
-
-#============================================================================#
-# BBParsingStatus
-#============================================================================#
-class BBParsingStatus:
- """
- The initial idea for this status class is to use the data when it is
- already loaded instead of loading it from various place over and over
- again.
- """
-
- def __init__(self):
- """
- Direct cache variables
- """
- self.providers = {}
- self.rproviders = {}
- self.packages = {}
- self.packages_dynamic = {}
- self.possible_world = []
- self.pkg_pn = {}
- self.pkg_fn = {}
- self.pkg_pvpr = {}
- self.pkg_dp = {}
- self.pn_provides = {}
- self.all_depends = Set()
- self.build_all = {}
- self.deps = {}
- self.rundeps = {}
- self.runrecs = {}
- self.task_queues = {}
- self.task_deps = {}
- self.stamp = {}
- self.preferred = {}
-
- """
- Indirect Cache variables
- """
- self.ignored_dependencies = []
- self.world_target = Set()
- self.bbfile_priority = {}
- self.bbfile_config_priorities = []
-
-
- def handle_bb_data(self, file_name, bb_cache, cached):
- """
- We will fill the dictionaries with the stuff we
- need for building the tree more fast
- """
-
- pn = bb_cache.getVar('PN', file_name, True)
- pv = bb_cache.getVar('PV', file_name, True)
- pr = bb_cache.getVar('PR', file_name, True)
- dp = int(bb_cache.getVar('DEFAULT_PREFERENCE', file_name, True) or "0")
- provides = Set([pn] + (bb_cache.getVar("PROVIDES", file_name, True) or "").split())
- depends = (bb_cache.getVar("DEPENDS", file_name, True) or "").split()
- packages = (bb_cache.getVar('PACKAGES', file_name, True) or "").split()
- packages_dynamic = (bb_cache.getVar('PACKAGES_DYNAMIC', file_name, True) or "").split()
- rprovides = (bb_cache.getVar("RPROVIDES", file_name, True) or "").split()
-
- self.task_queues[file_name] = bb_cache.getVar("_task_graph", file_name, True)
- self.task_deps[file_name] = bb_cache.getVar("_task_deps", file_name, True)
-
- # build PackageName to FileName lookup table
- if pn not in self.pkg_pn:
- self.pkg_pn[pn] = []
- self.pkg_pn[pn].append(file_name)
-
- self.build_all[file_name] = int(bb_cache.getVar('BUILD_ALL_DEPS', file_name, True) or "0")
- self.stamp[file_name] = bb_cache.getVar('STAMP', file_name, True)
-
- # build FileName to PackageName lookup table
- self.pkg_fn[file_name] = pn
- self.pkg_pvpr[file_name] = (pv,pr)
- self.pkg_dp[file_name] = dp
-
- # Build forward and reverse provider hashes
- # Forward: virtual -> [filenames]
- # Reverse: PN -> [virtuals]
- if pn not in self.pn_provides:
- self.pn_provides[pn] = Set()
- self.pn_provides[pn] |= provides
-
- for provide in provides:
- if provide not in self.providers:
- self.providers[provide] = []
- self.providers[provide].append(file_name)
-
- self.deps[file_name] = Set()
- for dep in depends:
- self.all_depends.add(dep)
- self.deps[file_name].add(dep)
-
- # Build reverse hash for PACKAGES, so runtime dependencies
- # can be be resolved (RDEPENDS, RRECOMMENDS etc.)
- for package in packages:
- if not package in self.packages:
- self.packages[package] = []
- self.packages[package].append(file_name)
- rprovides += (bb_cache.getVar("RPROVIDES_%s" % package, file_name, 1) or "").split()
-
- for package in packages_dynamic:
- if not package in self.packages_dynamic:
- self.packages_dynamic[package] = []
- self.packages_dynamic[package].append(file_name)
-
- for rprovide in rprovides:
- if not rprovide in self.rproviders:
- self.rproviders[rprovide] = []
- self.rproviders[rprovide].append(file_name)
-
- # Build hash of runtime depends and rececommends
-
- def add_dep(deplist, deps):
- for dep in deps:
- if not dep in deplist:
- deplist[dep] = ""
-
- if not file_name in self.rundeps:
- self.rundeps[file_name] = {}
- if not file_name in self.runrecs:
- self.runrecs[file_name] = {}
-
- for package in packages + [pn]:
- if not package in self.rundeps[file_name]:
- self.rundeps[file_name][package] = {}
- if not package in self.runrecs[file_name]:
- self.runrecs[file_name][package] = {}
-
- add_dep(self.rundeps[file_name][package], bb.utils.explode_deps(bb_cache.getVar('RDEPENDS', file_name, True) or ""))
- add_dep(self.runrecs[file_name][package], bb.utils.explode_deps(bb_cache.getVar('RRECOMMENDS', file_name, True) or ""))
- add_dep(self.rundeps[file_name][package], bb.utils.explode_deps(bb_cache.getVar("RDEPENDS_%s" % package, file_name, True) or ""))
- add_dep(self.runrecs[file_name][package], bb.utils.explode_deps(bb_cache.getVar("RRECOMMENDS_%s" % package, file_name, True) or ""))
-
- # Collect files we may need for possible world-dep
- # calculations
- if not bb_cache.getVar('BROKEN', file_name, True) and not bb_cache.getVar('EXCLUDE_FROM_WORLD', file_name, True):
- self.possible_world.append(file_name)
-
+__version__ = "1.7.4"
#============================================================================#
# BBStatistics
Manages one bitbake build run
"""
- ParsingStatus = BBParsingStatus # make it visible from the shell
Statistics = BBStatistics # make it visible from the shell
def __init__( self ):
If build_depends is empty, we're dealing with a runtime depends
"""
- the_data = self.bb_cache.loadDataFull(fn, self)
+ the_data = self.bb_cache.loadDataFull(fn, self.configuration.data)
item = self.status.pkg_fn[fn]
- if bb.build.stamp_is_current('do_%s' % self.configuration.cmd, the_data):
+ if bb.build.stamp_is_current('do_%s' % self.configuration.cmd, the_data) and not self.configuration.force:
self.build_cache.append(fn)
return True
self.cb = None
self.bb_cache = bb.cache.init(self)
try:
- self.configuration.data = self.bb_cache.loadDataFull(self.configuration.buildfile, self)
+ self.configuration.data = self.bb_cache.loadDataFull(self.configuration.buildfile, self.configuration.data)
except IOError, e:
bb.msg.fatal(bb.msg.domain.Parsing, "Unable to read %s: %s" % ( self.configuration.buildfile, e ))
except Exception, e:
except Exception, e:
bb.msg.fatal(bb.msg.domain.Parsing, "%s" % e)
# emit the metadata which isnt valid shell
+ data.expandKeys( self.configuration.data )
for e in self.configuration.data.keys():
if data.getVarFlag( e, 'python', self.configuration.data ):
sys.__stdout__.write("\npython %s () {\n%s}\n" % (e, data.getVar(e, self.configuration.data, 1)))
add_all_depends( pkgs_to_build, [] )
print >> alldepends_file, "}"
- def buildProvider( self, item , buildAllDeps , build_depends = [] ):
- """
- Build something to provide a named build requirement
- (takes item names from DEPENDS namespace)
- """
-
- taskdata = bb.taskdata.TaskData()
-
- try:
- taskdata.add_provider(self.configuration.data, self.status, item)
- except bb.providers.NoProvider:
- return 0
-
- providers = taskdata.get_provider(item)
-
- if len(providers) == 0:
- return 0
-
- for p in providers:
- if p in self.build_cache:
- bb.msg.debug(1, bb.msg.domain.Provider, "already built %s in this run" % p)
- return 1
-
- taskdata.add_unresolved(self.configuration.data, self.status)
-
- tasks = [[item, "do_%s" % self.configuration.cmd]]
- rq = bb.runqueue.RunQueue()
- rq.prepare_runqueue(self.configuration.data, self.status, taskdata, tasks)
- rq.execute_runqueue(self, self.configuration.data, self.status, taskdata, tasks)
-
- #taskdata.dump_data()
- #rq.dump_data(taskdata)
-
- return 1
-
def buildDepgraph( self ):
all_depends = self.status.all_depends
pn_provides = self.status.pn_provides
localdata = data.createCopy(self.configuration.data)
bb.data.update_data(localdata)
+ bb.data.expandKeys(localdata)
def calc_bbfile_priority(filename):
for (regex, pri) in self.status.bbfile_config_priorities:
self.status.possible_world = None
self.status.all_depends = None
- def myProgressCallback( self, x, y, f, bb_cache, from_cache ):
- # feed the status with new input
-
- self.status.handle_bb_data(f, bb_cache, from_cache)
-
+ def myProgressCallback( self, x, y, f, from_cache ):
+ """Update any tty with the progress change"""
if os.isatty(sys.stdout.fileno()):
sys.stdout.write("\rNOTE: Handling BitBake files: %s (%04d/%04d) [%2d %%]" % ( parsespin.next(), x, y, x*100/y ) )
sys.stdout.flush()
bb.msg.fatal(bb.msg.domain.Parsing, "Sorry, shell not available (%s)" % details )
else:
bb.data.update_data( self.configuration.data )
+ bb.data.expandKeys(localdata)
shell.start( self )
sys.exit( 0 )
if self.configuration.buildfile is not None:
bf = os.path.abspath( self.configuration.buildfile )
try:
- bbfile_data = bb.parse.handle(bf, self.configuration.data)
- except IOError:
- bb.msg.fatal(bb.msg.domain.Parsing, "Unable to open %s" % bf)
+ os.stat(bf)
+ except OSError:
+ (filelist, masked) = self.collect_bbfiles()
+ regexp = re.compile(self.configuration.buildfile)
+ matches = []
+ for f in filelist:
+ if regexp.search(f) and os.path.isfile(f):
+ bf = f
+ matches.append(f)
+ if len(matches) != 1:
+ bb.msg.error(bb.msg.domain.Parsing, "Unable to match %s (%s matches found):" % (self.configuration.buildfile, len(matches)))
+ for f in matches:
+ bb.msg.error(bb.msg.domain.Parsing, " %s" % f)
+ sys.exit(1)
+ bf = matches[0]
+
+ bbfile_data = bb.parse.handle(bf, self.configuration.data)
item = bb.data.getVar('PN', bbfile_data, 1)
try:
sys.exit( self.stats.show() )
# initialise the parsing status now we know we will need deps
- self.status = BBParsingStatus()
+ self.status = bb.cache.CacheData()
ignore = bb.data.getVar("ASSUME_PROVIDED", self.configuration.data, 1) or ""
self.status.ignored_dependencies = Set( ignore.split() )
except ImportError:
bb.msg.note(1, bb.msg.domain.Collection, "Psyco JIT Compiler (http://psyco.sf.net) not available. Install it to increase performance.")
else:
- psyco.bind( self.collect_bbfiles )
+ psyco.bind( self.parse_bbfiles )
else:
bb.msg.note(1, bb.msg.domain.Collection, "You have disabled Psyco. This decreases performance.")
try:
bb.msg.debug(1, bb.msg.domain.Collection, "collecting .bb files")
- self.collect_bbfiles( self.myProgressCallback )
+ (filelist, masked) = self.collect_bbfiles()
+ self.parse_bbfiles(filelist, masked, self.myProgressCallback)
bb.msg.debug(1, bb.msg.domain.Collection, "parsing complete")
print
if self.configuration.parse_only:
bb.event.fire(bb.event.BuildStarted(buildname, pkgs_to_build, self.configuration.event_data))
- taskdata = bb.taskdata.TaskData()
+ localdata = data.createCopy(self.configuration.data)
+ bb.data.update_data(localdata)
+ bb.data.expandKeys(localdata)
+
+ taskdata = bb.taskdata.TaskData(self.configuration.abort)
runlist = []
try:
for k in pkgs_to_build:
- taskdata.add_provider(self.configuration.data, self.status, k)
+ taskdata.add_provider(localdata, self.status, k)
runlist.append([k, "do_%s" % self.configuration.cmd])
- taskdata.add_unresolved(self.configuration.data, self.status)
+ taskdata.add_unresolved(localdata, self.status)
except bb.providers.NoProvider:
sys.exit(1)
rq = bb.runqueue.RunQueue()
rq.prepare_runqueue(self.configuration.data, self.status, taskdata, runlist)
- failures = rq.execute_runqueue(self, self.configuration.data, self.status, taskdata, runlist)
-
+ try:
+ failures = rq.execute_runqueue(self, self.configuration.data, self.status, taskdata, runlist)
+ except runqueue.TaskFailure, fnids:
+ for fnid in fnids:
+ bb.msg.error(bb.msg.domain.Build, "'%s' failed" % taskdata.fn_index[fnid])
+ sys.exit(1)
bb.event.fire(bb.event.BuildCompleted(buildname, pkgs_to_build, self.configuration.event_data, failures))
sys.exit( self.stats.show() )
return []
return finddata.readlines()
- def collect_bbfiles( self, progressCallback ):
+ def collect_bbfiles( self ):
"""Collect all available .bb build files"""
- self.cb = progressCallback
parsed, cached, skipped, masked = 0, 0, 0, 0
self.bb_cache = bb.cache.init(self)
continue
newfiles += glob.glob(f) or [ f ]
- bbmask = bb.data.getVar('BBMASK', self.configuration.data, 1) or ""
+ bbmask = bb.data.getVar('BBMASK', self.configuration.data, 1)
+
+ if not bbmask:
+ return (newfiles, 0)
+
try:
bbmask_compiled = re.compile(bbmask)
except sre_constants.error:
bb.msg.fatal(bb.msg.domain.Collection, "BBMASK is not a valid regular expression.")
+ finalfiles = []
for i in xrange( len( newfiles ) ):
f = newfiles[i]
if bbmask and bbmask_compiled.search(f):
- bb.msg.debug(1, bb.msg.domain.Collection, "bbmake: skipping %s" % f, f)
+ bb.msg.debug(1, bb.msg.domain.Collection, "skipping masked file %s" % f)
masked += 1
continue
- bb.msg.debug(1, bb.msg.domain.Collection, "bbmake: parsing %s" % f, f)
+ finalfiles.append(f)
+
+ return (finalfiles, masked)
+
+ def parse_bbfiles(self, filelist, masked, progressCallback = None):
+ parsed, cached, skipped = 0, 0, 0
+ for i in xrange( len( filelist ) ):
+ f = filelist[i]
+
+ bb.msg.debug(1, bb.msg.domain.Collection, "parsing %s" % f)
# read a file's metadata
try:
- fromCache, skip = self.bb_cache.loadData(f, self)
+ fromCache, skip = self.bb_cache.loadData(f, self.configuration.data)
if skip:
skipped += 1
- bb.msg.debug(2, bb.msg.domain.Collection, "Skipping %s" % f, f)
+ bb.msg.debug(2, bb.msg.domain.Collection, "skipping %s" % f)
self.bb_cache.skip(f)
continue
elif fromCache: cached += 1
else: parsed += 1
deps = None
+ # Disabled by RP as was no longer functional
# allow metadata files to add items to BBFILES
#data.update_data(self.pkgdata[f])
- addbbfiles = self.bb_cache.getVar('BBFILES', f, False) or None
- if addbbfiles:
- for aof in addbbfiles.split():
- if not files.count(aof):
- if not os.path.isabs(aof):
- aof = os.path.join(os.path.dirname(f),aof)
- files.append(aof)
+ #addbbfiles = self.bb_cache.getVar('BBFILES', f, False) or None
+ #if addbbfiles:
+ # for aof in addbbfiles.split():
+ # if not files.count(aof):
+ # if not os.path.isabs(aof):
+ # aof = os.path.join(os.path.dirname(f),aof)
+ # files.append(aof)
+
+ self.bb_cache.handle_data(f, self.status)
# now inform the caller
- if self.cb is not None:
- self.cb( i + 1, len( newfiles ), f, self.bb_cache, fromCache )
+ if progressCallback is not None:
+ progressCallback( i + 1, len( filelist ), f, fromCache )
except IOError, e:
self.bb_cache.remove(f)
- bb.msg.error(bb.msg.domain.Collection, "opening %s: %s" % (f, e), f)
+ bb.msg.error(bb.msg.domain.Collection, "opening %s: %s" % (f, e))
pass
except KeyboardInterrupt:
self.bb_cache.sync()
raise
except Exception, e:
self.bb_cache.remove(f)
- bb.msg.error(bb.msg.domain.Collection, "%s while parsing %s" % (e, f), f)
+ bb.msg.error(bb.msg.domain.Collection, "%s while parsing %s" % (e, f))
except:
self.bb_cache.remove(f)
raise
- if self.cb is not None:
+ if progressCallback is not None:
print "\r" # need newline after Handling Bitbake files message
bb.msg.note(1, bb.msg.domain.Collection, "Parsing finished. %d cached, %d parsed, %d skipped, %d masked." % ( cached, parsed, skipped, masked ))