# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
import sys, os, getopt, re, time, optparse, xmlrpclib
-sys.path.insert(0,os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])),
+ 'lib'))
import warnings
import bb
print "Sorry, python 2.6 or later is required for this version of bitbake"
sys.exit(1)
+
#============================================================================#
# BBOptions
#============================================================================#
-class BBConfiguration( object ):
+class BBConfiguration(object):
"""
Manages build options and configurations for one run
"""
- def __init__( self, options ):
+
+ def __init__(self, options):
for key, val in options.__dict__.items():
- setattr( self, key, val )
+ setattr(self, key, val)
self.pkgs_to_build = []
print "Sorry, bitbake needs python 2.5 or later."
sys.exit(1)
- parser = optparse.OptionParser( version = "BitBake Build Tool Core version %s, %%prog version %s" % ( bb.__version__, __version__ ),
- usage = """%prog [options] [package ...]
+ parser = optparse.OptionParser(
+ version = "BitBake Build Tool Core version %s, %%prog version %s" % (bb.__version__, __version__),
+ usage = """%prog [options] [package ...]
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.""" )
+Default BBFILES are the .bb files in the current directory.""")
- parser.add_option( "-b", "--buildfile", help = "execute the task against this .bb file, rather than a package from BBFILES.",
- action = "store", dest = "buildfile", default = None )
+ parser.add_option("-b", "--buildfile", help = "execute the task against this .bb file, rather than a package from BBFILES.",
+ 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 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("-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("-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("-f", "--force", help = "force run of specified cmd, regardless of stamp status",
+ action = "store_true", dest = "force", default = False)
- parser.add_option( "-i", "--interactive", help = "drop into the interactive mode also called the BitBake shell.",
- action = "store_true", dest = "interactive", default = False )
+ parser.add_option("-i", "--interactive", help = "drop into the interactive mode also called the BitBake shell.",
+ action = "store_true", dest = "interactive", 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", "--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( "-r", "--read", help = "read the specified file before bitbake.conf",
- action = "append", dest = "file", default = [] )
+ parser.add_option("-r", "--read", help = "read the specified file before bitbake.conf",
+ action = "append", dest = "file", default = [])
- parser.add_option( "-v", "--verbose", help = "output more chit-chat to the terminal",
- action = "store_true", dest = "verbose", default = False )
+ 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.",
+ 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("-n", "--dry-run", help = "don't execute, just go through the motions",
+ action = "store_true", dest = "dry_run", 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("-p", "--parse-only", help = "quit after parsing the BB files (developers only)",
+ action = "store_true", dest = "parse_only", default = False)
- parser.add_option( "-d", "--disable-psyco", help = "disable using the psyco just-in-time compiler (not recommended)",
- action = "store_true", dest = "disable_psyco", default = False )
+ parser.add_option("-d", "--disable-psyco", help = "disable using the psyco just-in-time compiler (not recommended)",
+ action = "store_true", dest = "disable_psyco", default = False)
- parser.add_option( "-s", "--show-versions", help = "show current and preferred versions of all packages",
- action = "store_true", dest = "show_versions", default = False )
+ parser.add_option("-s", "--show-versions", help = "show current and preferred versions of all packages",
+ 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("-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",
- action = "store_true", dest = "dot_graph", default = False )
+ parser.add_option("-g", "--graphviz", help = "emit the dependency trees of the specified packages 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("-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("-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("-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",
+ parser.add_option("-u", "--ui", help = "userinterface to use",
action = "store", dest = "ui")
- 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("", "--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)
options, args = parser.parse_args(sys.argv)
# Save a logfile for cooker into the current working directory. When the
# server is daemonized this logfile will be truncated.
- cooker_logfile = os.path.join (os.getcwd(), "cooker.log")
+ cooker_logfile = os.path.join(os.getcwd(), "cooker.log")
bb.utils.init_logger(bb.msg, configuration.verbose, configuration.debug,
configuration.debug_domains)
# Dynamically load the UI based on the ui name. Although we
# suggest a fixed set this allows you to have flexibility in which
# ones are available.
- uimodule = __import__("bb.ui", fromlist=[ui])
+ uimodule = __import__("bb.ui", fromlist = [ui])
return_value = getattr(uimodule, ui).init(serverConnection.connection, serverConnection.events)
except AttributeError:
print "FATAL: Invalid user interface '%s' specified. " % ui
#
# This is a copy on write dictionary and set which abuses classes to try and be nice and fast.
#
-# Copyright (C) 2006 Tim Amsell
+# Copyright (C) 2006 Tim Amsell
#
# 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
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
-#Please Note:
+#Please Note:
# Be careful when using mutable types (ie Dict and Lists) - operations involving these are SLOW.
# Assign a file to __warn__ to get warnings about slow operations.
#
class COWMeta(type):
pass
-
+
class COWDictMeta(COWMeta):
__warn__ = False
__hasmutable__ = False
cls.__hasmutable__ = True
key += MUTABLE
setattr(cls, key, value)
-
+
def __getmutable__(cls, key, readonly=False):
nkey = key + MUTABLE
try:
value = getattr(cls, key)
except AttributeError:
value = cls.__getmutable__(key, readonly)
-
- # This is for values which have been deleted
+
+ # This is for values which have been deleted
if value is cls.__marker__:
raise AttributeError("key %s does not exist." % key)
def iter(cls, type, readonly=False):
for key in dir(cls):
if key.startswith("__"):
- continue
+ continue
if key.endswith(MUTABLE):
key = key[:-len(MUTABLE)]
def remove(cls, value):
COWDictMeta.__delitem__(cls, repr(hash(value)))
-
+
def __in__(cls, value):
return COWDictMeta.has_key(repr(hash(value)))
def iterkeys(cls):
raise TypeError("sets don't have keys")
-
+
def iteritems(cls):
raise TypeError("sets don't have 'items'")
print "Boo!"
else:
print "Yay - has_key with delete works!"
-
+
print "a", a
for x in a.iteritems():
print x
from bb import data, event, mkdirhier, utils
import bb, os, sys
-# When we execute a python function we'd like certain things
+# When we execute a python function we'd like certain things
# in all namespaces, hence we add them to __builtins__
# If we do not do this and use the exec globals, they will
# not be available to subfunctions.
try:
utils.better_exec(comp, {"d": d}, tmp, bbfile)
except:
- (t,value,tb) = sys.exc_info()
+ (t, value, tb) = sys.exc_info()
if t in [bb.parse.SkipPackage, bb.build.FuncFailed]:
raise
def extract_stamp(d, fn):
"""
- Extracts stamp format which is either a data dictonary (fn unset)
- or a dataCache entry (fn set).
+ Extracts stamp format which is either a data dictonary (fn unset)
+ or a dataCache entry (fn set).
"""
if fn:
return d.stamp[fn]
if not task in task_deps['tasks']:
task_deps['tasks'].append(task)
- flags = data.getVarFlags(task, d)
+ flags = data.getVarFlags(task, d)
def getTask(name):
if not name in task_deps:
task_deps[name] = {}
If kill is 1, also remove tasks that depend on this task."""
data.delVarFlag(task, 'task', d)
-
# cache there isn't even any point in loading it...
newest_mtime = 0
deps = bb.data.getVar("__depends", data, True)
- for f,old_mtime in deps:
+ for f, old_mtime in deps:
if old_mtime > newest_mtime:
newest_mtime = old_mtime
"""
Gets the value of a variable
(similar to getVar in the data class)
-
+
There are two scenarios:
1. We have cached data - serve from depends_cache[fn]
- 2. We're learning what data to cache - serve from data
+ 2. We're learning what data to cache - serve from data
backend but add a copy of the data to the cache.
"""
if fn in self.clean:
self.data = data
# Make sure __depends makes the depends_cache
- # If we're a virtual class we need to make sure all our depends are appended
+ # If we're a virtual class we need to make sure all our depends are appended
# to the depends of fn.
depends = self.getVar("__depends", virtualfn, True) or []
self.depends_cache.setdefault(fn, {})
self.remove(fn)
return False
- mtime = bb.parse.cached_mtime_noerror(fn)
+ mtime = bb.parse.cached_mtime_noerror(fn)
# Check file still exists
if mtime == 0:
# Check dependencies are still valid
depends = self.getVar("__depends", fn, True)
if depends:
- for f,old_mtime in depends:
+ for f, old_mtime in depends:
fmtime = bb.parse.cached_mtime_noerror(f)
# Check if file still exists
if old_mtime != 0 and fmtime == 0:
def handle_data(self, file_name, cacheData):
"""
- Save data we need into the cache
+ Save data we need into the cache
"""
pn = self.getVar('PN', file_name, True)
# build FileName to PackageName lookup table
cacheData.pkg_fn[file_name] = pn
- cacheData.pkg_pepvpr[file_name] = (pe,pv,pr)
+ cacheData.pkg_pepvpr[file_name] = (pe, pv, pr)
cacheData.pkg_dp[file_name] = dp
provides = [pn]
if not dep in cacheData.all_depends:
cacheData.all_depends.append(dep)
- # Build reverse hash for PACKAGES, so runtime dependencies
+ # Build reverse hash for PACKAGES, so runtime dependencies
# can be be resolved (RDEPENDS, RRECOMMENDS etc.)
for package in packages:
if not package in cacheData.packages:
cacheData.packages[package] = []
cacheData.packages[package].append(file_name)
- rprovides += (self.getVar("RPROVIDES_%s" % package, file_name, 1) or "").split()
+ rprovides += (self.getVar("RPROVIDES_%s" % package, file_name, 1) or "").split()
for package in packages_dynamic:
if not package in cacheData.packages_dynamic:
def init(cooker):
"""
- The Objective: Cache the minimum amount of data possible yet get to the
+ The Objective: Cache the minimum amount of data possible yet get to the
stage of building packages (i.e. tryBuild) without reparsing any .bb files.
- To do this, we intercept getVar calls and only cache the variables we see
- being accessed. We rely on the cache getVar calls being made for all
- variables bitbake might need to use to reach this stage. For each cached
+ To do this, we intercept getVar calls and only cache the variables we see
+ being accessed. We rely on the cache getVar calls being made for all
+ variables bitbake might need to use to reach this stage. For each cached
file we need to track:
* Its mtime
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
"""
-The bitbake server takes 'commands' from its UI/commandline.
+The bitbake server takes 'commands' from its UI/commandline.
Commands are either synchronous or asynchronous.
Async commands return data to the client in the form of events.
Sync commands must only return data through the function return value
try:
command = commandline.pop(0)
if command in CommandsSync.__dict__:
- # Can run synchronous commands straight away
+ # Can run synchronous commands straight away
return getattr(CommandsSync, command)(self.cmds_sync, self, commandline)
if self.currentAsyncCommand is not None:
return "Busy (%s in progress)" % self.currentAsyncCommand[0]
def __init__(self, exitcode):
bb.event.Event.__init__(self)
self.exitcode = int(exitcode)
-
-
-
def tryBuild(self, fn, task):
"""
- Build a provider and its dependencies.
+ Build a provider and its dependencies.
build_depends is a list of previous build dependencies (not runtime)
If build_depends is empty, we're dealing with a runtime depends
"""
# Sort by priority
for pn in pkg_pn:
- (last_ver,last_file,pref_ver,pref_file) = bb.providers.findBestProvider(pn, self.configuration.data, self.status)
+ (last_ver, last_file, pref_ver, pref_file) = bb.providers.findBestProvider(pn, self.configuration.data, self.status)
preferred_versions[pn] = (pref_ver, pref_file)
latest_versions[pn] = (last_ver, last_file)
rq = bb.runqueue.RunQueue(self, self.configuration.data, self.status, taskdata, runlist)
rq.prepare_runqueue()
- seen_fnids = []
+ seen_fnids = []
depend_tree = {}
depend_tree["depends"] = {}
depend_tree["tdepends"] = {}
depend_tree["rdepends-pn"][pn] = []
for rdep in taskdata.rdepids[fnid]:
- depend_tree["rdepends-pn"][pn].append(taskdata.run_names_index[rdep])
+ depend_tree["rdepends-pn"][pn].append(taskdata.run_names_index[rdep])
rdepends = self.status.rundeps[fn]
for package in rdepends:
# 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', self.configuration.data) or []:
- bb.event.register(var,bb.data.getVar(var, self.configuration.data))
+ bb.event.register(var, bb.data.getVar(var, self.configuration.data))
bb.fetch.fetcher_init(self.configuration.data)
"""
if not bb.data.getVar("BUILDNAME", self.configuration.data):
bb.data.setVar("BUILDNAME", os.popen('date +%Y%m%d%H%M').readline().strip(), self.configuration.data)
- bb.data.setVar("BUILDSTART", time.strftime('%m/%d/%Y %H:%M:%S',time.gmtime()), self.configuration.data)
+ bb.data.setVar("BUILDSTART", time.strftime('%m/%d/%Y %H:%M:%S', time.gmtime()), self.configuration.data)
def matchFiles(self, buildfile):
"""
ignore = bb.data.getVar("ASSUME_PROVIDED", self.configuration.data, 1) or ""
self.status.ignored_dependencies = set(ignore.split())
-
+
for dep in self.configuration.extra_assume_provided:
self.status.ignored_dependencies.add(dep)
-
+
self.handleCollections( bb.data.getVar("BBFILE_COLLECTIONS", self.configuration.data, 1) )
bb.msg.debug(1, bb.msg.domain.Collection, "collecting .bb files")
for f in contents:
(root, ext) = os.path.splitext(f)
if ext == ".bb":
- bbfiles.append(os.path.abspath(os.path.join(os.getcwd(),f)))
+ bbfiles.append(os.path.abspath(os.path.join(os.getcwd(), f)))
return bbfiles
def find_bbfiles( self, path ):
for ignored in ('SCCS', 'CVS', '.svn'):
if ignored in dirs:
dirs.remove(ignored)
- found += [join(dir,f) for f in files if f.endswith('.bb')]
+ found += [join(dir, f) for f in files if f.endswith('.bb')]
return found
pout.close()
else:
self.server.serve_forever()
-
+
bb.event.fire(CookerExit(), self.configuration.event_data)
-
+
class CookerExit(bb.event.Event):
"""
Notify clients of the Cooker shutdown
raise ParsingErrorsFound
return False
return True
-
\r
Configurable daemon behaviors:\r
\r
- 1.) The current working directory set to the "/" directory.\r
- 2.) The current file creation mode mask set to 0.\r
- 3.) Close all open files (1024). \r
- 4.) Redirect standard I/O streams to "/dev/null".\r
+ 1.) The current working directory set to the "/" directory.\r
+ 2.) The current file creation mode mask set to 0.\r
+ 3.) Close all open files (1024). \r
+ 4.) Redirect standard I/O streams to "/dev/null".\r
\r
A failed call to fork() now raises an exception.\r
\r
References:\r
- 1) Advanced Programming in the Unix Environment: W. Richard Stevens\r
- 2) Unix Programming Frequently Asked Questions:\r
- http://www.erlenstar.demon.co.uk/unix/faq_toc.html\r
+ 1) Advanced Programming in the Unix Environment: W. Richard Stevens\r
+ 2) Unix Programming Frequently Asked Questions:\r
+ http://www.erlenstar.demon.co.uk/unix/faq_toc.html\r
\r
Modified to allow a function to be daemonized and return for \r
bitbake use by Richard Purdie\r
__version__ = "0.2"\r
\r
# Standard Python modules.\r
-import os # Miscellaneous OS interfaces.\r
-import sys # System-specific parameters and functions.\r
+import os # Miscellaneous OS interfaces.\r
+import sys # System-specific parameters and functions.\r
\r
# Default daemon parameters.\r
# File mode creation mask of the daemon.\r
\r
# The standard I/O file descriptors are redirected to /dev/null by default.\r
if (hasattr(os, "devnull")):\r
- REDIRECT_TO = os.devnull\r
+ REDIRECT_TO = os.devnull\r
else:\r
- REDIRECT_TO = "/dev/null"\r
+ REDIRECT_TO = "/dev/null"\r
\r
def createDaemon(function, logfile):\r
- """\r
- Detach a process from the controlling terminal and run it in the\r
- background as a daemon, returning control to the caller.\r
- """\r
-\r
- try:\r
- # Fork a child process so the parent can exit. This returns control to\r
- # the command-line or shell. It also guarantees that the child will not\r
- # be a process group leader, since the child receives a new process ID\r
- # and inherits the parent's process group ID. This step is required\r
- # to insure that the next call to os.setsid is successful.\r
- pid = os.fork()\r
- except OSError, e:\r
- raise Exception, "%s [%d]" % (e.strerror, e.errno)\r
-\r
- if (pid == 0): # The first child.\r
- # To become the session leader of this new session and the process group\r
- # leader of the new process group, we call os.setsid(). The process is\r
- # also guaranteed not to have a controlling terminal.\r
- os.setsid()\r
-\r
- # Is ignoring SIGHUP necessary?\r
- #\r
- # It's often suggested that the SIGHUP signal should be ignored before\r
- # the second fork to avoid premature termination of the process. The\r
- # reason is that when the first child terminates, all processes, e.g.\r
- # the second child, in the orphaned group will be sent a SIGHUP.\r
- #\r
- # "However, as part of the session management system, there are exactly\r
- # two cases where SIGHUP is sent on the death of a process:\r
- #\r
- # 1) When the process that dies is the session leader of a session that\r
- # is attached to a terminal device, SIGHUP is sent to all processes\r
- # in the foreground process group of that terminal device.\r
- # 2) When the death of a process causes a process group to become\r
- # orphaned, and one or more processes in the orphaned group are\r
- # stopped, then SIGHUP and SIGCONT are sent to all members of the\r
- # orphaned group." [2]\r
- #\r
- # The first case can be ignored since the child is guaranteed not to have\r
- # a controlling terminal. The second case isn't so easy to dismiss.\r
- # The process group is orphaned when the first child terminates and\r
- # POSIX.1 requires that every STOPPED process in an orphaned process\r
- # group be sent a SIGHUP signal followed by a SIGCONT signal. Since the\r
- # second child is not STOPPED though, we can safely forego ignoring the\r
- # SIGHUP signal. In any case, there are no ill-effects if it is ignored.\r
- #\r
- # import signal # Set handlers for asynchronous events.\r
- # signal.signal(signal.SIGHUP, signal.SIG_IGN)\r
-\r
- try:\r
- # Fork a second child and exit immediately to prevent zombies. This\r
- # causes the second child process to be orphaned, making the init\r
- # process responsible for its cleanup. And, since the first child is\r
- # a session leader without a controlling terminal, it's possible for\r
- # it to acquire one by opening a terminal in the future (System V-\r
- # based systems). This second fork guarantees that the child is no\r
- # longer a session leader, preventing the daemon from ever acquiring\r
- # a controlling terminal.\r
- pid = os.fork() # Fork a second child.\r
- except OSError, e:\r
- raise Exception, "%s [%d]" % (e.strerror, e.errno)\r
-\r
- if (pid == 0): # The second child.\r
- # We probably don't want the file mode creation mask inherited from\r
- # the parent, so we give the child complete control over permissions.\r
- if UMASK is not None:\r
- os.umask(UMASK)\r
- else:\r
- # Parent (the first child) of the second child.\r
- os._exit(0)\r
- else:\r
- # exit() or _exit()?\r
- # _exit is like exit(), but it doesn't call any functions registered\r
- # with atexit (and on_exit) or any registered signal handlers. It also\r
- # closes any open file descriptors. Using exit() may cause all stdio\r
- # streams to be flushed twice and any temporary files may be unexpectedly\r
- # removed. It's therefore recommended that child branches of a fork()\r
- # and the parent branch(es) of a daemon use _exit().\r
- return\r
-\r
- # Close all open file descriptors. This prevents the child from keeping\r
- # open any file descriptors inherited from the parent. There is a variety\r
- # of methods to accomplish this task. Three are listed below.\r
- #\r
- # Try the system configuration variable, SC_OPEN_MAX, to obtain the maximum\r
- # number of open file descriptors to close. If it doesn't exists, use\r
- # the default value (configurable).\r
- #\r
- # try:\r
- # maxfd = os.sysconf("SC_OPEN_MAX")\r
- # except (AttributeError, ValueError):\r
- # maxfd = MAXFD\r
- #\r
- # OR\r
- #\r
- # if (os.sysconf_names.has_key("SC_OPEN_MAX")):\r
- # maxfd = os.sysconf("SC_OPEN_MAX")\r
- # else:\r
- # maxfd = MAXFD\r
- #\r
- # OR\r
- #\r
- # Use the getrlimit method to retrieve the maximum file descriptor number\r
- # that can be opened by this process. If there is not limit on the\r
- # resource, use the default value.\r
- #\r
- import resource # Resource usage information.\r
- maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1]\r
- if (maxfd == resource.RLIM_INFINITY):\r
- maxfd = MAXFD\r
+ """\r
+ Detach a process from the controlling terminal and run it in the\r
+ background as a daemon, returning control to the caller.\r
+ """\r
+\r
+ try:\r
+ # Fork a child process so the parent can exit. This returns control to\r
+ # the command-line or shell. It also guarantees that the child will not\r
+ # be a process group leader, since the child receives a new process ID\r
+ # and inherits the parent's process group ID. This step is required\r
+ # to insure that the next call to os.setsid is successful.\r
+ pid = os.fork()\r
+ except OSError, e:\r
+ raise Exception, "%s [%d]" % (e.strerror, e.errno)\r
+\r
+ if (pid == 0): # The first child.\r
+ # To become the session leader of this new session and the process group\r
+ # leader of the new process group, we call os.setsid(). The process is\r
+ # also guaranteed not to have a controlling terminal.\r
+ os.setsid()\r
+\r
+ # Is ignoring SIGHUP necessary?\r
+ #\r
+ # It's often suggested that the SIGHUP signal should be ignored before\r
+ # the second fork to avoid premature termination of the process. The\r
+ # reason is that when the first child terminates, all processes, e.g.\r
+ # the second child, in the orphaned group will be sent a SIGHUP.\r
+ #\r
+ # "However, as part of the session management system, there are exactly\r
+ # two cases where SIGHUP is sent on the death of a process:\r
+ #\r
+ # 1) When the process that dies is the session leader of a session that\r
+ # is attached to a terminal device, SIGHUP is sent to all processes\r
+ # in the foreground process group of that terminal device.\r
+ # 2) When the death of a process causes a process group to become\r
+ # orphaned, and one or more processes in the orphaned group are\r
+ # stopped, then SIGHUP and SIGCONT are sent to all members of the\r
+ # orphaned group." [2]\r
+ #\r
+ # The first case can be ignored since the child is guaranteed not to have\r
+ # a controlling terminal. The second case isn't so easy to dismiss.\r
+ # The process group is orphaned when the first child terminates and\r
+ # POSIX.1 requires that every STOPPED process in an orphaned process\r
+ # group be sent a SIGHUP signal followed by a SIGCONT signal. Since the\r
+ # second child is not STOPPED though, we can safely forego ignoring the\r
+ # SIGHUP signal. In any case, there are no ill-effects if it is ignored.\r
+ #\r
+ # import signal # Set handlers for asynchronous events.\r
+ # signal.signal(signal.SIGHUP, signal.SIG_IGN)\r
+\r
+ try:\r
+ # Fork a second child and exit immediately to prevent zombies. This\r
+ # causes the second child process to be orphaned, making the init\r
+ # process responsible for its cleanup. And, since the first child is\r
+ # a session leader without a controlling terminal, it's possible for\r
+ # it to acquire one by opening a terminal in the future (System V-\r
+ # based systems). This second fork guarantees that the child is no\r
+ # longer a session leader, preventing the daemon from ever acquiring\r
+ # a controlling terminal.\r
+ pid = os.fork() # Fork a second child.\r
+ except OSError, e:\r
+ raise Exception, "%s [%d]" % (e.strerror, e.errno)\r
+\r
+ if (pid == 0): # The second child.\r
+ # We probably don't want the file mode creation mask inherited from\r
+ # the parent, so we give the child complete control over permissions.\r
+ if UMASK is not None:\r
+ os.umask(UMASK)\r
+ else:\r
+ # Parent (the first child) of the second child.\r
+ os._exit(0)\r
+ else:\r
+ # exit() or _exit()?\r
+ # _exit is like exit(), but it doesn't call any functions registered\r
+ # with atexit (and on_exit) or any registered signal handlers. It also\r
+ # closes any open file descriptors. Using exit() may cause all stdio\r
+ # streams to be flushed twice and any temporary files may be unexpectedly\r
+ # removed. It's therefore recommended that child branches of a fork()\r
+ # and the parent branch(es) of a daemon use _exit().\r
+ return\r
+\r
+ # Close all open file descriptors. This prevents the child from keeping\r
+ # open any file descriptors inherited from the parent. There is a variety\r
+ # of methods to accomplish this task. Three are listed below.\r
+ #\r
+ # Try the system configuration variable, SC_OPEN_MAX, to obtain the maximum\r
+ # number of open file descriptors to close. If it doesn't exists, use\r
+ # the default value (configurable).\r
+ #\r
+ # try:\r
+ # maxfd = os.sysconf("SC_OPEN_MAX")\r
+ # except (AttributeError, ValueError):\r
+ # maxfd = MAXFD\r
+ #\r
+ # OR\r
+ #\r
+ # if (os.sysconf_names.has_key("SC_OPEN_MAX")):\r
+ # maxfd = os.sysconf("SC_OPEN_MAX")\r
+ # else:\r
+ # maxfd = MAXFD\r
+ #\r
+ # OR\r
+ #\r
+ # Use the getrlimit method to retrieve the maximum file descriptor number\r
+ # that can be opened by this process. If there is not limit on the\r
+ # resource, use the default value.\r
+ #\r
+ import resource # Resource usage information.\r
+ maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1]\r
+ if (maxfd == resource.RLIM_INFINITY):\r
+ maxfd = MAXFD\r
\r
- # Iterate through and close all file descriptors.\r
-# for fd in range(0, maxfd):\r
-# try:\r
-# os.close(fd)\r
-# except OSError: # ERROR, fd wasn't open to begin with (ignored)\r
-# pass\r
+ # Iterate through and close all file descriptors.\r
+# for fd in range(0, maxfd):\r
+# try:\r
+# os.close(fd)\r
+# except OSError: # ERROR, fd wasn't open to begin with (ignored)\r
+# pass\r
\r
- # Redirect the standard I/O file descriptors to the specified file. Since\r
- # the daemon has no controlling terminal, most daemons redirect stdin,\r
- # stdout, and stderr to /dev/null. This is done to prevent side-effects\r
- # from reads and writes to the standard I/O file descriptors.\r
+ # Redirect the standard I/O file descriptors to the specified file. Since\r
+ # the daemon has no controlling terminal, most daemons redirect stdin,\r
+ # stdout, and stderr to /dev/null. This is done to prevent side-effects\r
+ # from reads and writes to the standard I/O file descriptors.\r
\r
- # This call to open is guaranteed to return the lowest file descriptor,\r
- # which will be 0 (stdin), since it was closed above.\r
-# os.open(REDIRECT_TO, os.O_RDWR) # standard input (0)\r
+ # This call to open is guaranteed to return the lowest file descriptor,\r
+ # which will be 0 (stdin), since it was closed above.\r
+# os.open(REDIRECT_TO, os.O_RDWR) # standard input (0)\r
\r
- # Duplicate standard input to standard output and standard error.\r
-# os.dup2(0, 1) # standard output (1)\r
-# os.dup2(0, 2) # standard error (2)\r
+ # Duplicate standard input to standard output and standard error.\r
+# os.dup2(0, 1) # standard output (1)\r
+# os.dup2(0, 2) # standard error (2)\r
\r
\r
- si = file('/dev/null', 'r')\r
- so = file(logfile, 'w')\r
- se = so\r
+ si = file('/dev/null', 'r')\r
+ so = file(logfile, 'w')\r
+ se = so\r
\r
\r
- # Replace those fds with our own\r
- os.dup2(si.fileno(), sys.stdin.fileno())\r
- os.dup2(so.fileno(), sys.stdout.fileno())\r
- os.dup2(se.fileno(), sys.stderr.fileno())\r
+ # Replace those fds with our own\r
+ os.dup2(si.fileno(), sys.stdin.fileno())\r
+ os.dup2(so.fileno(), sys.stdout.fileno())\r
+ os.dup2(se.fileno(), sys.stderr.fileno())\r
\r
- function()\r
-\r
- os._exit(0)\r
+ function()\r
\r
+ os._exit(0)\r
suggested 'give me cookies on setting the variables and
things will work out'. Taking this suggestion into account
applying the skills from the not yet passed 'Entwurf und
-Analyse von Algorithmen' lecture and the cookie
+Analyse von Algorithmen' lecture and the cookie
monster seems to be right. We will track setVar more carefully
to have faster update_data and expandKeys operations.
path = os.path.dirname(os.path.dirname(sys.argv[1]))
else:
path = os.path.dirname(os.path.dirname(sys.argv[0]))
-sys.path.insert(0,path)
+sys.path.insert(0, path)
from bb import data_smart
import bb
return _dict_type()
def createCopy(source):
- """Link the source set to the destination
- If one does not find the value in the destination set,
- search will go on to the source set to get the value.
- Value from source are copy-on-write. i.e. any try to
- modify one of them will end up putting the modified value
- in the destination set.
- """
- return source.createCopy()
+ """Link the source set to the destination
+ If one does not find the value in the destination set,
+ search will go on to the source set to get the value.
+ Value from source are copy-on-write. i.e. any try to
+ modify one of them will end up putting the modified value
+ in the destination set.
+ """
+ return source.createCopy()
def initVar(var, d):
"""Non-destructive var init for data structure"""
def setVar(var, value, d):
"""Set a variable to a given value"""
- d.setVar(var,value)
+ d.setVar(var, value)
def getVar(var, d, exp = 0):
"""Gets the value of a variable"""
- return d.getVar(var,exp)
+ return d.getVar(var, exp)
def renameVar(key, newkey, d):
def setVarFlag(var, flag, flagvalue, d):
"""Set a flag for a given variable to a given value"""
- d.setVarFlag(var,flag,flagvalue)
+ d.setVarFlag(var, flag, flagvalue)
def getVarFlag(var, flag, d):
"""Gets given flag from given var"""
- return d.getVarFlag(var,flag)
+ return d.getVarFlag(var, flag)
def delVarFlag(var, flag, d):
"""Removes a given flag from the variable's flags"""
- d.delVarFlag(var,flag)
+ d.delVarFlag(var, flag)
def setVarFlags(var, flags, d):
"""Set the flags for a given variable
flags. Think of this method as
addVarFlags
"""
- d.setVarFlags(var,flags)
+ d.setVarFlags(var, flags)
def getVarFlags(var, d):
"""Gets a variable's flags"""
continue
todolist[key] = ekey
- # These two for loops are split for performance to maximise the
+ # These two for loops are split for performance to maximise the
# usefulness of the expand cache
for key in todolist:
o.write('%s="%s"\n' % (varExpanded, alter))
return 1
-
def emit_env(o=sys.__stdout__, d = init(), all=False):
"""Emits all items in the data store in a format such that it can be sourced by a shell."""
import copy, os, re, sys, time, types
import bb
from bb import utils, methodpool
-from COW import COWDictBase
+from bb.COW import COWDictBase
from new import classobj
-__setvar_keyword__ = ["_append","_prepend"]
+__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"\${@.+?}")
self.expand_cache = {}
- def expand(self,s, varname):
+ def expand(self, s, varname):
def var_sub(match):
key = match.group()[2:-1]
if varname and key:
if not var in self.dict:
self.dict[var] = {}
- def _findVar(self,var):
+ def _findVar(self, var):
_dest = self.dict
while (_dest and var not in _dest):
else:
self.initVar(var)
- def setVar(self,var,value):
+ def setVar(self, var, value):
self.expand_cache = {}
match = __setvar_regexp__.match(var)
if match and match.group("keyword") in __setvar_keyword__:
# setting var
self.dict[var]["content"] = value
- def getVar(self,var,exp):
- value = self.getVarFlag(var,"content")
+ def getVar(self, var, exp):
+ value = self.getVarFlag(var, "content")
if exp and value:
- return self.expand(value,var)
+ return self.expand(value, var)
return value
def renameVar(self, key, newkey):
"""
- Rename the variable key to newkey
+ Rename the variable key to newkey
"""
val = self.getVar(key, 0)
if val is not None:
dest = self.getVarFlag(newkey, i) or []
dest.extend(src)
self.setVarFlag(newkey, i, dest)
-
+
if self._special_values.has_key(i) and key in self._special_values[i]:
self._special_values[i].remove(key)
self._special_values[i].add(newkey)
self.delVar(key)
- def delVar(self,var):
+ def delVar(self, var):
self.expand_cache = {}
self.dict[var] = {}
- def setVarFlag(self,var,flag,flagvalue):
+ def setVarFlag(self, var, flag, flagvalue):
if not var in self.dict:
self._makeShadowCopy(var)
self.dict[var][flag] = flagvalue
- def getVarFlag(self,var,flag):
+ def getVarFlag(self, var, flag):
local_var = self._findVar(var)
if local_var:
if flag in local_var:
return copy.copy(local_var[flag])
return None
- def delVarFlag(self,var,flag):
+ def delVarFlag(self, var, flag):
local_var = self._findVar(var)
if not local_var:
return
if var in self.dict and flag in self.dict[var]:
del self.dict[var][flag]
- def setVarFlags(self,var,flags):
+ def setVarFlags(self, var, flags):
if not var in self.dict:
self._makeShadowCopy(var)
continue
self.dict[var][i] = flags[i]
- def getVarFlags(self,var):
+ def getVarFlags(self, var):
local_var = self._findVar(var)
flags = {}
return flags
- def delVarFlags(self,var):
+ def delVarFlags(self, var):
if not var in self.dict:
self._makeShadowCopy(var)
def keys(self):
def _keys(d, mykey):
if "_data" in d:
- _keys(d["_data"],mykey)
+ _keys(d["_data"], mykey)
for key in d.keys():
if key != "_data":
mykey[key] = None
keytab = {}
- _keys(self.dict,keytab)
+ _keys(self.dict, keytab)
return keytab.keys()
- def __getitem__(self,item):
+ def __getitem__(self, item):
#print "Warning deprecated"
return self.getVar(item, False)
- def __setitem__(self,var,data):
+ def __setitem__(self, var, data):
#print "Warning deprecated"
- self.setVar(var,data)
-
-
+ self.setVar(var, data)
def fire(event, d):
"""Fire off an Event"""
- # We can fire class handlers in the worker process context and this is
+ # We can fire class handlers in the worker process context and this is
# desired so they get the task based datastore.
- # UI handlers need to be fired in the server context so we defer this. They
+ # UI handlers need to be fired in the server context so we defer this. They
# don't have a datastore so the datastore context isn't a problem.
fire_class_handlers(event, d)
def __init__(self, depgraph):
Event.__init__(self)
self._depgraph = depgraph
-
p = {}
if parm:
for s in parm.split(';'):
- s1,s2 = s.split('=')
+ s1, s2 = s.split('=')
p[s1] = s2
return (type, host, path, user, pswd, p)
uri_decoded = list(decodeurl(uri))
uri_find_decoded = list(decodeurl(uri_find))
uri_replace_decoded = list(decodeurl(uri_replace))
- result_decoded = ['','','','','',{}]
+ result_decoded = ['', '', '', '', '', {}]
for i in uri_find_decoded:
loc = uri_find_decoded.index(i)
result_decoded[loc] = uri_decoded[loc]
if setup:
for url in urldata:
if not urldata[url].setup:
- urldata[url].setup_localpath(d)
+ urldata[url].setup_localpath(d)
urldata_cache[fn] = urldata
return urldata
continue
lf = bb.utils.lockfile(ud.lockfile)
if not m.forcefetch(u, ud, d) and os.path.exists(ud.md5):
- # If someone else fetched this before we got the lock,
+ # If someone else fetched this before we got the lock,
# notice and don't try again
try:
os.utime(ud.md5, None)
urldata = init([], d, True)
for u in urldata:
- ud = urldata[u]
+ ud = urldata[u]
local.append(ud.localpath)
return local
Return the version string for the current package
(usually to be used as PV)
Most packages usually only have one SCM so we just pass on the call.
- In the multi SCM case, we build a value based on SRCREV_FORMAT which must
+ In the multi SCM case, we build a value based on SRCREV_FORMAT which must
have been set.
"""
#
- # Ugly code alert. localpath in the fetchers will try to evaluate SRCREV which
+ # Ugly code alert. localpath in the fetchers will try to evaluate SRCREV which
# could translate into a call to here. If it does, we need to catch this
# and provide some way so it knows get_srcrev is active instead of being
- # some number etc. hence the srcrev_internal_call tracking and the magic
+ # some number etc. hence the srcrev_internal_call tracking and the magic
# "SRCREVINACTION" return value.
#
# Neater solutions welcome!
scms = []
- # Only call setup_localpath on URIs which suppports_srcrev()
+ # Only call setup_localpath on URIs which suppports_srcrev()
urldata = init(bb.data.getVar('SRC_URI', d, 1).split(), d, False)
for u in urldata:
ud = urldata[u]
bb.msg.error(bb.msg.domain.Fetcher, "SRCREV was used yet no valid SCM was found in SRC_URI")
raise ParameterError
- bb.data.setVar('__BB_DONT_CACHE','1', d)
+ bb.data.setVar('__BB_DONT_CACHE', '1', d)
if len(scms) == 1:
return urldata[scms[0]].method.sortable_revision(scms[0], urldata[scms[0]], d)
def localpath(url, d, cache = True):
"""
- Called from the parser with cache=False since the cache isn't ready
+ Called from the parser with cache=False since the cache isn't ready
at this point. Also called from classed in OE e.g. patch.bbclass
"""
ud = init([url], d)
def localpath(self, url, urldata, d):
"""
Return the local filename of a given url assuming a successful fetch.
- Can also setup variables in urldata for use in go (saving code duplication
+ Can also setup variables in urldata for use in go (saving code duplication
and duplicate code execution)
"""
return url
"""
Return:
a) a source revision if specified
- b) True if auto srcrev is in action
- c) False otherwise
+ b) True if auto srcrev is in action
+ c) False otherwise
"""
if 'rev' in ud.parm:
b) None otherwise
"""
- localcount= None
+ localcount = None
if 'name' in ud.parm:
pn = data.getVar("PN", d, 1)
localcount = data.getVar("LOCALCOUNT_" + ud.parm['name'], d, 1)
def sortable_revision(self, url, ud, d):
"""
-
+
"""
if hasattr(self, "_sortable_revision"):
return self._sortable_revision(url, ud, d)
revision = Fetch.srcrev_internal_helper(ud, d)
if revision is True:
- ud.revision = self.latest_revision(url, ud, d)
+ ud.revision = self.latest_revision(url, ud, d)
elif revision:
ud.revision = revision
if not ud.revision:
- ud.revision = self.latest_revision(url, ud, d)
+ ud.revision = self.latest_revision(url, ud, d)
ud.localfile = data.expand('bzr_%s_%s_%s.tar.gz' % (ud.host, ud.path.replace('/', '.'), ud.revision), d)
-
+
return os.path.join(data.getVar("DL_DIR", d, True), ud.localfile)
def _buildbzrcommand(self, ud, d, command):
def _build_revision(self, url, ud, d):
return ud.revision
-
try:
os.rmdir(moddir)
except OSError:
- pass
+ pass
raise FetchError(ud.module)
# tar them up to a defined filename
tag = Fetch.srcrev_internal_helper(ud, d)
if tag is True:
- ud.tag = self.latest_revision(url, ud, d)
+ ud.tag = self.latest_revision(url, ud, d)
elif tag:
ud.tag = tag
if not ud.tag or ud.tag == "master":
- ud.tag = self.latest_revision(url, ud, d)
+ ud.tag = self.latest_revision(url, ud, d)
subdir = ud.parm.get("subpath", "")
if subdir != "":
os.chdir(ud.clonedir)
mirror_tarballs = data.getVar("BB_GENERATE_MIRROR_TARBALLS", d, True)
- if mirror_tarballs != "0" or 'fullclone' in ud.parm:
+ if mirror_tarballs != "0" or 'fullclone' in ud.parm:
bb.msg.note(1, bb.msg.domain.Fetcher, "Creating tarball of git repository")
runfetchcmd("tar -czf %s %s" % (repofile, os.path.join(".", ".git", "*") ), d)
def _sortable_buildindex_disabled(self, url, ud, d, rev):
"""
- Return a suitable buildindex for the revision specified. This is done by counting revisions
+ Return a suitable buildindex for the revision specified. This is done by counting revisions
using "git rev-list" which may or may not work in different circumstances.
"""
buildindex = "%s" % output.split()[0]
bb.msg.debug(1, bb.msg.domain.Fetcher, "GIT repository for %s in %s is returning %s revisions in rev-list before %s" % (url, ud.clonedir, buildindex, rev))
- return buildindex
-
+ return buildindex
os.chdir(ud.pkgdir)
bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % fetchcmd)
runfetchcmd(fetchcmd, d)
-
- # Even when we clone (fetch), we still need to update as hg's clone
- # won't checkout the specified revision if its on a branch
+
+ # Even when we clone (fetch), we still need to update as hg's clone
+ # won't checkout the specified revision if its on a branch
updatecmd = self._buildhgcommand(ud, d, "update")
bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % updatecmd)
runfetchcmd(updatecmd, d)
Return a unique key for the url
"""
return "hg:" + ud.moddir
-
Check the status of the url
"""
if urldata.localpath.find("*") != -1:
- bb.msg.note(1, bb.msg.domain.Fetcher, "URL %s looks like a glob and was therefore not checked." % url)
- return True
+ bb.msg.note(1, bb.msg.domain.Fetcher, "URL %s looks like a glob and was therefore not checked." % url)
+ return True
if os.path.exists(urldata.localpath):
- return True
+ return True
return False
from bb.fetch import runfetchcmd
class Osc(Fetch):
- """Class to fetch a module or modules from Opensuse build server
+ """Class to fetch a module or modules from Opensuse build server
repositories."""
def supports(self, url, ud, d):
proto = "ocs"
if "proto" in ud.parm:
proto = ud.parm["proto"]
-
+
options = []
config = "-c %s" % self.generate_config(ud, d)
os.chdir(ud.pkgdir)
bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % oscfetchcmd)
runfetchcmd(oscfetchcmd, d)
-
+
os.chdir(os.path.join(ud.pkgdir + ud.path))
# tar them up to a defined filename
try:
config_path = "%s/oscrc" % data.expand('${OSCDIR}', d)
if (os.path.exists(config_path)):
- os.remove(config_path)
+ os.remove(config_path)
f = open(config_path, 'w')
f.write("[general]\n")
f.write("user = %s\n" % ud.parm["user"])
f.write("pass = %s\n" % ud.parm["pswd"])
f.close()
-
+
return config_path
return cset.split(' ')[1]
getcset = staticmethod(getcset)
- def localpath(self, url, ud, d):
+ def localpath(self, url, ud, d):
(host,path,user,pswd,parm) = Perforce.doparse(url,d)
count = 0
- for file in p4file:
+ for file in p4file:
list = file.split()
if list[2] == "delete":
os.system("%s%s print -o %s/%s %s" % (p4cmd, p4opt, module,dest[:where],list[0]))
count = count + 1
-
+
if count == 0:
bb.msg.error(bb.msg.domain.Fetcher, "Fetch: No files gathered from the P4 fetch")
raise FetchError(module)
raise FetchError(module)
# cleanup
os.system('rm -rf %s' % tmpfile)
-
-
ud.revision = rev
ud.date = ""
else:
- ud.revision = ""
+ ud.revision = ""
ud.localfile = data.expand('%s_%s_%s_%s_%s.tar.gz' % (ud.module.replace('/', '.'), ud.host, ud.path.replace('/', '.'), ud.revision, ud.date), d)
Tuple = collections.namedtuple(name, " ".join(fields))
return Tuple(*range(len(fields)))
-domain = _NamedTuple("Domain",(
+domain = _NamedTuple("Domain", (
"Default",
"Build",
"Cache",
def eval(self, data):
bb.parse.BBHandler.inherit(self.n, data)
-
+
def handleInclude(statements, m, fn, lineno, force):
statements.append(IncludeNode(m.group(1), fn, lineno, force))
# Copyright (C) 2003, 2004 Chris Larson
# Copyright (C) 2003, 2004 Phil Blundell
-#
+#
# 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.
# Copyright (C) 2003, 2004 Chris Larson
# Copyright (C) 2003, 2004 Phil Blundell
-#
+#
# 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.
"""
BitBake Persistent Data Store
- Used to store data in a central location such that other threads/tasks can
+ Used to store data in a central location such that other threads/tasks can
access them at some future date.
- The "domain" is used as a key to isolate each data pool and in this
- implementation corresponds to an SQL table. The SQL table consists of a
+ The "domain" is used as a key to isolate each data pool and in this
+ implementation corresponds to an SQL table. The SQL table consists of a
simple key and value pair.
Why sqlite? It handles all the locking issues for us.
for row in data:
ret[str(row[0])] = str(row[1])
- return ret
+ return ret
def getValue(self, domain, key):
"""
self._execute("DELETE from %s where key=?;" % domain, [key])
def _execute(self, *query):
- while True:
+ while True:
try:
self.connection.execute(*query)
return
if 'database is locked' in str(e):
continue
raise
-
-
-
def preferredVersionMatch(pe, pv, pr, preferred_e, preferred_v, preferred_r):
"""
Check if the version pe,pv,pr is the preferred one.
- If there is preferred version defined and ends with '%', then pv has to start with that version after removing the '%'
+ If there is preferred version defined and ends with '%', then pv has to start with that version after removing the '%'
"""
if (pr == preferred_r or preferred_r == None):
if (pe == preferred_e or preferred_e == None):
for file_set in pkg_pn:
for f in file_set:
- pe,pv,pr = dataCache.pkg_pepvpr[f]
+ pe, pv, pr = dataCache.pkg_pepvpr[f]
if preferredVersionMatch(pe, pv, pr, preferred_e, preferred_v, preferred_r):
preferred_file = f
preferred_ver = (pe, pv, pr)
latest_p = 0
latest_f = None
for file_name in file_set:
- pe,pv,pr = dataCache.pkg_pepvpr[file_name]
+ pe, pv, pr = dataCache.pkg_pepvpr[file_name]
dp = dataCache.pkg_dp[file_name]
if (latest is None) or ((latest_p == dp) and (utils.vercmp(latest, (pe, pv, pr)) < 0)) or (dp > latest_p):
def _filterProviders(providers, item, cfgData, dataCache):
"""
- Take a list of providers and filter/reorder according to the
+ Take a list of providers and filter/reorder according to the
environment variables and previous build results
"""
eligible = []
preferred_versions = {}
sortpkg_pn = {}
- # The order of providers depends on the order of the files on the disk
+ # The order of providers depends on the order of the files on the disk
# up to here. Sort pkg_pn to make dependency issues reproducible rather
# than effectively random.
providers.sort()
def filterProviders(providers, item, cfgData, dataCache):
"""
- Take a list of providers and filter/reorder according to the
+ Take a list of providers and filter/reorder according to the
environment variables and previous build results
Takes a "normal" target item
"""
def filterProvidersRunTime(providers, item, cfgData, dataCache):
"""
- Take a list of providers and filter/reorder according to the
+ Take a list of providers and filter/reorder according to the
environment variables and previous build results
Takes a "runtime" target item
"""
rproviders = []
if rdepend in dataCache.rproviders:
- rproviders += dataCache.rproviders[rdepend]
+ rproviders += dataCache.rproviders[rdepend]
if rdepend in dataCache.packages:
rproviders += dataCache.packages[rdepend]
class TaskFailure(Exception):
"""Exception raised when a task in a runqueue fails"""
- def __init__(self, x):
+ def __init__(self, x):
self.args = x
def taskActive(self):
self.active = self.active + 1
-# These values indicate the next step due to be run in the
+# These values indicate the next step due to be run in the
# runQueue state machine
runQueuePrepare = 2
runQueueRunInit = 3
"""
def __init__(self, runqueue):
"""
- The default scheduler just returns the first buildable task (the
+ The default scheduler just returns the first buildable task (the
priority map is sorted by task numer)
"""
self.rq = runqueue
class RunQueueSchedulerCompletion(RunQueueSchedulerSpeed):
"""
- A scheduler optimised to complete .bb files are quickly as possible. The
- priority map is sorted by task weight, but then reordered so once a given
+ A scheduler optimised to complete .bb files are quickly as possible. The
+ priority map is sorted by task weight, but then reordered so once a given
.bb file starts to build, its completed as quickly as possible. This works
- well where disk space is at a premium and classes like OE's rm_work are in
+ well where disk space is at a premium and classes like OE's rm_work are in
force.
"""
def __init__(self, runqueue):
#FIXME - whilst this groups all fnids together it does not reorder the
#fnid groups optimally.
-
+
basemap = deepcopy(self.prio_map)
self.prio_map = []
while (len(basemap) > 0):
if chain1[index] != chain2[index]:
return False
return True
-
+
def chain_array_contains(chain, chain_array):
"""
Return True if chain_array contains chain
def calculate_task_weights(self, endpoints):
"""
- Calculate a number representing the "weight" of each task. Heavier weighted tasks
+ Calculate a number representing the "weight" of each task. Heavier weighted tasks
have more dependencies and hence should be executed sooner for maximum speed.
This function also sanity checks the task list finding tasks that its not
task_done[revdep] = True
endpoints = next_points
if len(next_points) == 0:
- break
+ break
# Circular dependency sanity check
problem_tasks = []
def prepare_runqueue(self):
"""
- Turn a set of taskData into a RunQueue and compute data needed
+ Turn a set of taskData into a RunQueue and compute data needed
to optimise the execution order.
"""
# Step A - Work out a list of tasks to run
#
# Taskdata gives us a list of possible providers for every build and run
- # target ordered by priority. It also gives information on each of those
+ # target ordered by priority. It also gives information on each of those
# providers.
#
- # To create the actual list of tasks to execute we fix the list of
- # providers and then resolve the dependencies into task IDs. This
- # process is repeated for each type of dependency (tdepends, deptask,
+ # To create the actual list of tasks to execute we fix the list of
+ # providers and then resolve the dependencies into task IDs. This
+ # process is repeated for each type of dependency (tdepends, deptask,
# rdeptast, recrdeptask, idepends).
def add_build_dependencies(depids, tasknames, depends):
if fnid not in taskData.failed_fnids:
- # Resolve task internal dependencies
+ # Resolve task internal dependencies
#
# e.g. addtask before X after Y
depends = taskData.tasks_tdepends[task]
- # Resolve 'deptask' dependencies
+ # Resolve 'deptask' dependencies
#
# e.g. do_sometask[deptask] = "do_someothertask"
# (makes sure sometask runs after someothertask of all DEPENDS)
tasknames = task_deps['deptask'][taskData.tasks_name[task]].split()
add_build_dependencies(taskData.depids[fnid], tasknames, depends)
- # Resolve 'rdeptask' dependencies
+ # Resolve 'rdeptask' dependencies
#
# e.g. do_sometask[rdeptask] = "do_someothertask"
# (makes sure sometask runs after someothertask of all RDEPENDS)
taskname = task_deps['rdeptask'][taskData.tasks_name[task]]
add_runtime_dependencies(taskData.rdepids[fnid], [taskname], depends)
- # Resolve inter-task dependencies
+ # Resolve inter-task dependencies
#
# e.g. do_sometask[depends] = "targetname:do_someothertask"
# (makes sure sometask runs after targetname's someothertask)
newdep = []
bb.msg.debug(2, bb.msg.domain.RunQueue, "Task %s (%s %s) contains self reference! %s" % (task, taskData.fn_index[taskData.tasks_fnid[task]], taskData.tasks_name[task], depends))
for dep in depends:
- if task != dep:
- newdep.append(dep)
+ if task != dep:
+ newdep.append(dep)
depends = newdep
self.runq_fnid.append(taskData.tasks_fnid[task])
#
# Build a list of recursive cumulative dependencies for each fnid
# We do this by fnid, since if A depends on some task in B
- # we're interested in later tasks B's fnid might have but B itself
+ # we're interested in later tasks B's fnid might have but B itself
# doesn't depend on
#
# Algorithm is O(tasks) + O(tasks)*O(fnids)
if len(runq_recrdepends[task]) > 0:
taskfnid = self.runq_fnid[task]
for dep in reccumdepends[taskfnid]:
- # Ignore self references
+ # Ignore self references
if dep == task:
continue
for taskname in runq_recrdepends[task]:
bb.msg.note(2, bb.msg.domain.RunQueue, "Compute totals (have %s endpoint(s))" % len(endpoints))
- # Calculate task weights
+ # Calculate task weights
# Check of higher length circular dependencies
self.runq_weight = self.calculate_task_weights(endpoints)
for prov in self.dataCache.fn_provides[fn]:
if prov not in prov_list:
prov_list[prov] = [fn]
- elif fn not in prov_list[prov]:
+ elif fn not in prov_list[prov]:
prov_list[prov].append(fn)
error = False
for prov in prov_list:
buildable.append(task)
def check_buildable(self, task, buildable):
- for revdep in self.runq_revdeps[task]:
+ for revdep in self.runq_revdeps[task]:
alldeps = 1
for dep in self.runq_depends[revdep]:
if dep in unchecked:
try:
t2 = os.stat(stampfile2)[stat.ST_MTIME]
if t1 < t2:
- bb.msg.debug(2, bb.msg.domain.RunQueue, "Stampfile %s < %s" % (stampfile,stampfile2))
+ bb.msg.debug(2, bb.msg.domain.RunQueue, "Stampfile %s < %s" % (stampfile, stampfile2))
iscurrent = False
except:
- bb.msg.debug(2, bb.msg.domain.RunQueue, "Exception reading %s for %s" % (stampfile2 ,stampfile))
+ bb.msg.debug(2, bb.msg.domain.RunQueue, "Exception reading %s for %s" % (stampfile2 , stampfile))
iscurrent = False
return iscurrent
def task_complete(self, task):
"""
Mark a task as completed
- Look at the reverse dependencies and mark any task with
+ Look at the reverse dependencies and mark any task with
completed dependencies as buildable
"""
self.runq_complete[task] = 1
def finish_runqueue_now(self):
bb.msg.note(1, bb.msg.domain.RunQueue, "Sending SIGINT to remaining %s tasks" % self.stats.active)
for k, v in self.build_pids.iteritems():
- try:
- os.kill(-k, signal.SIGINT)
- except:
- pass
+ try:
+ os.kill(-k, signal.SIGINT)
+ except:
+ pass
for pipe in self.build_pipes:
self.build_pipes[pipe].read()
"""
bb.msg.debug(3, bb.msg.domain.RunQueue, "run_tasks:")
for task in range(len(self.runq_task)):
- bb.msg.debug(3, bb.msg.domain.RunQueue, " (%s)%s - %s: %s Deps %s RevDeps %s" % (task,
- taskQueue.fn_index[self.runq_fnid[task]],
- self.runq_task[task],
- self.runq_weight[task],
- self.runq_depends[task],
- self.runq_revdeps[task]))
+ bb.msg.debug(3, bb.msg.domain.RunQueue, " (%s)%s - %s: %s Deps %s RevDeps %s" % (task,
+ taskQueue.fn_index[self.runq_fnid[task]],
+ self.runq_task[task],
+ self.runq_weight[task],
+ self.runq_depends[task],
+ self.runq_revdeps[task]))
bb.msg.debug(3, bb.msg.domain.RunQueue, "sorted_tasks:")
for task1 in range(len(self.runq_task)):
if task1 in self.prio_map:
task = self.prio_map[task1]
- bb.msg.debug(3, bb.msg.domain.RunQueue, " (%s)%s - %s: %s Deps %s RevDeps %s" % (task,
- taskQueue.fn_index[self.runq_fnid[task]],
- self.runq_task[task],
- self.runq_weight[task],
- self.runq_depends[task],
- self.runq_revdeps[task]))
+ bb.msg.debug(3, bb.msg.domain.RunQueue, " (%s)%s - %s: %s Deps %s RevDeps %s" % (task,
+ taskQueue.fn_index[self.runq_fnid[task]],
+ self.runq_task[task],
+ self.runq_weight[task],
+ self.runq_depends[task],
+ self.runq_revdeps[task]))
class TaskFailure(Exception):
"""
Exception raised when a task in a runqueue fails
"""
- def __init__(self, x):
+ def __init__(self, x):
self.args = x
if len(self.queue) > 0:
print "Warning, worker left partial message"
os.close(self.fd)
-
self.connection.terminateServer()
except:
pass
-
def __init__(self, cooker, interface = ("localhost", 0)):
"""
- Constructor
- """
+ Constructor
+ """
SimpleXMLRPCServer.__init__(self, interface,
requestHandler=SimpleXMLRPCRequestHandler,
logRequests=False, allow_none=True)
traceback.print_exc()
pass
if nextsleep is None and len(self._idlefuns) > 0:
- nextsleep = 0
+ nextsleep = 0
self.timeout = nextsleep
# Tell idle functions we're exiting
for function, data in self._idlefuns.items():
def terminate(self):
# Don't wait for server indefinitely
import socket
- socket.setdefaulttimeout(2)
+ socket.setdefaulttimeout(2)
try:
self.events.system_quit()
except:
self.connection.terminateServer()
except:
pass
-
tasks.append([name, "do_%s" % cmd])
td.add_unresolved(localdata, cooker.status)
-
+
rq = runqueue.RunQueue(cooker, localdata, cooker.status, td, tasks)
rq.prepare_runqueue()
rq.execute_runqueue()
"""Show a comprehensive list of commands and their purpose"""
print "="*30, "Available Commands", "="*30
for cmd in sorted(cmds):
- function,numparams,usage,helptext = cmds[cmd]
+ function, numparams, usage, helptext = cmds[cmd]
print "| %s | %s" % (usage.ljust(30), helptext)
print "="*78
return False
print "SHELL: Creating '%s/%s'" % ( fulldirname, filename )
newpackage = open( "%s/%s" % ( fulldirname, filename ), "w" )
- print >>newpackage,"""DESCRIPTION = ""
+ print >>newpackage, """DESCRIPTION = ""
SECTION = ""
AUTHOR = ""
HOMEPAGE = ""
mydata["nick"] = "%s@%s" % ( os.environ.get( "USER", "unknown" ), socket.gethostname() or "unknown" )
mydata["text"] = content
params = urllib.urlencode( mydata )
- headers = {"Content-type": "application/x-www-form-urlencoded","Accept": "text/plain"}
+ headers = {"Content-type": "application/x-www-form-urlencoded", "Accept": "text/plain"}
host = "rafb.net"
conn = httplib.HTTPConnection( "%s:80" % host )
def getrun_id(self, name):
"""
- Return an ID number for the run target name.
+ Return an ID number for the run target name.
If it doesn't exist, create one.
"""
if not name in self.run_names_index:
def getfn_id(self, name):
"""
- Return an ID number for the filename.
+ Return an ID number for the filename.
If it doesn't exist, create one.
"""
if not name in self.fn_index:
def get_unresolved_build_targets(self, dataCache):
"""
- Return a list of build targets who's providers
+ Return a list of build targets who's providers
are unknown.
"""
unresolved = []
def get_unresolved_run_targets(self, dataCache):
"""
- Return a list of runtime targets who's providers
+ Return a list of runtime targets who's providers
are unknown.
"""
unresolved = []
Return a list of providers of item
"""
targetid = self.getbuild_id(item)
-
+
return self.build_targets[targetid]
def get_dependees(self, itemid):
def add_provider_internal(self, cfgData, dataCache, item):
"""
Add the providers of item to the task data
- Mark entries were specifically added externally as against dependencies
+ Mark entries were specifically added externally as against dependencies
added internally during dependency resolution
"""
providers_list.append(dataCache.pkg_fn[fn])
bb.msg.note(2, bb.msg.domain.Provider, "multiple providers are available for runtime %s (%s);" % (item, ", ".join(providers_list)))
bb.msg.note(2, bb.msg.domain.Provider, "consider defining a PREFERRED_PROVIDER entry to match runtime %s" % item)
- bb.event.fire(bb.event.MultipleProviders(item,providers_list, runtime=True), cfgData)
+ bb.event.fire(bb.event.MultipleProviders(item, providers_list, runtime=True), cfgData)
self.consider_msgs_cache.append(item)
if numberPreferred > 1:
providers_list.append(dataCache.pkg_fn[fn])
bb.msg.note(2, bb.msg.domain.Provider, "multiple providers are available for runtime %s (top %s entries preferred) (%s);" % (item, numberPreferred, ", ".join(providers_list)))
bb.msg.note(2, bb.msg.domain.Provider, "consider defining only one PREFERRED_PROVIDER entry to match runtime %s" % item)
- bb.event.fire(bb.event.MultipleProviders(item,providers_list, runtime=True), cfgData)
+ bb.event.fire(bb.event.MultipleProviders(item, providers_list, runtime=True), cfgData)
self.consider_msgs_cache.append(item)
# run through the list until we find one that we can build
bb.msg.debug(3, bb.msg.domain.TaskData, "tasks:")
for task in range(len(self.tasks_name)):
bb.msg.debug(3, bb.msg.domain.TaskData, " (%s)%s - %s: %s" % (
- task,
- self.fn_index[self.tasks_fnid[task]],
- self.tasks_name[task],
+ task,
+ self.fn_index[self.tasks_fnid[task]],
+ self.tasks_name[task],
self.tasks_tdepends[task]))
bb.msg.debug(3, bb.msg.domain.TaskData, "dependency ids (per fn):")
bb.msg.debug(3, bb.msg.domain.TaskData, "runtime dependency ids (per fn):")
for fnid in self.rdepids:
bb.msg.debug(3, bb.msg.domain.TaskData, " %s %s: %s" % (fnid, self.fn_index[fnid], self.rdepids[fnid]))
-
-
# 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.
-
# 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.
-
class BuildConfiguration:
""" Represents a potential *or* historic *or* concrete build. It
encompasses all the things that we need to tell bitbake to do to make it
- build what we want it to build.
+ build what we want it to build.
It also stored the metadata URL and the set of possible machines (and the
distros / images / uris for these. Apart from the metdata URL these are
return self.urls
# It might be a lot lot better if we stored these in like, bitbake conf
- # file format.
- @staticmethod
+ # file format.
+ @staticmethod
def load_from_file (filename):
f = open (filename, "r")
".conf" in the directory for the build.
This is GObject so that it can be included in the TreeStore."""
-
+
(STATE_COMPLETE, STATE_FAILED, STATE_ONGOING) = \
(0, 1, 2)
def __init__ (self, parent, identifier):
gobject.GObject.__init__ (self)
- self.date = None
+ self.date = None
self.files = []
self.status = None
self.add_file (file)
def add_file (self, file):
- # Just add the file for now. Don't care about the type.
+ # Just add the file for now. Don't care about the type.
self.files += [(file, None)]
class BuildManagerModel (gtk.TreeStore):
def __init__ (self):
gtk.TreeStore.__init__ (self,
- gobject.TYPE_STRING,
+ gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
"results" directory but is also used for starting a new build."""
__gsignals__ = {
- 'population-finished' : (gobject.SIGNAL_RUN_LAST,
+ 'population-finished' : (gobject.SIGNAL_RUN_LAST,
gobject.TYPE_NONE,
()),
'populate-error' : (gobject.SIGNAL_RUN_LAST,
date = long (time.mktime (result.date.timetuple()))
# Add a top level entry for the build
-
- self.model.set (iter,
+
+ self.model.set (iter,
BuildManagerModel.COL_IDENT, result.identifier,
BuildManagerModel.COL_DESC, result.conf.image,
- BuildManagerModel.COL_MACHINE, result.conf.machine,
- BuildManagerModel.COL_DISTRO, result.conf.distro,
- BuildManagerModel.COL_BUILD_RESULT, result,
+ BuildManagerModel.COL_MACHINE, result.conf.machine,
+ BuildManagerModel.COL_DISTRO, result.conf.distro,
+ BuildManagerModel.COL_BUILD_RESULT, result,
BuildManagerModel.COL_DATE, date,
BuildManagerModel.COL_STATE, result.state)
while (iter):
(ident, state) = self.model.get(iter,
- BuildManagerModel.COL_IDENT,
+ BuildManagerModel.COL_IDENT,
BuildManagerModel.COL_STATE)
if state == BuildResult.STATE_ONGOING:
# Misc descriptiony thing
renderer = gtk.CellRendererText ()
- col = gtk.TreeViewColumn (None, renderer,
+ col = gtk.TreeViewColumn (None, renderer,
text=BuildManagerModel.COL_DESC)
self.append_column (col)
# Machine
renderer = gtk.CellRendererText ()
- col = gtk.TreeViewColumn ("Machine", renderer,
+ col = gtk.TreeViewColumn ("Machine", renderer,
text=BuildManagerModel.COL_MACHINE)
self.append_column (col)
# distro
renderer = gtk.CellRendererText ()
- col = gtk.TreeViewColumn ("Distribution", renderer,
+ col = gtk.TreeViewColumn ("Distribution", renderer,
text=BuildManagerModel.COL_DISTRO)
self.append_column (col)
# date (using a custom function for formatting the cell contents it
# takes epoch -> human readable string)
renderer = gtk.CellRendererText ()
- col = gtk.TreeViewColumn ("Date", renderer,
+ col = gtk.TreeViewColumn ("Date", renderer,
text=BuildManagerModel.COL_DATE)
self.append_column (col)
- col.set_cell_data_func (renderer,
+ col.set_cell_data_func (renderer,
self.date_format_custom_cell_data_func)
# For status.
self.append_column (col)
col.set_cell_data_func (renderer,
self.state_format_custom_cell_data_fun)
-
class RunningBuildModel (gtk.TreeStore):
(COL_TYPE, COL_PACKAGE, COL_TASK, COL_MESSAGE, COL_ICON, COL_ACTIVE) = (0, 1, 2, 3, 4, 5)
def __init__ (self):
- gtk.TreeStore.__init__ (self,
+ gtk.TreeStore.__init__ (self,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
class RunningBuild (gobject.GObject):
__gsignals__ = {
- 'build-succeeded' : (gobject.SIGNAL_RUN_LAST,
+ 'build-succeeded' : (gobject.SIGNAL_RUN_LAST,
gobject.TYPE_NONE,
()),
'build-failed' : (gobject.SIGNAL_RUN_LAST,
# Add the message to the tree either at the top level if parent is
# None otherwise as a descendent of a task.
- self.model.append (parent,
+ self.model.append (parent,
(event.__name__.split()[-1], # e.g. MsgWarn, MsgError
- package,
+ package,
task,
event._message,
- icon,
+ icon,
False))
elif isinstance(event, bb.build.TaskStarted):
(package, task) = (event._package, event._task)
if (self.tasks_to_iter.has_key ((package, None))):
parent = self.tasks_to_iter[(package, None)]
else:
- parent = self.model.append (None, (None,
- package,
+ parent = self.model.append (None, (None,
+ package,
None,
- "Package: %s" % (package),
+ "Package: %s" % (package),
None,
False))
self.tasks_to_iter[(package, None)] = parent
self.model.set(parent, self.model.COL_ICON, "gtk-execute")
# Add an entry in the model for this task
- i = self.model.append (parent, (None,
- package,
+ i = self.model.append (parent, (None,
+ package,
task,
- "Task: %s" % (task),
+ "Task: %s" % (task),
None,
False))
renderer = gtk.CellRendererText ()
col = gtk.TreeViewColumn ("Message", renderer, text=3)
self.append_column (col)
-
-
x = event.sofar
y = event.total
if x == y:
- print("\nParsing finished. %d cached, %d parsed, %d skipped, %d masked, %d errors."
+ print("\nParsing finished. %d cached, %d parsed, %d skipped, %d masked, %d errors."
% ( event.cached, event.parsed, event.skipped, event.masked, event.errors))
pbar.hide()
gtk.gdk.threads_enter()
server.runCommand(["stateShutdown"])
shutdown = shutdown + 1
pass
-
def event_handle_idle_func (eventHandler, build):
- # Consume as many messages as we can in the time available to us
- event = eventHandler.getEvent()
- while event:
- build.handle_event (event)
- event = eventHandler.getEvent()
+ # Consume as many messages as we can in the time available to us
+ event = eventHandler.getEvent()
+ while event:
+ build.handle_event (event)
+ event = eventHandler.getEvent()
- return True
+ return True
class MainWindow (gtk.Window):
def __init__ (self):
running_build)
gtk.main()
-
sys.stdout.write("done.")
sys.stdout.flush()
if x == y:
- print("\nParsing of %d .bb files complete (%d cached, %d parsed). %d targets, %d skipped, %d masked, %d errors."
+ print("\nParsing of %d .bb files complete (%d cached, %d parsed). %d targets, %d skipped, %d masked, %d errors."
% ( event.total, event.cached, event.parsed, event.virtuals, event.skipped, event.masked, event.errors))
continue
"""Thread Activity Window"""
def __init__( self, x, y, width, height ):
NCursesUI.DecoratedWindow.__init__( self, "Thread Activity", x, y, width, height )
-
+
def setStatus( self, thread, text ):
line = "%02d: %s" % ( thread, text )
width = self.dimensions[WIDTH]
helper = uihelper.BBUIHelper()
shutdown = 0
-
+
try:
cmdline = server.runCommand(["getCmdLineAction"])
if not cmdline:
y = event.total
if x == y:
mw.setStatus("Idle")
- mw.appendText("Parsing finished. %d cached, %d parsed, %d skipped, %d masked."
+ mw.appendText("Parsing finished. %d cached, %d parsed, %d skipped, %d masked."
% ( event.cached, event.parsed, event.skipped, event.masked ))
else:
mw.setStatus("Parsing: %s (%04d/%04d) [%2d %%]" % ( parsespin.next(), x, y, x*100/y ) )
except:
import traceback
traceback.print_exc()
-
on what machines are available. The distribution and images available for
the machine and the the uris to use for building the given machine."""
__gsignals__ = {
- 'success' : (gobject.SIGNAL_RUN_LAST,
+ 'success' : (gobject.SIGNAL_RUN_LAST,
gobject.TYPE_NONE,
()),
'error' : (gobject.SIGNAL_RUN_LAST,
if (active_iter):
self.configuration.machine = model.get(active_iter, 0)[0]
- # Extract the chosen distro from the combo
+ # Extract the chosen distro from the combo
model = self.distribution_combo.get_model()
active_iter = self.distribution_combo.get_active_iter()
if (active_iter):
#
# TODO: Should be a method on the RunningBuild class
def event_handle_timeout (eventHandler, build):
- # Consume as many messages as we can ...
- event = eventHandler.getEvent()
- while event:
- build.handle_event (event)
- event = eventHandler.getEvent()
- return True
+ # Consume as many messages as we can ...
+ event = eventHandler.getEvent()
+ while event:
+ build.handle_event (event)
+ event = eventHandler.getEvent()
+ return True
class MainWindow (gtk.Window):
- # Callback that gets fired when the user hits a button in the
- # BuildSetupDialog.
- def build_dialog_box_response_cb (self, dialog, response_id):
- conf = None
- if (response_id == BuildSetupDialog.RESPONSE_BUILD):
- dialog.update_configuration()
- print dialog.configuration.machine, dialog.configuration.distro, \
- dialog.configuration.image
- conf = dialog.configuration
-
- dialog.destroy()
-
- if conf:
- self.manager.do_build (conf)
-
- def build_button_clicked_cb (self, button):
- dialog = BuildSetupDialog ()
-
- # For some unknown reason Dialog.run causes nice little deadlocks ... :-(
- dialog.connect ("response", self.build_dialog_box_response_cb)
- dialog.show()
-
- def __init__ (self):
- gtk.Window.__init__ (self)
-
- # Pull in *just* the main vbox from the Glade XML data and then pack
- # that inside the window
- gxml = gtk.glade.XML (os.path.dirname(__file__) + "/crumbs/puccho.glade",
- root = "main_window_vbox")
- vbox = gxml.get_widget ("main_window_vbox")
- self.add (vbox)
-
- # Create the tree views for the build manager view and the progress view
- self.build_manager_view = BuildManagerTreeView()
- self.running_build_view = RunningBuildTreeView()
-
- # Grab the scrolled windows that we put the tree views into
- self.results_scrolledwindow = gxml.get_widget ("results_scrolledwindow")
- self.progress_scrolledwindow = gxml.get_widget ("progress_scrolledwindow")
-
- # Put the tree views inside ...
- self.results_scrolledwindow.add (self.build_manager_view)
- self.progress_scrolledwindow.add (self.running_build_view)
-
- # Hook up the build button...
- self.build_button = gxml.get_widget ("main_toolbutton_build")
- self.build_button.connect ("clicked", self.build_button_clicked_cb)
+ # Callback that gets fired when the user hits a button in the
+ # BuildSetupDialog.
+ def build_dialog_box_response_cb (self, dialog, response_id):
+ conf = None
+ if (response_id == BuildSetupDialog.RESPONSE_BUILD):
+ dialog.update_configuration()
+ print dialog.configuration.machine, dialog.configuration.distro, \
+ dialog.configuration.image
+ conf = dialog.configuration
+
+ dialog.destroy()
+
+ if conf:
+ self.manager.do_build (conf)
+
+ def build_button_clicked_cb (self, button):
+ dialog = BuildSetupDialog ()
+
+ # For some unknown reason Dialog.run causes nice little deadlocks ... :-(
+ dialog.connect ("response", self.build_dialog_box_response_cb)
+ dialog.show()
+
+ def __init__ (self):
+ gtk.Window.__init__ (self)
+
+ # Pull in *just* the main vbox from the Glade XML data and then pack
+ # that inside the window
+ gxml = gtk.glade.XML (os.path.dirname(__file__) + "/crumbs/puccho.glade",
+ root = "main_window_vbox")
+ vbox = gxml.get_widget ("main_window_vbox")
+ self.add (vbox)
+
+ # Create the tree views for the build manager view and the progress view
+ self.build_manager_view = BuildManagerTreeView()
+ self.running_build_view = RunningBuildTreeView()
+
+ # Grab the scrolled windows that we put the tree views into
+ self.results_scrolledwindow = gxml.get_widget ("results_scrolledwindow")
+ self.progress_scrolledwindow = gxml.get_widget ("progress_scrolledwindow")
+
+ # Put the tree views inside ...
+ self.results_scrolledwindow.add (self.build_manager_view)
+ self.progress_scrolledwindow.add (self.running_build_view)
+
+ # Hook up the build button...
+ self.build_button = gxml.get_widget ("main_toolbutton_build")
+ self.build_button.connect ("clicked", self.build_button_clicked_cb)
# I'm not very happy about the current ownership of the RunningBuild. I have
# my suspicions that this object should be held by the BuildManager since we
"""
-Use this class to fork off a thread to recieve event callbacks from the bitbake
+Use this class to fork off a thread to recieve event callbacks from the bitbake
server and queue them for the UI to process. This process must be used to avoid
client/server deadlocks.
"""
if request is None:
return
SimpleXMLRPCServer.close_request(self, request)
-
+
def process_request(self, request, client_address):
if request is None:
return
SimpleXMLRPCServer.process_request(self, request, client_address)
\r
-
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-separators = ".-"
-
import re, fcntl, os, types, bb, string, stat, shutil, time
from commands import getstatusoutput
+# Version comparison
+separators = ".-"
+
# Context used in better_exec, eval
_context = {
"os": os,
r = vercmp_part(ra, rb)
return r
-_package_weights_ = {"pre":-2,"p":0,"alpha":-4,"beta":-3,"rc":-1} # dicts are unordered
-_package_ends_ = ["pre", "p", "alpha", "beta", "rc", "cvs", "bk", "HEAD" ] # so we need ordered list
+_package_weights_ = {"pre":-2, "p":0, "alpha":-4, "beta":-3, "rc":-1} # dicts are unordered
+_package_ends_ = ["pre", "p", "alpha", "beta", "rc", "cvs", "bk", "HEAD" ] # so we need ordered list
def relparse(myver):
"""Parses the last elements of a version number into a triplet, that can
later be compared.
"""
- number = 0
- p1 = 0
- p2 = 0
+ number = 0
+ p1 = 0
+ p2 = 0
mynewver = myver.split('_')
- if len(mynewver)==2:
+ if len(mynewver) == 2:
# an _package_weights_
number = float(mynewver[0])
match = 0
divider = len(myver)-1
if myver[divider:] not in "1234567890":
#letter at end
- p1 = ord(myver[divider:])
+ p1 = ord(myver[divider:])
number = float(myver[0:divider])
else:
number = float(myver)
- return [number,p1,p2]
+ return [number, p1, p2]
__vercmp_cache__ = {}
-def vercmp_string(val1,val2):
+def vercmp_string(val1, val2):
"""This takes two version strings and returns an integer to tell you whether
the versions are the same, val1>val2 or val2>val1.
"""
# quick short-circuit
if val1 == val2:
return 0
- valkey = val1+" "+val2
+ valkey = val1 + " " + val2
# cache lookup
try:
return __vercmp_cache__[valkey]
try:
- return - __vercmp_cache__[val2+" "+val1]
+ return - __vercmp_cache__[val2 + " " + val1]
except KeyError:
pass
except KeyError:
# replace '-' by '.'
# FIXME: Is it needed? can val1/2 contain '-'?
- val1 = string.split(val1,'-')
+ val1 = val1.split("-")
if len(val1) == 2:
- val1[0] = val1[0] +"."+ val1[1]
- val2 = string.split(val2,'-')
+ val1[0] = val1[0] + "." + val1[1]
+ val2 = val2.split("-")
if len(val2) == 2:
- val2[0] = val2[0] +"."+ val2[1]
+ val2[0] = val2[0] + "." + val2[1]
- val1 = string.split(val1[0],'.')
- val2 = string.split(val2[0],'.')
+ val1 = val1[0].split('.')
+ val2 = val2[0].split('.')
# add back decimal point so that .03 does not become "3" !
- for x in range(1,len(val1)):
+ for x in range(1, len(val1)):
if val1[x][0] == '0' :
val1[x] = '.' + val1[x]
- for x in range(1,len(val2)):
+ for x in range(1, len(val2)):
if val2[x][0] == '0' :
val2[x] = '.' + val2[x]
val2[-1] += '_' + val2_prepart
# The above code will extend version numbers out so they
# have the same number of digits.
- for x in range(0,len(val1)):
+ for x in range(0, len(val1)):
cmp1 = relparse(val1[x])
cmp2 = relparse(val2[x])
- for y in range(0,3):
+ for y in range(0, 3):
myret = cmp1[y] - cmp2[y]
if myret != 0:
__vercmp_cache__[valkey] = myret
# print the environment of the method
bb.msg.error(bb.msg.domain.Util, "Printing the environment of the function")
- min_line = max(1,line-4)
- max_line = min(line+4,len(body)-1)
- for i in range(min_line,max_line+1):
+ min_line = max(1, line-4)
+ max_line = min(line + 4, len(body)-1)
+ for i in range(min_line, max_line + 1):
bb.msg.error(bb.msg.domain.Util, "\t%.4d:%s" % (i, body[i-1]) )
try:
return compile(text, file, mode)
except Exception, e:
- import bb,sys
+ import bb, sys
# split the text into lines again
body = text.split('\n')
print the lines that are responsible for the
error.
"""
- import bb,sys
+ import bb, sys
try:
exec code in _context, context
except:
- (t,value,tb) = sys.exc_info()
+ (t, value, tb) = sys.exc_info()
if t in [bb.parse.SkipPackage, bb.build.FuncFailed]:
raise
# print the Header of the Error Message
bb.msg.error(bb.msg.domain.Util, "Error in executing python function in: %s" % realfile)
- bb.msg.error(bb.msg.domain.Util, "Exception:%s Message:%s" % (t,value) )
+ bb.msg.error(bb.msg.domain.Util, "Exception:%s Message:%s" % (t, value))
# let us find the line number now
while tb.tb_next:
line = traceback.tb_lineno(tb)
_print_trace( text.split('\n'), line )
-
+
raise
def simple_exec(code, context):
while True:
# If we leave the lockfiles lying around there is no problem
# but we should clean up after ourselves. This gives potential
- # for races though. To work around this, when we acquire the lock
- # we check the file we locked was still the lock file on disk.
- # by comparing inode numbers. If they don't match or the lockfile
+ # for races though. To work around this, when we acquire the lock
+ # we check the file we locked was still the lock file on disk.
+ # by comparing inode numbers. If they don't match or the lockfile
# no longer exists, we start again.
- # This implementation is unfair since the last person to request the
+ # This implementation is unfair since the last person to request the
# lock is the most likely to win it.
try:
- lf = open(name, "a+")
+ lf = open(name, "a + ")
fcntl.flock(lf.fileno(), fcntl.LOCK_EX)
statinfo = os.fstat(lf.fileno())
if os.path.exists(lf.name):
- statinfo2 = os.stat(lf.name)
- if statinfo.st_ino == statinfo2.st_ino:
- return lf
+ statinfo2 = os.stat(lf.name)
+ if statinfo.st_ino == statinfo2.st_ino:
+ return lf
# File no longer exists or changed, retry
lf.close
except Exception, e:
def unlockfile(lf):
"""
- Unlock a file locked using lockfile()
+ Unlock a file locked using lockfile()
"""
os.unlink(lf.name)
fcntl.flock(lf.fileno(), fcntl.LOCK_UN)
except ImportError:
import md5
m = md5.new()
-
+
for line in open(filename):
m.update(line)
return m.hexdigest()
for key in os.environ.keys():
if key in good_vars:
continue
-
+
removed_vars.append(key)
os.unsetenv(key)
del os.environ[key]
def prunedir(topdir):
# Delete everything reachable from the directory named in 'topdir'.
# CAUTION: This is dangerous!
- for root, dirs, files in os.walk(topdir, topdown=False):
+ for root, dirs, files in os.walk(topdir, topdown = False):
for name in files:
os.remove(os.path.join(root, name))
for name in dirs:
# but thats possibly insane and suffixes is probably going to be small
#
def prune_suffix(var, suffixes, d):
- # See if var ends with any of the suffixes listed and
+ # See if var ends with any of the suffixes listed and
# remove it if found
for suffix in suffixes:
if var.endswith(suffix):
import stat
-def movefile(src,dest,newmtime=None,sstat=None):
+def movefile(src, dest, newmtime = None, sstat = None):
"""Moves a file from src to dest, preserving all permissions and
attributes; mtime will be preserved even when moving across
filesystems. Returns true on success and false on failure. Move is
atomic.
"""
- #print "movefile("+src+","+dest+","+str(newmtime)+","+str(sstat)+")"
+ #print "movefile(" + src + "," + dest + "," + str(newmtime) + "," + str(sstat) + ")"
try:
if not sstat:
- sstat=os.lstat(src)
+ sstat = os.lstat(src)
except Exception, e:
print "movefile: Stating source file failed...", e
return None
- destexists=1
+ destexists = 1
try:
- dstat=os.lstat(dest)
+ dstat = os.lstat(dest)
except:
- dstat=os.lstat(os.path.dirname(dest))
- destexists=0
+ dstat = os.lstat(os.path.dirname(dest))
+ destexists = 0
if destexists:
if stat.S_ISLNK(dstat[stat.ST_MODE]):
try:
os.unlink(dest)
- destexists=0
+ destexists = 0
except Exception, e:
pass
if stat.S_ISLNK(sstat[stat.ST_MODE]):
try:
- target=os.readlink(src)
+ target = os.readlink(src)
if destexists and not stat.S_ISDIR(dstat[stat.ST_MODE]):
os.unlink(dest)
- os.symlink(target,dest)
+ os.symlink(target, dest)
#os.lchown(dest,sstat[stat.ST_UID],sstat[stat.ST_GID])
os.unlink(src)
return os.lstat(dest)
print "movefile: failed to properly create symlink:", dest, "->", target, e
return None
- renamefailed=1
- if sstat[stat.ST_DEV]==dstat[stat.ST_DEV]:
+ renamefailed = 1
+ if sstat[stat.ST_DEV] == dstat[stat.ST_DEV]:
try:
- ret=os.rename(src,dest)
- renamefailed=0
+ ret = os.rename(src, dest)
+ renamefailed = 0
except Exception, e:
import errno
- if e[0]!=errno.EXDEV:
+ if e[0] != errno.EXDEV:
# Some random error.
print "movefile: Failed to move", src, "to", dest, e
return None
# Invalid cross-device-link 'bind' mounted or actually Cross-Device
if renamefailed:
- didcopy=0
+ didcopy = 0
if stat.S_ISREG(sstat[stat.ST_MODE]):
try: # For safety copy then move it over.
- shutil.copyfile(src,dest+"#new")
- os.rename(dest+"#new",dest)
- didcopy=1
+ shutil.copyfile(src, dest + "#new")
+ os.rename(dest + "#new", dest)
+ didcopy = 1
except Exception, e:
print 'movefile: copy', src, '->', dest, 'failed.', e
return None
else:
#we don't yet handle special, so we need to fall back to /bin/mv
- a=getstatusoutput("/bin/mv -f "+"'"+src+"' '"+dest+"'")
- if a[0]!=0:
+ a = getstatusoutput("/bin/mv -f " + "'" + src + "' '" + dest + "'")
+ if a[0] != 0:
print "movefile: Failed to move special file:" + src + "' to '" + dest + "'", a
return None # failure
try:
if didcopy:
- os.lchown(dest,sstat[stat.ST_UID],sstat[stat.ST_GID])
+ 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
os.unlink(src)
except Exception, e:
return None
if newmtime:
- os.utime(dest,(newmtime,newmtime))
+ os.utime(dest, (newmtime, newmtime))
else:
os.utime(dest, (sstat[stat.ST_ATIME], sstat[stat.ST_MTIME]))
- newmtime=sstat[stat.ST_MTIME]
+ newmtime = sstat[stat.ST_MTIME]
return newmtime
-def copyfile(src,dest,newmtime=None,sstat=None):
+def copyfile(src, dest, newmtime = None, sstat = None):
"""
Copies a file from src to dest, preserving all permissions and
attributes; mtime will be preserved even when moving across
filesystems. Returns true on success and false on failure.
"""
- #print "copyfile("+src+","+dest+","+str(newmtime)+","+str(sstat)+")"
+ #print "copyfile(" + src + "," + dest + "," + str(newmtime) + "," + str(sstat) + ")"
try:
if not sstat:
- sstat=os.lstat(src)
+ sstat = os.lstat(src)
except Exception, e:
print "copyfile: Stating source file failed...", e
return False
- destexists=1
+ destexists = 1
try:
- dstat=os.lstat(dest)
+ dstat = os.lstat(dest)
except:
- dstat=os.lstat(os.path.dirname(dest))
- destexists=0
+ dstat = os.lstat(os.path.dirname(dest))
+ destexists = 0
if destexists:
if stat.S_ISLNK(dstat[stat.ST_MODE]):
try:
os.unlink(dest)
- destexists=0
+ destexists = 0
except Exception, e:
pass
if stat.S_ISLNK(sstat[stat.ST_MODE]):
try:
- target=os.readlink(src)
+ target = os.readlink(src)
if destexists and not stat.S_ISDIR(dstat[stat.ST_MODE]):
os.unlink(dest)
- os.symlink(target,dest)
+ os.symlink(target, dest)
#os.lchown(dest,sstat[stat.ST_UID],sstat[stat.ST_GID])
return os.lstat(dest)
except Exception, e:
return False
if stat.S_ISREG(sstat[stat.ST_MODE]):
- try: # For safety copy then move it over.
- shutil.copyfile(src,dest+"#new")
- os.rename(dest+"#new",dest)
- except Exception, e:
- print 'copyfile: copy', src, '->', dest, 'failed.', e
- return False
+ try: # For safety copy then move it over.
+ shutil.copyfile(src, dest + "#new")
+ os.rename(dest + "#new", dest)
+ except Exception, e:
+ print 'copyfile: copy', src, '->', dest, 'failed.', e
+ return False
else:
- #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:
- print "copyfile: Failed to copy special file:" + src + "' to '" + dest + "'", a
- return False # failure
+ #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:
+ 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.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, e:
print "copyfile: Failed to chown/chmod/unlink", dest, e
return False
if newmtime:
- os.utime(dest,(newmtime,newmtime))
+ os.utime(dest, (newmtime, newmtime))
else:
os.utime(dest, (sstat[stat.ST_ATIME], sstat[stat.ST_MTIME]))
- newmtime=sstat[stat.ST_MTIME]
+ newmtime = sstat[stat.ST_MTIME]
return newmtime
def which(path, item, direction = 0):
