def setupBuild(self, expectations):
# create the actual BuildSteps. If there are any name collisions, we
# add a count to the loser until it is unique.
self.steps = []
self.stepStatuses = {}
sps = []
self.createSteps(sps)
# Create a buildbot.status.progress.BuildProgress object. This is
# called once at startup to figure out how to build the long-term
# Expectations object, and again at the start of each build to get a
# fresh BuildProgress object to track progress for that individual
# build. TODO: revisit at-startup call
if self.useProgress:
self.progress = BuildProgress(sps)
if self.progress and expectations:
self.progress.setExpectationsFrom(expectations)
# we are now ready to set up our BuildStatus.
# pass all sourcestamps to the buildstatus
self.build_status.setSourceStamps(self.sources)
self.build_status.setReason(self.reason)
self.builder.builder_status.reason = self.reason
self.build_status.setBlamelist(self.blamelist())
self.build_status.setProgress(self.progress)
if len(self.requests) > 0:
self.build_status.setSubmitted(self.requests[0].submittedAt)
self.setProperty("submittedTime", self.requests[0].submittedAt,
"buildrequest")
brids = [req.id for req in self.requests]
self.build_status.setBuildRequestIDs(brids)
self.setProperty("brids", brids, "buildrequest")
self.build_status.setBuildChainID(self.requests[0].buildChainID)
self.setProperty("buildChainID", self.requests[0].buildChainID,
"buildrequest")
# gather owners from build requests
owners = [
r.properties['owner'] for r in self.requests
if r.properties.has_key('owner')
]
if owners: self.setProperty('owners', owners, self.reason)
self.build_status.setOwners(owners)
self.results = [] # list of FAILURE, SUCCESS, WARNINGS, SKIPPED
self.result = SUCCESS # overall result, may downgrade after each step
self.text = [] # list of text string lists (text2)
def setupBuild(self, expectations):
# create the actual BuildSteps. If there are any name collisions, we
# add a count to the loser until it is unique.
self.steps = []
self.stepStatuses = {}
stepnames = {}
sps = []
for factory, args in self.stepFactories:
args = args.copy()
try:
step = factory(**args)
except:
log.msg("error while creating step, factory=%s, args=%s"
% (factory, args))
raise
step.setBuild(self)
step.setBuildSlave(self.slavebuilder.slave)
step.setDefaultWorkdir(self.workdir)
name = step.name
if stepnames.has_key(name):
count = stepnames[name]
count += 1
stepnames[name] = count
name = step.name + "_%d" % count
else:
stepnames[name] = 0
step.name = name
self.steps.append(step)
# tell the BuildStatus about the step. This will create a
# BuildStepStatus and bind it to the Step.
step_status = self.build_status.addStepWithName(name)
step.setStepStatus(step_status)
sp = None
if self.useProgress:
# XXX: maybe bail if step.progressMetrics is empty? or skip
# progress for that one step (i.e. "it is fast"), or have a
# separate "variable" flag that makes us bail on progress
# tracking
sp = step.setupProgress()
if sp:
sps.append(sp)
# Create a buildbot.status.progress.BuildProgress object. This is
# called once at startup to figure out how to build the long-term
# Expectations object, and again at the start of each build to get a
# fresh BuildProgress object to track progress for that individual
# build. TODO: revisit at-startup call
if self.useProgress:
self.progress = BuildProgress(sps)
if self.progress and expectations:
self.progress.setExpectationsFrom(expectations)
# we are now ready to set up our BuildStatus.
self.build_status.setSourceStamp(self.source)
self.build_status.setRequests([req.status for req in self.requests])
self.build_status.setReason(self.reason)
self.build_status.setBlamelist(self.blamelist())
self.build_status.setProgress(self.progress)
# gather owners from build requests
owners = [r.properties['owner'] for r in self.requests
if r.properties.has_key('owner')]
if owners: self.setProperty('owners', owners, self.reason)
self.results = [] # list of FAILURE, SUCCESS, WARNINGS, SKIPPED
self.result = SUCCESS # overall result, may downgrade after each step
self.text = [] # list of text string lists (text2)
class Build:
"""I represent a single build by a single slave. Specialized Builders can
use subclasses of Build to hold status information unique to those build
processes.
I control B{how} the build proceeds. The actual build is broken up into a
series of steps, saved in the .buildSteps[] array as a list of
L{buildbot.process.step.BuildStep} objects. Each step is a single remote
command, possibly a shell command.
During the build, I put status information into my C{BuildStatus}
gatherer.
After the build, I go away.
I can be used by a factory by setting buildClass on
L{buildbot.process.factory.BuildFactory}
@ivar requests: the list of L{BuildRequest}s that triggered me
@ivar build_status: the L{buildbot.status.builder.BuildStatus} that
collects our status
"""
implements(interfaces.IBuildControl)
workdir = "build"
build_status = None
reason = "changes"
finished = False
results = None
def __init__(self, requests):
self.requests = requests
for req in self.requests:
req.startCount += 1
self.locks = []
# build a source stamp
self.source = requests[0].mergeWith(requests[1:])
self.reason = requests[0].mergeReasons(requests[1:])
self.progress = None
self.currentStep = None
self.slaveEnvironment = {}
self.terminate = False
def setBuilder(self, builder):
"""
Set the given builder as our builder.
@type builder: L{buildbot.process.builder.Builder}
"""
self.builder = builder
def setLocks(self, locks):
self.locks = locks
def setSlaveEnvironment(self, env):
self.slaveEnvironment = env
def getSourceStamp(self):
return self.source
def setProperty(self, propname, value, source):
"""Set a property on this build. This may only be called after the
build has started, so that it has a BuildStatus object where the
properties can live."""
self.build_status.setProperty(propname, value, source)
def getProperties(self):
return self.build_status.getProperties()
def getProperty(self, propname):
return self.build_status.getProperty(propname)
def allChanges(self):
return self.source.changes
def allFiles(self):
# return a list of all source files that were changed
files = []
havedirs = 0
for c in self.allChanges():
for f in c.files:
files.append(f)
if c.isdir:
havedirs = 1
return files
def __repr__(self):
return "<Build %s>" % (self.builder.name,)
def __getstate__(self):
d = self.__dict__.copy()
if d.has_key('remote'):
del d['remote']
return d
def blamelist(self):
blamelist = []
for c in self.allChanges():
if c.who not in blamelist:
blamelist.append(c.who)
blamelist.sort()
return blamelist
def changesText(self):
changetext = ""
for c in self.allChanges():
changetext += "-" * 60 + "\n\n" + c.asText() + "\n"
# consider sorting these by number
return changetext
def setStepFactories(self, step_factories):
"""Set a list of 'step factories', which are tuples of (class,
kwargs), where 'class' is generally a subclass of step.BuildStep .
These are used to create the Steps themselves when the Build starts
(as opposed to when it is first created). By creating the steps
later, their __init__ method will have access to things like
build.allFiles() ."""
self.stepFactories = list(step_factories)
useProgress = True
def getSlaveCommandVersion(self, command, oldversion=None):
return self.slavebuilder.getSlaveCommandVersion(command, oldversion)
def getSlaveName(self):
return self.slavebuilder.slave.slavename
def setupProperties(self):
props = self.getProperties()
# start with global properties from the configuration
buildmaster = self.builder.botmaster.parent
props.updateFromProperties(buildmaster.properties)
# get any properties from requests (this is the path through
# which schedulers will send us properties)
for rq in self.requests:
props.updateFromProperties(rq.properties)
# and finally, from the SourceStamp, which has properties via Change
for change in self.source.changes:
props.updateFromProperties(change.properties)
# now set some properties of our own, corresponding to the
# build itself
props.setProperty("buildername", self.builder.name, "Build")
props.setProperty("buildnumber", self.build_status.number, "Build")
props.setProperty("branch", self.source.branch, "Build")
props.setProperty("revision", self.source.revision, "Build")
def setupSlaveBuilder(self, slavebuilder):
self.slavebuilder = slavebuilder
# navigate our way back to the L{buildbot.buildslave.BuildSlave}
# object that came from the config, and get its properties
buildslave_properties = slavebuilder.slave.properties
self.getProperties().updateFromProperties(buildslave_properties)
self.slavename = slavebuilder.slave.slavename
self.build_status.setSlavename(self.slavename)
def startBuild(self, build_status, expectations, slavebuilder):
"""This method sets up the build, then starts it by invoking the
first Step. It returns a Deferred which will fire when the build
finishes. This Deferred is guaranteed to never errback."""
# we are taking responsibility for watching the connection to the
# remote. This responsibility was held by the Builder until our
# startBuild was called, and will not return to them until we fire
# the Deferred returned by this method.
log.msg("%s.startBuild" % self)
self.build_status = build_status
# now that we have a build_status, we can set properties
self.setupProperties()
self.setupSlaveBuilder(slavebuilder)
slavebuilder.slave.updateSlaveStatus(buildStarted=build_status)
# convert all locks into their real forms
lock_list = []
for access in self.locks:
if not isinstance(access, locks.LockAccess):
# Buildbot 0.7.7 compability: user did not specify access
access = access.defaultAccess()
lock = self.builder.botmaster.getLockByID(access.lockid)
lock_list.append((lock, access))
self.locks = lock_list
# then narrow SlaveLocks down to the right slave
self.locks = [(l.getLock(self.slavebuilder), la)
for l, la in self.locks]
self.remote = slavebuilder.remote
self.remote.notifyOnDisconnect(self.lostRemote)
d = self.deferred = defer.Deferred()
def _release_slave(res, slave, bs):
self.slavebuilder.buildFinished()
slave.updateSlaveStatus(buildFinished=bs)
return res
d.addCallback(_release_slave, self.slavebuilder.slave, build_status)
try:
self.setupBuild(expectations) # create .steps
except:
# the build hasn't started yet, so log the exception as a point
# event instead of flunking the build. TODO: associate this
# failure with the build instead. this involves doing
# self.build_status.buildStarted() from within the exception
# handler
log.msg("Build.setupBuild failed")
log.err(Failure())
self.builder.builder_status.addPointEvent(["setupBuild",
"exception"])
self.finished = True
self.results = FAILURE
self.deferred = None
d.callback(self)
return d
self.acquireLocks().addCallback(self._startBuild_2)
return d
def acquireLocks(self, res=None):
log.msg("acquireLocks(step %s, locks %s)" % (self, self.locks))
if not self.locks:
return defer.succeed(None)
for lock, access in self.locks:
if not lock.isAvailable(access):
log.msg("Build %s waiting for lock %s" % (self, lock))
d = lock.waitUntilMaybeAvailable(self, access)
d.addCallback(self.acquireLocks)
return d
# all locks are available, claim them all
for lock, access in self.locks:
lock.claim(self, access)
return defer.succeed(None)
def _startBuild_2(self, res):
self.build_status.buildStarted(self)
self.startNextStep()
def setupBuild(self, expectations):
# create the actual BuildSteps. If there are any name collisions, we
# add a count to the loser until it is unique.
self.steps = []
self.stepStatuses = {}
stepnames = {}
sps = []
for factory, args in self.stepFactories:
args = args.copy()
try:
step = factory(**args)
except:
log.msg("error while creating step, factory=%s, args=%s"
% (factory, args))
raise
step.setBuild(self)
step.setBuildSlave(self.slavebuilder.slave)
step.setDefaultWorkdir(self.workdir)
name = step.name
if stepnames.has_key(name):
count = stepnames[name]
count += 1
stepnames[name] = count
name = step.name + "_%d" % count
else:
stepnames[name] = 0
step.name = name
self.steps.append(step)
# tell the BuildStatus about the step. This will create a
# BuildStepStatus and bind it to the Step.
step_status = self.build_status.addStepWithName(name)
step.setStepStatus(step_status)
sp = None
if self.useProgress:
# XXX: maybe bail if step.progressMetrics is empty? or skip
# progress for that one step (i.e. "it is fast"), or have a
# separate "variable" flag that makes us bail on progress
# tracking
sp = step.setupProgress()
if sp:
sps.append(sp)
# Create a buildbot.status.progress.BuildProgress object. This is
# called once at startup to figure out how to build the long-term
# Expectations object, and again at the start of each build to get a
# fresh BuildProgress object to track progress for that individual
# build. TODO: revisit at-startup call
if self.useProgress:
self.progress = BuildProgress(sps)
if self.progress and expectations:
self.progress.setExpectationsFrom(expectations)
# we are now ready to set up our BuildStatus.
self.build_status.setSourceStamp(self.source)
self.build_status.setRequests([req.status for req in self.requests])
self.build_status.setReason(self.reason)
self.build_status.setBlamelist(self.blamelist())
self.build_status.setProgress(self.progress)
# gather owners from build requests
owners = [r.properties['owner'] for r in self.requests
if r.properties.has_key('owner')]
if owners: self.setProperty('owners', owners, self.reason)
self.results = [] # list of FAILURE, SUCCESS, WARNINGS, SKIPPED
self.result = SUCCESS # overall result, may downgrade after each step
self.text = [] # list of text string lists (text2)
def getNextStep(self):
"""This method is called to obtain the next BuildStep for this build.
When it returns None (or raises a StopIteration exception), the build
is complete."""
if not self.steps:
return None
if self.terminate:
while True:
s = self.steps.pop(0)
if s.alwaysRun:
return s
if not self.steps:
return None
else:
return self.steps.pop(0)
def startNextStep(self):
try:
s = self.getNextStep()
except StopIteration:
s = None
if not s:
return self.allStepsDone()
self.currentStep = s
d = defer.maybeDeferred(s.startStep, self.remote)
d.addCallback(self._stepDone, s)
d.addErrback(self.buildException)
def _stepDone(self, results, step):
self.currentStep = None
if self.finished:
return # build was interrupted, don't keep building
terminate = self.stepDone(results, step) # interpret/merge results
if terminate:
self.terminate = True
return self.startNextStep()
def stepDone(self, result, step):
"""This method is called when the BuildStep completes. It is passed a
status object from the BuildStep and is responsible for merging the
Step's results into those of the overall Build."""
terminate = False
text = None
if type(result) == types.TupleType:
result, text = result
assert type(result) == type(SUCCESS)
log.msg(" step '%s' complete: %s" % (step.name, Results[result]))
self.results.append(result)
if text:
self.text.extend(text)
if not self.remote:
terminate = True
if result == FAILURE:
if step.warnOnFailure:
if self.result != FAILURE:
self.result = WARNINGS
if step.flunkOnFailure:
self.result = FAILURE
if step.haltOnFailure:
terminate = True
elif result == WARNINGS:
if step.warnOnWarnings:
if self.result != FAILURE:
self.result = WARNINGS
if step.flunkOnWarnings:
self.result = FAILURE
elif result == EXCEPTION:
self.result = EXCEPTION
terminate = True
return terminate
def lostRemote(self, remote=None):
# the slave went away. There are several possible reasons for this,
# and they aren't necessarily fatal. For now, kill the build, but
# TODO: see if we can resume the build when it reconnects.
log.msg("%s.lostRemote" % self)
self.remote = None
if self.currentStep:
# this should cause the step to finish.
log.msg(" stopping currentStep", self.currentStep)
self.currentStep.interrupt(Failure(error.ConnectionLost()))
def stopBuild(self, reason="<no reason given>"):
# the idea here is to let the user cancel a build because, e.g.,
# they realized they committed a bug and they don't want to waste
# the time building something that they know will fail. Another
# reason might be to abandon a stuck build. We want to mark the
# build as failed quickly rather than waiting for the slave's
# timeout to kill it on its own.
log.msg(" %s: stopping build: %s" % (self, reason))
if self.finished:
return
# TODO: include 'reason' in this point event
self.builder.builder_status.addPointEvent(['interrupt'])
self.currentStep.interrupt(reason)
if 0:
# TODO: maybe let its deferred do buildFinished
if self.currentStep and self.currentStep.progress:
# XXX: really .fail or something
self.currentStep.progress.finish()
text = ["stopped", reason]
self.buildFinished(text, FAILURE)
def allStepsDone(self):
if self.result == FAILURE:
text = ["failed"]
elif self.result == WARNINGS:
text = ["warnings"]
elif self.result == EXCEPTION:
text = ["exception"]
else:
text = ["build", "successful"]
text.extend(self.text)
return self.buildFinished(text, self.result)
def buildException(self, why):
log.msg("%s.buildException" % self)
log.err(why)
self.buildFinished(["build", "exception"], FAILURE)
def buildFinished(self, text, results):
"""This method must be called when the last Step has completed. It
marks the Build as complete and returns the Builder to the 'idle'
state.
It takes two arguments which describe the overall build status:
text, results. 'results' is one of SUCCESS, WARNINGS, or FAILURE.
If 'results' is SUCCESS or WARNINGS, we will permit any dependant
builds to start. If it is 'FAILURE', those builds will be
abandoned."""
self.finished = True
if self.remote:
self.remote.dontNotifyOnDisconnect(self.lostRemote)
self.results = results
log.msg(" %s: build finished" % self)
self.build_status.setText(text)
self.build_status.setResults(results)
self.build_status.buildFinished()
if self.progress and results == SUCCESS:
# XXX: also test a 'timing consistent' flag?
log.msg(" setting expectations for next time")
self.builder.setExpectations(self.progress)
reactor.callLater(0, self.releaseLocks)
self.deferred.callback(self)
self.deferred = None
def releaseLocks(self):
log.msg("releaseLocks(%s): %s" % (self, self.locks))
for lock, access in self.locks:
lock.release(self, access)
# IBuildControl
def getStatus(self):
return self.build_status
class Build:
"""I represent a single build by a single slave. Specialized Builders can
use subclasses of Build to hold status information unique to those build
processes.
I control B{how} the build proceeds. The actual build is broken up into a
series of steps, saved in the .buildSteps[] array as a list of
L{buildbot.process.step.BuildStep} objects. Each step is a single remote
command, possibly a shell command.
During the build, I put status information into my C{BuildStatus}
gatherer.
After the build, I go away.
I can be used by a factory by setting buildClass on
L{buildbot.process.factory.BuildFactory}
@ivar requests: the list of L{BuildRequest}s that triggered me
@ivar build_status: the L{buildbot.status.build.BuildStatus} that
collects our status
"""
implements(interfaces.IBuildControl)
workdir = "build"
build_status = None
reason = "changes"
finished = False
results = None
stopped = False
def __init__(self, requests):
self.requests = requests
self.locks = []
# build a source stamp
self.source = requests[0].mergeWith(requests[1:])
self.reason = requests[0].mergeReasons(requests[1:])
self.progress = None
self.currentStep = None
self.slaveEnvironment = {}
self.terminate = False
self._acquiringLock = None
def setBuilder(self, builder):
"""
Set the given builder as our builder.
@type builder: L{buildbot.process.builder.Builder}
"""
self.builder = builder
def setLocks(self, locks):
self.locks = locks
def setSlaveEnvironment(self, env):
self.slaveEnvironment = env
def getSourceStamp(self):
return self.source
def setProperty(self, propname, value, source, runtime=True):
"""Set a property on this build. This may only be called after the
build has started, so that it has a BuildStatus object where the
properties can live."""
self.build_status.setProperty(propname, value, source, runtime=True)
def getProperties(self):
return self.build_status.getProperties()
def getProperty(self, propname):
return self.build_status.getProperty(propname)
def render(self, value):
"""
Return a variant of value that has any WithProperties objects
substituted. This recurses into Python's compound data types.
"""
return interfaces.IRenderable(value).getRenderingFor(self)
def allChanges(self):
return self.source.changes
def allFiles(self):
# return a list of all source files that were changed
files = []
for c in self.allChanges():
for f in c.files:
files.append(f)
return files
def __repr__(self):
return "<Build %s>" % (self.builder.name, )
def blamelist(self):
blamelist = []
for c in self.allChanges():
if c.who not in blamelist:
blamelist.append(c.who)
blamelist.sort()
return blamelist
def changesText(self):
changetext = ""
for c in self.allChanges():
changetext += "-" * 60 + "\n\n" + c.asText() + "\n"
# consider sorting these by number
return changetext
def setStepFactories(self, step_factories):
"""Set a list of 'step factories', which are tuples of (class,
kwargs), where 'class' is generally a subclass of step.BuildStep .
These are used to create the Steps themselves when the Build starts
(as opposed to when it is first created). By creating the steps
later, their __init__ method will have access to things like
build.allFiles() ."""
self.stepFactories = list(step_factories)
useProgress = True
def getSlaveCommandVersion(self, command, oldversion=None):
return self.slavebuilder.getSlaveCommandVersion(command, oldversion)
def getSlaveName(self):
return self.slavebuilder.slave.slavename
def setupProperties(self):
props = self.getProperties()
# start with global properties from the configuration
buildmaster = self.builder.botmaster.parent
props.updateFromProperties(buildmaster.properties)
# from the SourceStamp, which has properties via Change
for change in self.source.changes:
props.updateFromProperties(change.properties)
# and finally, get any properties from requests (this is the path
# through which schedulers will send us properties)
for rq in self.requests:
props.updateFromProperties(rq.properties)
# now set some properties of our own, corresponding to the
# build itself
props.setProperty("buildnumber", self.build_status.number, "Build")
props.setProperty("branch", self.source.branch, "Build")
props.setProperty("revision", self.source.revision, "Build")
props.setProperty("repository", self.source.repository, "Build")
props.setProperty("project", self.source.project, "Build")
self.builder.setupProperties(props)
def setupSlaveBuilder(self, slavebuilder):
self.slavebuilder = slavebuilder
# navigate our way back to the L{buildbot.buildslave.BuildSlave}
# object that came from the config, and get its properties
buildslave_properties = slavebuilder.slave.properties
self.getProperties().updateFromProperties(buildslave_properties)
if slavebuilder.slave.slave_basedir:
self.setProperty(
"workdir",
slavebuilder.slave.path_module.join(
slavebuilder.slave.slave_basedir,
self.builder.slavebuilddir), "slave")
self.slavename = slavebuilder.slave.slavename
self.build_status.setSlavename(self.slavename)
def startBuild(self, build_status, expectations, slavebuilder):
"""This method sets up the build, then starts it by invoking the
first Step. It returns a Deferred which will fire when the build
finishes. This Deferred is guaranteed to never errback."""
# we are taking responsibility for watching the connection to the
# remote. This responsibility was held by the Builder until our
# startBuild was called, and will not return to them until we fire
# the Deferred returned by this method.
log.msg("%s.startBuild" % self)
self.build_status = build_status
# now that we have a build_status, we can set properties
self.setupProperties()
self.setupSlaveBuilder(slavebuilder)
slavebuilder.slave.updateSlaveStatus(buildStarted=build_status)
# convert all locks into their real forms
lock_list = []
for access in self.locks:
if not isinstance(access, locks.LockAccess):
# Buildbot 0.7.7 compability: user did not specify access
access = access.defaultAccess()
lock = self.builder.botmaster.getLockByID(access.lockid)
lock_list.append((lock, access))
self.locks = lock_list
# then narrow SlaveLocks down to the right slave
self.locks = [(l.getLock(self.slavebuilder), la)
for l, la in self.locks]
self.remote = slavebuilder.remote
self.remote.notifyOnDisconnect(self.lostRemote)
metrics.MetricCountEvent.log('active_builds', 1)
d = self.deferred = defer.Deferred()
def _uncount_build(res):
metrics.MetricCountEvent.log('active_builds', -1)
return res
d.addBoth(_uncount_build)
def _release_slave(res, slave, bs):
self.slavebuilder.buildFinished()
slave.updateSlaveStatus(buildFinished=bs)
return res
d.addCallback(_release_slave, self.slavebuilder.slave, build_status)
try:
self.setupBuild(expectations) # create .steps
except:
# the build hasn't started yet, so log the exception as a point
# event instead of flunking the build.
# TODO: associate this failure with the build instead.
# this involves doing
# self.build_status.buildStarted() from within the exception
# handler
log.msg("Build.setupBuild failed")
log.err(Failure())
self.builder.builder_status.addPointEvent(
["setupBuild", "exception"])
self.finished = True
self.results = FAILURE
self.deferred = None
d.callback(self)
return d
self.build_status.buildStarted(self)
self.acquireLocks().addCallback(self._startBuild_2)
return d
def acquireLocks(self, res=None):
self._acquiringLock = None
if not self.locks:
return defer.succeed(None)
if self.stopped:
return defer.succeed(None)
log.msg("acquireLocks(build %s, locks %s)" % (self, self.locks))
for lock, access in self.locks:
if not lock.isAvailable(access):
log.msg("Build %s waiting for lock %s" % (self, lock))
d = lock.waitUntilMaybeAvailable(self, access)
d.addCallback(self.acquireLocks)
self._acquiringLock = (lock, access, d)
return d
# all locks are available, claim them all
for lock, access in self.locks:
lock.claim(self, access)
return defer.succeed(None)
def _startBuild_2(self, res):
self.startNextStep()
def setupBuild(self, expectations):
# create the actual BuildSteps. If there are any name collisions, we
# add a count to the loser until it is unique.
self.steps = []
self.stepStatuses = {}
stepnames = {}
sps = []
for factory, args in self.stepFactories:
args = args.copy()
try:
step = factory(**args)
except:
log.msg("error while creating step, factory=%s, args=%s" %
(factory, args))
raise
step.setBuild(self)
step.setBuildSlave(self.slavebuilder.slave)
if callable(self.workdir):
step.setDefaultWorkdir(self.workdir(self.source))
else:
step.setDefaultWorkdir(self.workdir)
name = step.name
if stepnames.has_key(name):
count = stepnames[name]
count += 1
stepnames[name] = count
name = step.name + "_%d" % count
else:
stepnames[name] = 0
step.name = name
self.steps.append(step)
# tell the BuildStatus about the step. This will create a
# BuildStepStatus and bind it to the Step.
step_status = self.build_status.addStepWithName(name)
step.setStepStatus(step_status)
sp = None
if self.useProgress:
# XXX: maybe bail if step.progressMetrics is empty? or skip
# progress for that one step (i.e. "it is fast"), or have a
# separate "variable" flag that makes us bail on progress
# tracking
sp = step.setupProgress()
if sp:
sps.append(sp)
# Create a buildbot.status.progress.BuildProgress object. This is
# called once at startup to figure out how to build the long-term
# Expectations object, and again at the start of each build to get a
# fresh BuildProgress object to track progress for that individual
# build. TODO: revisit at-startup call
if self.useProgress:
self.progress = BuildProgress(sps)
if self.progress and expectations:
self.progress.setExpectationsFrom(expectations)
# we are now ready to set up our BuildStatus.
self.build_status.setSourceStamp(self.source)
self.build_status.setReason(self.reason)
self.build_status.setBlamelist(self.blamelist())
self.build_status.setProgress(self.progress)
# gather owners from build requests
owners = [
r.properties['owner'] for r in self.requests
if r.properties.has_key('owner')
]
if owners: self.setProperty('owners', owners, self.reason)
self.results = [] # list of FAILURE, SUCCESS, WARNINGS, SKIPPED
self.result = SUCCESS # overall result, may downgrade after each step
self.text = [] # list of text string lists (text2)
def getNextStep(self):
"""This method is called to obtain the next BuildStep for this build.
When it returns None (or raises a StopIteration exception), the build
is complete."""
if not self.steps:
return None
if not self.remote:
return None
if self.terminate or self.stopped:
# Run any remaining alwaysRun steps, and skip over the others
while True:
s = self.steps.pop(0)
if s.alwaysRun:
return s
if not self.steps:
return None
else:
return self.steps.pop(0)
def startNextStep(self):
try:
s = self.getNextStep()
except StopIteration:
s = None
if not s:
return self.allStepsDone()
self.currentStep = s
d = defer.maybeDeferred(s.startStep, self.remote)
d.addCallback(self._stepDone, s)
d.addErrback(self.buildException)
def _stepDone(self, results, step):
self.currentStep = None
if self.finished:
return # build was interrupted, don't keep building
terminate = self.stepDone(results, step) # interpret/merge results
if terminate:
self.terminate = True
return self.startNextStep()
def stepDone(self, result, step):
"""This method is called when the BuildStep completes. It is passed a
status object from the BuildStep and is responsible for merging the
Step's results into those of the overall Build."""
terminate = False
text = None
if type(result) == types.TupleType:
result, text = result
assert type(result) == type(SUCCESS)
log.msg(" step '%s' complete: %s" % (step.name, Results[result]))
self.results.append(result)
if text:
self.text.extend(text)
if not self.remote:
terminate = True
possible_overall_result = result
if result == FAILURE:
if not step.flunkOnFailure:
possible_overall_result = SUCCESS
if step.warnOnFailure:
possible_overall_result = WARNINGS
if step.flunkOnFailure:
possible_overall_result = FAILURE
if step.haltOnFailure:
terminate = True
elif result == WARNINGS:
if not step.warnOnWarnings:
possible_overall_result = SUCCESS
else:
possible_overall_result = WARNINGS
if step.flunkOnWarnings:
possible_overall_result = FAILURE
elif result in (EXCEPTION, RETRY):
terminate = True
# if we skipped this step, then don't adjust the build status
if result != SKIPPED:
self.result = worst_status(self.result, possible_overall_result)
return terminate
def lostRemote(self, remote=None):
# the slave went away. There are several possible reasons for this,
# and they aren't necessarily fatal. For now, kill the build, but
# TODO: see if we can resume the build when it reconnects.
log.msg("%s.lostRemote" % self)
self.remote = None
if self.currentStep:
# this should cause the step to finish.
log.msg(" stopping currentStep", self.currentStep)
self.currentStep.interrupt(Failure(error.ConnectionLost()))
def stopBuild(self, reason="<no reason given>"):
# the idea here is to let the user cancel a build because, e.g.,
# they realized they committed a bug and they don't want to waste
# the time building something that they know will fail. Another
# reason might be to abandon a stuck build. We want to mark the
# build as failed quickly rather than waiting for the slave's
# timeout to kill it on its own.
log.msg(" %s: stopping build: %s" % (self, reason))
if self.finished:
return
# TODO: include 'reason' in this point event
self.builder.builder_status.addPointEvent(['interrupt'])
self.stopped = True
if self.currentStep:
self.currentStep.interrupt(reason)
self.result = EXCEPTION
if self._acquiringLock:
lock, access, d = self._acquiringLock
lock.stopWaitingUntilAvailable(self, access, d)
d.callback(None)
def allStepsDone(self):
if self.result == FAILURE:
text = ["failed"]
elif self.result == WARNINGS:
text = ["warnings"]
elif self.result == EXCEPTION:
text = ["exception"]
else:
text = ["build", "successful"]
text.extend(self.text)
return self.buildFinished(text, self.result)
def buildException(self, why):
log.msg("%s.buildException" % self)
log.err(why)
self.buildFinished(["build", "exception"], EXCEPTION)
def buildFinished(self, text, results):
"""This method must be called when the last Step has completed. It
marks the Build as complete and returns the Builder to the 'idle'
state.
It takes two arguments which describe the overall build status:
text, results. 'results' is one of SUCCESS, WARNINGS, or FAILURE.
If 'results' is SUCCESS or WARNINGS, we will permit any dependant
builds to start. If it is 'FAILURE', those builds will be
abandoned."""
self.finished = True
if self.remote:
self.remote.dontNotifyOnDisconnect(self.lostRemote)
self.results = results
log.msg(" %s: build finished" % self)
self.build_status.setText(text)
self.build_status.setResults(results)
self.build_status.buildFinished()
if self.progress and results == SUCCESS:
# XXX: also test a 'timing consistent' flag?
log.msg(" setting expectations for next time")
self.builder.setExpectations(self.progress)
reactor.callLater(0, self.releaseLocks)
self.deferred.callback(self)
self.deferred = None
def releaseLocks(self):
if self.locks:
log.msg("releaseLocks(%s): %s" % (self, self.locks))
for lock, access in self.locks:
if lock.isOwner(self, access):
lock.release(self, access)
else:
# This should only happen if we've been interrupted
assert self.stopped
# IBuildControl
def getStatus(self):
return self.build_status
def setupBuild(self, expectations):
# create the actual BuildSteps. If there are any name collisions, we
# add a count to the loser until it is unique.
self.steps = []
self.stepStatuses = {}
stepnames = {}
sps = []
for factory, args in self.stepFactories:
args = args.copy()
try:
step = factory(**args)
except:
log.msg("error while creating step, factory=%s, args=%s" %
(factory, args))
raise
step.setBuild(self)
step.setBuildSlave(self.slavebuilder.slave)
if callable(self.workdir):
step.setDefaultWorkdir(self.workdir(self.source))
else:
step.setDefaultWorkdir(self.workdir)
name = step.name
if stepnames.has_key(name):
count = stepnames[name]
count += 1
stepnames[name] = count
name = step.name + "_%d" % count
else:
stepnames[name] = 0
step.name = name
self.steps.append(step)
# tell the BuildStatus about the step. This will create a
# BuildStepStatus and bind it to the Step.
step_status = self.build_status.addStepWithName(name)
step.setStepStatus(step_status)
sp = None
if self.useProgress:
# XXX: maybe bail if step.progressMetrics is empty? or skip
# progress for that one step (i.e. "it is fast"), or have a
# separate "variable" flag that makes us bail on progress
# tracking
sp = step.setupProgress()
if sp:
sps.append(sp)
# Create a buildbot.status.progress.BuildProgress object. This is
# called once at startup to figure out how to build the long-term
# Expectations object, and again at the start of each build to get a
# fresh BuildProgress object to track progress for that individual
# build. TODO: revisit at-startup call
if self.useProgress:
self.progress = BuildProgress(sps)
if self.progress and expectations:
self.progress.setExpectationsFrom(expectations)
# we are now ready to set up our BuildStatus.
self.build_status.setSourceStamp(self.source)
self.build_status.setReason(self.reason)
self.build_status.setBlamelist(self.blamelist())
self.build_status.setProgress(self.progress)
# gather owners from build requests
owners = [
r.properties['owner'] for r in self.requests
if r.properties.has_key('owner')
]
if owners: self.setProperty('owners', owners, self.reason)
self.results = [] # list of FAILURE, SUCCESS, WARNINGS, SKIPPED
self.result = SUCCESS # overall result, may downgrade after each step
self.text = [] # list of text string lists (text2)
class Build:
"""I represent a single build by a single slave. Specialized Builders can
use subclasses of Build to hold status information unique to those build
processes.
I control B{how} the build proceeds. The actual build is broken up into a
series of steps, saved in the .buildSteps[] array as a list of
L{buildbot.process.step.BuildStep} objects. Each step is a single remote
command, possibly a shell command.
During the build, I put status information into my C{BuildStatus}
gatherer.
After the build, I go away.
I can be used by a factory by setting buildClass on
L{buildbot.process.factory.BuildFactory}
@ivar requests: the list of L{BuildRequest}s that triggered me
@ivar build_status: the L{buildbot.status.builder.BuildStatus} that
collects our status
"""
implements(interfaces.IBuildControl)
workdir = "build"
build_status = None
reason = "changes"
finished = False
results = None
def __init__(self, requests):
self.requests = requests
for req in self.requests:
req.startCount += 1
self.locks = []
# build a source stamp
self.source = requests[0].mergeWith(requests[1:])
self.reason = requests[0].mergeReasons(requests[1:])
#self.abandoned = False
self.progress = None
self.currentStep = None
self.slaveEnvironment = {}
def setBuilder(self, builder):
"""
Set the given builder as our builder.
@type builder: L{buildbot.process.builder.Builder}
"""
self.builder = builder
def setLocks(self, locks):
self.locks = locks
def getSourceStamp(self):
return self.source
def setProperty(self, propname, value):
"""Set a property on this build. This may only be called after the
build has started, so that it has a BuildStatus object where the
properties can live."""
self.build_status.setProperty(propname, value)
def getProperty(self, propname):
return self.build_status.properties[propname]
def allChanges(self):
return self.source.changes
def allFiles(self):
# return a list of all source files that were changed
files = []
havedirs = 0
for c in self.allChanges():
for f in c.files:
files.append(f)
if c.isdir:
havedirs = 1
return files
def __repr__(self):
return "<Build %s>" % (self.builder.name,)
def __getstate__(self):
d = self.__dict__.copy()
if d.has_key('remote'):
del d['remote']
return d
def blamelist(self):
blamelist = []
for c in self.allChanges():
if c.who not in blamelist:
blamelist.append(c.who)
blamelist.sort()
return blamelist
def changesText(self):
changetext = ""
for c in self.allChanges():
changetext += "-" * 60 + "\n\n" + c.asText() + "\n"
# consider sorting these by number
return changetext
def setStepFactories(self, step_factories):
"""Set a list of 'step factories', which are tuples of (class,
kwargs), where 'class' is generally a subclass of step.BuildStep .
These are used to create the Steps themselves when the Build starts
(as opposed to when it is first created). By creating the steps
later, their __init__ method will have access to things like
build.allFiles() ."""
self.stepFactories = list(step_factories)
useProgress = True
def getSlaveCommandVersion(self, command, oldversion=None):
return self.slavebuilder.getSlaveCommandVersion(command, oldversion)
def getSlaveName(self):
return self.slavebuilder.slave.slavename
def setupStatus(self, build_status):
self.build_status = build_status
self.setProperty("buildername", self.builder.name)
self.setProperty("buildnumber", self.build_status.number)
self.setProperty("branch", self.source.branch)
self.setProperty("revision", self.source.revision)
def setupSlaveBuilder(self, slavebuilder):
self.slavebuilder = slavebuilder
self.slavename = slavebuilder.slave.slavename
self.build_status.setSlavename(self.slavename)
self.setProperty("slavename", self.slavename)
def startBuild(self, build_status, expectations, slavebuilder):
"""This method sets up the build, then starts it by invoking the
first Step. It returns a Deferred which will fire when the build
finishes. This Deferred is guaranteed to never errback."""
# we are taking responsibility for watching the connection to the
# remote. This responsibility was held by the Builder until our
# startBuild was called, and will not return to them until we fire
# the Deferred returned by this method.
log.msg("%s.startBuild" % self)
self.setupStatus(build_status)
# now that we have a build_status, we can set properties
self.setupSlaveBuilder(slavebuilder)
# convert all locks into their real forms
self.locks = [self.builder.botmaster.getLockByID(l)
for l in self.locks]
# then narrow SlaveLocks down to the right slave
self.locks = [l.getLock(self.slavebuilder) for l in self.locks]
self.remote = slavebuilder.remote
self.remote.notifyOnDisconnect(self.lostRemote)
d = self.deferred = defer.Deferred()
def _release_slave(res):
self.slavebuilder.buildFinished()
return res
d.addCallback(_release_slave)
try:
self.setupBuild(expectations) # create .steps
except:
# the build hasn't started yet, so log the exception as a point
# event instead of flunking the build. TODO: associate this
# failure with the build instead. this involves doing
# self.build_status.buildStarted() from within the exception
# handler
log.msg("Build.setupBuild failed")
log.err(Failure())
self.builder.builder_status.addPointEvent(["setupBuild",
"exception"],
color="purple")
self.finished = True
self.results = FAILURE
self.deferred = None
d.callback(self)
return d
self.build_status.buildStarted(self)
self.acquireLocks().addCallback(self._startBuild_2)
return d
def acquireLocks(self, res=None):
log.msg("acquireLocks(step %s, locks %s)" % (self, self.locks))
if not self.locks:
return defer.succeed(None)
for lock in self.locks:
if not lock.isAvailable():
log.msg("Build %s waiting for lock %s" % (self, lock))
d = lock.waitUntilMaybeAvailable(self)
d.addCallback(self.acquireLocks)
return d
# all locks are available, claim them all
for lock in self.locks:
lock.claim(self)
return defer.succeed(None)
def _startBuild_2(self, res):
self.startNextStep()
def setupBuild(self, expectations):
# create the actual BuildSteps. If there are any name collisions, we
# add a count to the loser until it is unique.
self.steps = []
self.stepStatuses = {}
stepnames = []
sps = []
for factory, args in self.stepFactories:
args = args.copy()
try:
step = factory(**args)
except:
log.msg("error while creating step, factory=%s, args=%s"
% (factory, args))
raise
step.setBuild(self)
step.setBuildSlave(self.slavebuilder.slave)
step.setDefaultWorkdir(self.workdir)
name = step.name
count = 1
while name in stepnames and count < 100:
count += 1
name = step.name + "_%d" % count
if name in stepnames:
raise RuntimeError("duplicate step '%s'" % step.name)
step.name = name
stepnames.append(name)
self.steps.append(step)
# tell the BuildStatus about the step. This will create a
# BuildStepStatus and bind it to the Step.
step_status = self.build_status.addStepWithName(name)
step.setStepStatus(step_status)
sp = None
if self.useProgress:
# XXX: maybe bail if step.progressMetrics is empty? or skip
# progress for that one step (i.e. "it is fast"), or have a
# separate "variable" flag that makes us bail on progress
# tracking
sp = step.setupProgress()
if sp:
sps.append(sp)
# Create a buildbot.status.progress.BuildProgress object. This is
# called once at startup to figure out how to build the long-term
# Expectations object, and again at the start of each build to get a
# fresh BuildProgress object to track progress for that individual
# build. TODO: revisit at-startup call
if self.useProgress:
self.progress = BuildProgress(sps)
if self.progress and expectations:
self.progress.setExpectationsFrom(expectations)
# we are now ready to set up our BuildStatus.
self.build_status.setSourceStamp(self.source)
self.build_status.setReason(self.reason)
self.build_status.setBlamelist(self.blamelist())
self.build_status.setProgress(self.progress)
self.results = [] # list of FAILURE, SUCCESS, WARNINGS, SKIPPED
self.result = SUCCESS # overall result, may downgrade after each step
self.text = [] # list of text string lists (text2)
def getNextStep(self):
"""This method is called to obtain the next BuildStep for this build.
When it returns None (or raises a StopIteration exception), the build
is complete."""
if not self.steps:
return None
return self.steps.pop(0)
def startNextStep(self):
try:
s = self.getNextStep()
except StopIteration:
s = None
if not s:
return self.allStepsDone()
self.currentStep = s
d = defer.maybeDeferred(s.startStep, self.remote)
d.addCallback(self._stepDone, s)
d.addErrback(self.buildException)
def _stepDone(self, results, step):
self.currentStep = None
if self.finished:
return # build was interrupted, don't keep building
terminate = self.stepDone(results, step) # interpret/merge results
if terminate:
return self.allStepsDone()
self.startNextStep()
def stepDone(self, result, step):
"""This method is called when the BuildStep completes. It is passed a
status object from the BuildStep and is responsible for merging the
Step's results into those of the overall Build."""
terminate = False
text = None
if type(result) == types.TupleType:
result, text = result
assert type(result) == type(SUCCESS)
log.msg(" step '%s' complete: %s" % (step.name, Results[result]))
self.results.append(result)
if text:
self.text.extend(text)
if not self.remote:
terminate = True
if result == FAILURE:
if step.warnOnFailure:
if self.result != FAILURE:
self.result = WARNINGS
if step.flunkOnFailure:
self.result = FAILURE
if step.haltOnFailure:
self.result = FAILURE
terminate = True
elif result == WARNINGS:
if step.warnOnWarnings:
if self.result != FAILURE:
self.result = WARNINGS
if step.flunkOnWarnings:
self.result = FAILURE
elif result == EXCEPTION:
self.result = EXCEPTION
terminate = True
return terminate
def lostRemote(self, remote=None):
# the slave went away. There are several possible reasons for this,
# and they aren't necessarily fatal. For now, kill the build, but
# TODO: see if we can resume the build when it reconnects.
log.msg("%s.lostRemote" % self)
self.remote = None
if self.currentStep:
# this should cause the step to finish.
log.msg(" stopping currentStep", self.currentStep)
self.currentStep.interrupt(Failure(error.ConnectionLost()))
def stopBuild(self, reason="<no reason given>"):
# the idea here is to let the user cancel a build because, e.g.,
# they realized they committed a bug and they don't want to waste
# the time building something that they know will fail. Another
# reason might be to abandon a stuck build. We want to mark the
# build as failed quickly rather than waiting for the slave's
# timeout to kill it on its own.
log.msg(" %s: stopping build: %s" % (self, reason))
if self.finished:
return
# TODO: include 'reason' in this point event
self.builder.builder_status.addPointEvent(['interrupt'])
self.currentStep.interrupt(reason)
if 0:
# TODO: maybe let its deferred do buildFinished
if self.currentStep and self.currentStep.progress:
# XXX: really .fail or something
self.currentStep.progress.finish()
text = ["stopped", reason]
self.buildFinished(text, "red", FAILURE)
def allStepsDone(self):
if self.result == FAILURE:
color = "red"
text = ["failed"]
elif self.result == WARNINGS:
color = "orange"
text = ["warnings"]
elif self.result == EXCEPTION:
color = "purple"
text = ["exception"]
else:
color = "green"
text = ["build", "successful"]
text.extend(self.text)
return self.buildFinished(text, color, self.result)
def buildException(self, why):
log.msg("%s.buildException" % self)
log.err(why)
self.buildFinished(["build", "exception"], "purple", FAILURE)
def buildFinished(self, text, color, results):
"""This method must be called when the last Step has completed. It
marks the Build as complete and returns the Builder to the 'idle'
state.
It takes three arguments which describe the overall build status:
text, color, results. 'results' is one of SUCCESS, WARNINGS, or
FAILURE.
If 'results' is SUCCESS or WARNINGS, we will permit any dependant
builds to start. If it is 'FAILURE', those builds will be
abandoned."""
self.finished = True
if self.remote:
self.remote.dontNotifyOnDisconnect(self.lostRemote)
self.results = results
log.msg(" %s: build finished" % self)
self.build_status.setText(text)
self.build_status.setColor(color)
self.build_status.setResults(results)
self.build_status.buildFinished()
if self.progress:
# XXX: also test a 'timing consistent' flag?
log.msg(" setting expectations for next time")
self.builder.setExpectations(self.progress)
reactor.callLater(0, self.releaseLocks)
self.deferred.callback(self)
self.deferred = None
def releaseLocks(self):
log.msg("releaseLocks(%s): %s" % (self, self.locks))
for lock in self.locks:
lock.release(self)
# IBuildControl
def getStatus(self):
return self.build_status
class Build(properties.PropertiesMixin):
"""I represent a single build by a single slave. Specialized Builders can
use subclasses of Build to hold status information unique to those build
processes.
I control B{how} the build proceeds. The actual build is broken up into a
series of steps, saved in the .buildSteps[] array as a list of
L{buildbot.process.step.BuildStep} objects. Each step is a single remote
command, possibly a shell command.
During the build, I put status information into my C{BuildStatus}
gatherer.
After the build, I go away.
I can be used by a factory by setting buildClass on
L{buildbot.process.factory.BuildFactory}
@ivar requests: the list of L{BuildRequest}s that triggered me
@ivar build_status: the L{buildbot.status.build.BuildStatus} that
collects our status
"""
implements(interfaces.IBuildControl)
workdir = "build"
build_status = None
reason = "changes"
finished = False
results = None
stopped = False
set_runtime_properties = True
subs = None
_sentinel = [] # used as a sentinel to indicate unspecified initial_value
def __init__(self, requests):
self.requests = requests
self.locks = []
# build a source stamp
self.sources = requests[0].mergeSourceStampsWith(requests[1:])
self.reason = requests[0].mergeReasons(requests[1:])
self.progress = None
self.currentStep = None
self.slaveEnvironment = {}
self.buildid = None
self.number = None
self.terminate = False
self._acquiringLock = None
def setBuilder(self, builder):
"""
Set the given builder as our builder.
@type builder: L{buildbot.process.builder.Builder}
"""
self.builder = builder
self.master = builder.master
def setLocks(self, lockList):
# convert all locks into their real forms
self.locks = [(self.builder.botmaster.getLockFromLockAccess(access),
access) for access in lockList]
def setSlaveEnvironment(self, env):
# TODO: remove once we don't have anything depending on this method or attribute
# e.g., old-style steps (ShellMixin pulls the environment out of the builder directly)
self.slaveEnvironment = env
def getSourceStamp(self, codebase=''):
for source in self.sources:
if source.codebase == codebase:
return source
return None
def getAllSourceStamps(self):
return list(self.sources)
def allChanges(self):
for s in self.sources:
for c in s.changes:
yield c
def allFiles(self):
# return a list of all source files that were changed
files = []
for c in self.allChanges():
for f in c.files:
files.append(f)
return files
def __repr__(self):
return "<Build %s>" % (self.builder.name, )
def blamelist(self):
blamelist = []
for c in self.allChanges():
if c.who not in blamelist:
blamelist.append(c.who)
for source in self.sources:
if source.patch_info: # Add patch author to blamelist
blamelist.append(source.patch_info[0])
blamelist.sort()
return blamelist
def changesText(self):
changetext = ""
for c in self.allChanges():
changetext += "-" * 60 + "\n\n" + c.asText() + "\n"
# consider sorting these by number
return changetext
def setStepFactories(self, step_factories):
"""Set a list of 'step factories', which are tuples of (class,
kwargs), where 'class' is generally a subclass of step.BuildStep .
These are used to create the Steps themselves when the Build starts
(as opposed to when it is first created). By creating the steps
later, their __init__ method will have access to things like
build.allFiles() ."""
self.stepFactories = list(step_factories)
useProgress = True
def getSlaveCommandVersion(self, command, oldversion=None):
return self.slavebuilder.getSlaveCommandVersion(command, oldversion)
def getSlaveName(self):
return self.slavebuilder.slave.slavename
def setupProperties(self):
props = interfaces.IProperties(self)
# give the properties a reference back to this build
props.build = self
# start with global properties from the configuration
master = self.builder.master
props.updateFromProperties(master.config.properties)
# from the SourceStamps, which have properties via Change
for change in self.allChanges():
props.updateFromProperties(change.properties)
# and finally, get any properties from requests (this is the path
# through which schedulers will send us properties)
for rq in self.requests:
props.updateFromProperties(rq.properties)
# now set some properties of our own, corresponding to the
# build itself
props.setProperty("buildnumber", self.number, "Build")
if self.sources and len(self.sources) == 1:
# old interface for backwards compatibility
source = self.sources[0]
props.setProperty("branch", source.branch, "Build")
props.setProperty("revision", source.revision, "Build")
props.setProperty("repository", source.repository, "Build")
props.setProperty("codebase", source.codebase, "Build")
props.setProperty("project", source.project, "Build")
self.builder.setupProperties(props)
def setupSlaveBuilder(self, slavebuilder):
self.slavebuilder = slavebuilder
self.path_module = slavebuilder.slave.path_module
# navigate our way back to the L{buildbot.buildslave.BuildSlave}
# object that came from the config, and get its properties
buildslave_properties = slavebuilder.slave.properties
self.getProperties().updateFromProperties(buildslave_properties)
if slavebuilder.slave.slave_basedir:
builddir = self.path_module.join(slavebuilder.slave.slave_basedir,
self.builder.config.slavebuilddir)
self.setProperty("builddir", builddir, "slave")
self.setProperty("workdir", builddir, "slave (deprecated)")
self.slavename = slavebuilder.slave.slavename
self.build_status.setSlavename(self.slavename)
@defer.inlineCallbacks
def startBuild(self, build_status, expectations, slavebuilder):
"""This method sets up the build, then starts it by invoking the
first Step. It returns a Deferred which will fire when the build
finishes. This Deferred is guaranteed to never errback."""
slave = slavebuilder.slave
# we are taking responsibility for watching the connection to the
# remote. This responsibility was held by the Builder until our
# startBuild was called, and will not return to them until we fire
# the Deferred returned by this method.
log.msg("%s.startBuild" % self)
self.build_status = build_status
# TODO: this will go away when build collapsing is implemented; until
# then we just assign the bulid to the first buildrequest
brid = self.requests[0].id
self.buildid, self.number = \
yield self.master.data.updates.newBuild(
builderid=(yield self.builder.getBuilderId()),
buildrequestid=brid,
buildslaveid=slave.buildslaveid)
# now that we have a build_status, we can set properties
self.setupProperties()
self.setupSlaveBuilder(slavebuilder)
slave.updateSlaveStatus(buildStarted=self)
# then narrow SlaveLocks down to the right slave
self.locks = [(l.getLock(self.slavebuilder.slave), a)
for l, a in self.locks]
self.conn = slavebuilder.slave.conn
self.subs = self.conn.notifyOnDisconnect(self.lostRemote)
metrics.MetricCountEvent.log('active_builds', 1)
self.deferred = defer.Deferred()
try:
self.setupBuild(expectations) # create .steps
except:
# the build hasn't started yet, so log the exception as a point
# event instead of flunking the build.
# TODO: associate this failure with the build instead.
# this involves doing
# self.build_status.buildStarted() from within the exception
# handler
log.msg("Build.setupBuild failed")
log.err(Failure())
self.finished = True
self.results = EXCEPTION
self.deferred = None
return
yield self.master.data.updates.setBuildStateStrings(
self.buildid, [u'starting'])
self.build_status.buildStarted(self)
yield self.acquireLocks()
try:
# start the sequence of steps and wait until it's finished
self.startNextStep()
yield self.deferred
finally:
metrics.MetricCountEvent.log('active_builds', -1)
yield self.master.data.updates.setBuildStateStrings(
self.buildid, [u'finished'])
yield self.master.data.updates.finishBuild(self.buildid, self.results)
# mark the build as finished
self.slavebuilder.buildFinished()
slave.updateSlaveStatus(buildFinished=self)
@staticmethod
def canStartWithSlavebuilder(lockList, slavebuilder):
for lock, access in lockList:
slave_lock = lock.getLock(slavebuilder.slave)
if not slave_lock.isAvailable(None, access):
return False
return True
def acquireLocks(self, res=None):
self._acquiringLock = None
if not self.locks:
return defer.succeed(None)
if self.stopped:
return defer.succeed(None)
log.msg("acquireLocks(build %s, locks %s)" % (self, self.locks))
for lock, access in self.locks:
if not lock.isAvailable(self, access):
log.msg("Build %s waiting for lock %s" % (self, lock))
d = lock.waitUntilMaybeAvailable(self, access)
d.addCallback(self.acquireLocks)
self._acquiringLock = (lock, access, d)
return d
# all locks are available, claim them all
for lock, access in self.locks:
lock.claim(self, access)
return defer.succeed(None)
def setupBuild(self, expectations):
# create the actual BuildSteps. If there are any name collisions, we
# add a count to the loser until it is unique.
self.steps = []
self.executedSteps = []
self.stepStatuses = {}
stepnames = {}
sps = []
for factory in self.stepFactories:
step = factory.buildStep()
step.setBuild(self)
step.setBuildSlave(self.slavebuilder.slave)
# TODO: remove once we don't have anything depending on setDefaultWorkdir
if callable(self.workdir):
step.setDefaultWorkdir(self.workdir(self.sources))
else:
step.setDefaultWorkdir(self.workdir)
name = step.name
if name in stepnames:
count = stepnames[name]
count += 1
stepnames[name] = count
name = step.name + "_%d" % count
else:
stepnames[name] = 0
step.name = name
self.steps.append(step)
# tell the BuildStatus about the step. This will create a
# BuildStepStatus and bind it to the Step.
step_status = self.build_status.addStepWithName(name)
step.setStepStatus(step_status)
sp = None
if self.useProgress:
# XXX: maybe bail if step.progressMetrics is empty? or skip
# progress for that one step (i.e. "it is fast"), or have a
# separate "variable" flag that makes us bail on progress
# tracking
sp = step.setupProgress()
if sp:
sps.append(sp)
# Create a buildbot.status.progress.BuildProgress object. This is
# called once at startup to figure out how to build the long-term
# Expectations object, and again at the start of each build to get a
# fresh BuildProgress object to track progress for that individual
# build. TODO: revisit at-startup call
if self.useProgress:
self.progress = BuildProgress(sps)
if self.progress and expectations:
self.progress.setExpectationsFrom(expectations)
# we are now ready to set up our BuildStatus.
# pass all sourcestamps to the buildstatus
self.build_status.setSourceStamps(self.sources)
self.build_status.setReason(self.reason)
self.build_status.setBlamelist(self.blamelist())
self.build_status.setProgress(self.progress)
# gather owners from build requests
owners = [
r.properties['owner'] for r in self.requests
if "owner" in r.properties
]
if owners:
self.setProperty('owners', owners, self.reason)
self.results = [] # list of FAILURE, SUCCESS, WARNINGS, SKIPPED
self.result = SUCCESS # overall result, may downgrade after each step
self.text = [] # list of text string lists (text2)
def getNextStep(self):
"""This method is called to obtain the next BuildStep for this build.
When it returns None (or raises a StopIteration exception), the build
is complete."""
if not self.steps:
return None
if not self.conn:
return None
if self.terminate or self.stopped:
# Run any remaining alwaysRun steps, and skip over the others
while True:
s = self.steps.pop(0)
if s.alwaysRun:
return s
if not self.steps:
return None
else:
return self.steps.pop(0)
def startNextStep(self):
try:
s = self.getNextStep()
except StopIteration:
s = None
if not s:
return self.allStepsDone()
self.executedSteps.append(s)
self.currentStep = s
d = defer.maybeDeferred(s.startStep, self.conn)
d.addCallback(self._stepDone, s)
d.addErrback(self.buildException)
def _stepDone(self, results, step):
self.currentStep = None
if self.finished:
return # build was interrupted, don't keep building
terminate = self.stepDone(results, step) # interpret/merge results
if terminate:
self.terminate = True
return self.startNextStep()
def stepDone(self, result, step):
"""This method is called when the BuildStep completes. It is passed a
status object from the BuildStep and is responsible for merging the
Step's results into those of the overall Build."""
terminate = False
text = None
if isinstance(result, types.TupleType):
result, text = result
assert isinstance(result, type(SUCCESS)), "got %r" % (result, )
log.msg(" step '%s' complete: %s" % (step.name, Results[result]))
self.results.append(result)
if text:
self.text.extend(text)
self.result, terminate = computeResultAndTermination(
step, result, self.result)
if not self.conn:
terminate = True
return terminate
def lostRemote(self, conn=None):
# the slave went away. There are several possible reasons for this,
# and they aren't necessarily fatal. For now, kill the build, but
# TODO: see if we can resume the build when it reconnects.
log.msg("%s.lostRemote" % self)
self.conn = None
if self.currentStep:
# this should cause the step to finish.
log.msg(" stopping currentStep", self.currentStep)
self.currentStep.interrupt(Failure(error.ConnectionLost()))
else:
self.result = RETRY
self.text = ["lost", "connection"]
self.stopped = True
if self._acquiringLock:
lock, access, d = self._acquiringLock
lock.stopWaitingUntilAvailable(self, access, d)
d.callback(None)
def stopBuild(self, reason="<no reason given>"):
# the idea here is to let the user cancel a build because, e.g.,
# they realized they committed a bug and they don't want to waste
# the time building something that they know will fail. Another
# reason might be to abandon a stuck build. We want to mark the
# build as failed quickly rather than waiting for the slave's
# timeout to kill it on its own.
log.msg(" %s: stopping build: %s" % (self, reason))
if self.finished:
return
# TODO: include 'reason' in this point event
self.stopped = True
if self.currentStep:
self.currentStep.interrupt(reason)
self.result = CANCELLED
if self._acquiringLock:
lock, access, d = self._acquiringLock
lock.stopWaitingUntilAvailable(self, access, d)
d.callback(None)
def allStepsDone(self):
if self.result == FAILURE:
text = ["failed"]
elif self.result == WARNINGS:
text = ["warnings"]
elif self.result == EXCEPTION:
text = ["exception"]
elif self.result == RETRY:
text = ["retry"]
elif self.result == CANCELLED:
text = ["cancelled"]
else:
text = ["build", "successful"]
text.extend(self.text)
return self.buildFinished(text, self.result)
def buildException(self, why):
log.msg("%s.buildException" % self)
log.err(why)
# try to finish the build, but since we've already faced an exception,
# this may not work well.
try:
self.buildFinished(["build", "exception"], EXCEPTION)
except:
log.err(Failure(), 'while finishing a build with an exception')
def buildFinished(self, text, results):
"""This method must be called when the last Step has completed. It
marks the Build as complete and returns the Builder to the 'idle'
state.
It takes two arguments which describe the overall build status:
text, results. 'results' is one of SUCCESS, WARNINGS, or FAILURE.
If 'results' is SUCCESS or WARNINGS, we will permit any dependant
builds to start. If it is 'FAILURE', those builds will be
abandoned."""
self.finished = True
if self.conn:
self.subs.unsubscribe()
self.subs = None
self.conn = None
self.results = results
log.msg(" %s: build finished" % self)
self.build_status.setText(text)
self.build_status.setResults(results)
self.build_status.buildFinished()
if self.progress and results == SUCCESS:
# XXX: also test a 'timing consistent' flag?
log.msg(" setting expectations for next time")
self.builder.setExpectations(self.progress)
eventually(self.releaseLocks)
self.deferred.callback(self)
self.deferred = None
def releaseLocks(self):
if self.locks:
log.msg("releaseLocks(%s): %s" % (self, self.locks))
for lock, access in self.locks:
if lock.isOwner(self, access):
lock.release(self, access)
else:
# This should only happen if we've been interrupted
assert self.stopped
def getSummaryStatistic(self, name, summary_fn, initial_value=_sentinel):
step_stats_list = [
st.getStatistic(name) for st in self.executedSteps
if st.hasStatistic(name)
]
if initial_value is self._sentinel:
return reduce(summary_fn, step_stats_list)
else:
return reduce(summary_fn, step_stats_list, initial_value)
# IBuildControl
def getStatus(self):
return self.build_status
class Build(properties.PropertiesMixin):
"""I represent a single build by a single slave. Specialized Builders can
use subclasses of Build to hold status information unique to those build
processes.
I control B{how} the build proceeds. The actual build is broken up into a
series of steps, saved in the .buildSteps[] array as a list of
L{buildbot.process.step.BuildStep} objects. Each step is a single remote
command, possibly a shell command.
During the build, I put status information into my C{BuildStatus}
gatherer.
After the build, I go away.
I can be used by a factory by setting buildClass on
L{buildbot.process.factory.BuildFactory}
@ivar requests: the list of L{BuildRequest}s that triggered me
@ivar build_status: the L{buildbot.status.build.BuildStatus} that
collects our status
"""
implements(interfaces.IBuildControl)
workdir = "build"
build_status = None
reason = "changes"
finished = False
results = None
stopped = False
set_runtime_properties = True
subs = None
_sentinel = [] # used as a sentinel to indicate unspecified initial_value
def __init__(self, requests):
self.requests = requests
self.locks = []
# build a source stamp
self.sources = requests[0].mergeSourceStampsWith(requests[1:])
self.reason = requests[0].mergeReasons(requests[1:])
self.progress = None
self.currentStep = None
self.slaveEnvironment = {}
self.buildid = None
self.number = None
self.terminate = False
self._acquiringLock = None
def setBuilder(self, builder):
"""
Set the given builder as our builder.
@type builder: L{buildbot.process.builder.Builder}
"""
self.builder = builder
self.master = builder.master
def setLocks(self, lockList):
# convert all locks into their real forms
self.locks = [(self.builder.botmaster.getLockFromLockAccess(access), access)
for access in lockList]
def setSlaveEnvironment(self, env):
# TODO: remove once we don't have anything depending on this method or attribute
# e.g., old-style steps (ShellMixin pulls the environment out of the builder directly)
self.slaveEnvironment = env
def getSourceStamp(self, codebase=''):
for source in self.sources:
if source.codebase == codebase:
return source
return None
def getAllSourceStamps(self):
return list(self.sources)
def allChanges(self):
for s in self.sources:
for c in s.changes:
yield c
def allFiles(self):
# return a list of all source files that were changed
files = []
for c in self.allChanges():
for f in c.files:
files.append(f)
return files
def __repr__(self):
return "<Build %s>" % (self.builder.name,)
def blamelist(self):
blamelist = []
for c in self.allChanges():
if c.who not in blamelist:
blamelist.append(c.who)
for source in self.sources:
if source.patch_info: # Add patch author to blamelist
blamelist.append(source.patch_info[0])
blamelist.sort()
return blamelist
def changesText(self):
changetext = ""
for c in self.allChanges():
changetext += "-" * 60 + "\n\n" + c.asText() + "\n"
# consider sorting these by number
return changetext
def setStepFactories(self, step_factories):
"""Set a list of 'step factories', which are tuples of (class,
kwargs), where 'class' is generally a subclass of step.BuildStep .
These are used to create the Steps themselves when the Build starts
(as opposed to when it is first created). By creating the steps
later, their __init__ method will have access to things like
build.allFiles() ."""
self.stepFactories = list(step_factories)
useProgress = True
def getSlaveCommandVersion(self, command, oldversion=None):
return self.slavebuilder.getSlaveCommandVersion(command, oldversion)
def getSlaveName(self):
return self.slavebuilder.slave.slavename
def setupProperties(self):
props = interfaces.IProperties(self)
# give the properties a reference back to this build
props.build = self
# start with global properties from the configuration
master = self.builder.master
props.updateFromProperties(master.config.properties)
# from the SourceStamps, which have properties via Change
for change in self.allChanges():
props.updateFromProperties(change.properties)
# and finally, get any properties from requests (this is the path
# through which schedulers will send us properties)
for rq in self.requests:
props.updateFromProperties(rq.properties)
# now set some properties of our own, corresponding to the
# build itself
props.setProperty("buildnumber", self.number, "Build")
if self.sources and len(self.sources) == 1:
# old interface for backwards compatibility
source = self.sources[0]
props.setProperty("branch", source.branch, "Build")
props.setProperty("revision", source.revision, "Build")
props.setProperty("repository", source.repository, "Build")
props.setProperty("codebase", source.codebase, "Build")
props.setProperty("project", source.project, "Build")
self.builder.setupProperties(props)
def setupSlaveBuilder(self, slavebuilder):
self.slavebuilder = slavebuilder
self.path_module = slavebuilder.slave.path_module
# navigate our way back to the L{buildbot.buildslave.BuildSlave}
# object that came from the config, and get its properties
buildslave_properties = slavebuilder.slave.properties
self.getProperties().updateFromProperties(buildslave_properties)
if slavebuilder.slave.slave_basedir:
builddir = self.path_module.join(
slavebuilder.slave.slave_basedir,
self.builder.config.slavebuilddir)
self.setProperty("builddir", builddir, "slave")
self.setProperty("workdir", builddir, "slave (deprecated)")
self.slavename = slavebuilder.slave.slavename
self.build_status.setSlavename(self.slavename)
@defer.inlineCallbacks
def startBuild(self, build_status, expectations, slavebuilder):
"""This method sets up the build, then starts it by invoking the
first Step. It returns a Deferred which will fire when the build
finishes. This Deferred is guaranteed to never errback."""
slave = slavebuilder.slave
# we are taking responsibility for watching the connection to the
# remote. This responsibility was held by the Builder until our
# startBuild was called, and will not return to them until we fire
# the Deferred returned by this method.
log.msg("%s.startBuild" % self)
self.build_status = build_status
# TODO: this will go away when build collapsing is implemented; until
# then we just assign the bulid to the first buildrequest
brid = self.requests[0].id
self.buildid, self.number = \
yield self.master.data.updates.newBuild(
builderid=(yield self.builder.getBuilderId()),
buildrequestid=brid,
buildslaveid=slave.buildslaveid)
# now that we have a build_status, we can set properties
self.setupProperties()
self.setupSlaveBuilder(slavebuilder)
slave.updateSlaveStatus(buildStarted=self)
# then narrow SlaveLocks down to the right slave
self.locks = [(l.getLock(self.slavebuilder.slave), a)
for l, a in self.locks]
self.conn = slavebuilder.slave.conn
self.subs = self.conn.notifyOnDisconnect(self.lostRemote)
metrics.MetricCountEvent.log('active_builds', 1)
self.deferred = defer.Deferred()
try:
self.setupBuild(expectations) # create .steps
except:
# the build hasn't started yet, so log the exception as a point
# event instead of flunking the build.
# TODO: associate this failure with the build instead.
# this involves doing
# self.build_status.buildStarted() from within the exception
# handler
log.msg("Build.setupBuild failed")
log.err(Failure())
self.finished = True
self.results = EXCEPTION
self.deferred = None
return
yield self.master.data.updates.setBuildStateStrings(self.buildid,
[u'starting'])
self.build_status.buildStarted(self)
yield self.acquireLocks()
try:
# start the sequence of steps and wait until it's finished
self.startNextStep()
yield self.deferred
finally:
metrics.MetricCountEvent.log('active_builds', -1)
yield self.master.data.updates.setBuildStateStrings(self.buildid,
[u'finished'])
yield self.master.data.updates.finishBuild(self.buildid, self.results)
# mark the build as finished
self.slavebuilder.buildFinished()
slave.updateSlaveStatus(buildFinished=self)
@staticmethod
def canStartWithSlavebuilder(lockList, slavebuilder):
for lock, access in lockList:
slave_lock = lock.getLock(slavebuilder.slave)
if not slave_lock.isAvailable(None, access):
return False
return True
def acquireLocks(self, res=None):
self._acquiringLock = None
if not self.locks:
return defer.succeed(None)
if self.stopped:
return defer.succeed(None)
log.msg("acquireLocks(build %s, locks %s)" % (self, self.locks))
for lock, access in self.locks:
if not lock.isAvailable(self, access):
log.msg("Build %s waiting for lock %s" % (self, lock))
d = lock.waitUntilMaybeAvailable(self, access)
d.addCallback(self.acquireLocks)
self._acquiringLock = (lock, access, d)
return d
# all locks are available, claim them all
for lock, access in self.locks:
lock.claim(self, access)
return defer.succeed(None)
def setupBuild(self, expectations):
# create the actual BuildSteps. If there are any name collisions, we
# add a count to the loser until it is unique.
self.steps = []
self.executedSteps = []
self.stepStatuses = {}
stepnames = {}
sps = []
for factory in self.stepFactories:
step = factory.buildStep()
step.setBuild(self)
step.setBuildSlave(self.slavebuilder.slave)
# TODO: remove once we don't have anything depending on setDefaultWorkdir
if callable(self.workdir):
step.setDefaultWorkdir(self.workdir(self.sources))
else:
step.setDefaultWorkdir(self.workdir)
name = step.name
if name in stepnames:
count = stepnames[name]
count += 1
stepnames[name] = count
name = step.name + "_%d" % count
else:
stepnames[name] = 0
step.name = name
self.steps.append(step)
# tell the BuildStatus about the step. This will create a
# BuildStepStatus and bind it to the Step.
step_status = self.build_status.addStepWithName(name)
step.setStepStatus(step_status)
sp = None
if self.useProgress:
# XXX: maybe bail if step.progressMetrics is empty? or skip
# progress for that one step (i.e. "it is fast"), or have a
# separate "variable" flag that makes us bail on progress
# tracking
sp = step.setupProgress()
if sp:
sps.append(sp)
# Create a buildbot.status.progress.BuildProgress object. This is
# called once at startup to figure out how to build the long-term
# Expectations object, and again at the start of each build to get a
# fresh BuildProgress object to track progress for that individual
# build. TODO: revisit at-startup call
if self.useProgress:
self.progress = BuildProgress(sps)
if self.progress and expectations:
self.progress.setExpectationsFrom(expectations)
# we are now ready to set up our BuildStatus.
# pass all sourcestamps to the buildstatus
self.build_status.setSourceStamps(self.sources)
self.build_status.setReason(self.reason)
self.build_status.setBlamelist(self.blamelist())
self.build_status.setProgress(self.progress)
# gather owners from build requests
owners = [r.properties['owner'] for r in self.requests
if "owner" in r.properties]
if owners:
self.setProperty('owners', owners, self.reason)
self.results = [] # list of FAILURE, SUCCESS, WARNINGS, SKIPPED
self.result = SUCCESS # overall result, may downgrade after each step
self.text = [] # list of text string lists (text2)
def getNextStep(self):
"""This method is called to obtain the next BuildStep for this build.
When it returns None (or raises a StopIteration exception), the build
is complete."""
if not self.steps:
return None
if not self.conn:
return None
if self.terminate or self.stopped:
# Run any remaining alwaysRun steps, and skip over the others
while True:
s = self.steps.pop(0)
if s.alwaysRun:
return s
if not self.steps:
return None
else:
return self.steps.pop(0)
def startNextStep(self):
try:
s = self.getNextStep()
except StopIteration:
s = None
if not s:
return self.allStepsDone()
self.executedSteps.append(s)
self.currentStep = s
d = defer.maybeDeferred(s.startStep, self.conn)
d.addCallback(self._stepDone, s)
d.addErrback(self.buildException)
def _stepDone(self, results, step):
self.currentStep = None
if self.finished:
return # build was interrupted, don't keep building
terminate = self.stepDone(results, step) # interpret/merge results
if terminate:
self.terminate = True
return self.startNextStep()
def stepDone(self, result, step):
"""This method is called when the BuildStep completes. It is passed a
status object from the BuildStep and is responsible for merging the
Step's results into those of the overall Build."""
terminate = False
text = None
if isinstance(result, types.TupleType):
result, text = result
assert isinstance(result, type(SUCCESS)), "got %r" % (result,)
log.msg(" step '%s' complete: %s" % (step.name, Results[result]))
self.results.append(result)
if text:
self.text.extend(text)
self.result, terminate = computeResultAndTermination(step, result,
self.result)
if not self.conn:
terminate = True
return terminate
def lostRemote(self, conn=None):
# the slave went away. There are several possible reasons for this,
# and they aren't necessarily fatal. For now, kill the build, but
# TODO: see if we can resume the build when it reconnects.
log.msg("%s.lostRemote" % self)
self.conn = None
if self.currentStep:
# this should cause the step to finish.
log.msg(" stopping currentStep", self.currentStep)
self.currentStep.interrupt(Failure(error.ConnectionLost()))
else:
self.result = RETRY
self.text = ["lost", "connection"]
self.stopped = True
if self._acquiringLock:
lock, access, d = self._acquiringLock
lock.stopWaitingUntilAvailable(self, access, d)
d.callback(None)
def stopBuild(self, reason="<no reason given>"):
# the idea here is to let the user cancel a build because, e.g.,
# they realized they committed a bug and they don't want to waste
# the time building something that they know will fail. Another
# reason might be to abandon a stuck build. We want to mark the
# build as failed quickly rather than waiting for the slave's
# timeout to kill it on its own.
log.msg(" %s: stopping build: %s" % (self, reason))
if self.finished:
return
# TODO: include 'reason' in this point event
self.stopped = True
if self.currentStep:
self.currentStep.interrupt(reason)
self.result = CANCELLED
if self._acquiringLock:
lock, access, d = self._acquiringLock
lock.stopWaitingUntilAvailable(self, access, d)
d.callback(None)
def allStepsDone(self):
if self.result == FAILURE:
text = ["failed"]
elif self.result == WARNINGS:
text = ["warnings"]
elif self.result == EXCEPTION:
text = ["exception"]
elif self.result == RETRY:
text = ["retry"]
elif self.result == CANCELLED:
text = ["cancelled"]
else:
text = ["build", "successful"]
text.extend(self.text)
return self.buildFinished(text, self.result)
def buildException(self, why):
log.msg("%s.buildException" % self)
log.err(why)
# try to finish the build, but since we've already faced an exception,
# this may not work well.
try:
self.buildFinished(["build", "exception"], EXCEPTION)
except:
log.err(Failure(), 'while finishing a build with an exception')
def buildFinished(self, text, results):
"""This method must be called when the last Step has completed. It
marks the Build as complete and returns the Builder to the 'idle'
state.
It takes two arguments which describe the overall build status:
text, results. 'results' is one of SUCCESS, WARNINGS, or FAILURE.
If 'results' is SUCCESS or WARNINGS, we will permit any dependant
builds to start. If it is 'FAILURE', those builds will be
abandoned."""
self.finished = True
if self.conn:
self.subs.unsubscribe()
self.subs = None
self.conn = None
self.results = results
log.msg(" %s: build finished" % self)
self.build_status.setText(text)
self.build_status.setResults(results)
self.build_status.buildFinished()
if self.progress and results == SUCCESS:
# XXX: also test a 'timing consistent' flag?
log.msg(" setting expectations for next time")
self.builder.setExpectations(self.progress)
eventually(self.releaseLocks)
self.deferred.callback(self)
self.deferred = None
def releaseLocks(self):
if self.locks:
log.msg("releaseLocks(%s): %s" % (self, self.locks))
for lock, access in self.locks:
if lock.isOwner(self, access):
lock.release(self, access)
else:
# This should only happen if we've been interrupted
assert self.stopped
def getSummaryStatistic(self, name, summary_fn, initial_value=_sentinel):
step_stats_list = [
st.getStatistic(name)
for st in self.executedSteps
if st.hasStatistic(name)]
if initial_value is self._sentinel:
return reduce(summary_fn, step_stats_list)
else:
return reduce(summary_fn, step_stats_list, initial_value)
# IBuildControl
def getStatus(self):
return self.build_status
class Build(properties.PropertiesMixin):
"""I represent a single build by a single slave. Specialized Builders can
use subclasses of Build to hold status information unique to those build
processes.
I control B{how} the build proceeds. The actual build is broken up into a
series of steps, saved in the .buildSteps[] array as a list of
L{buildbot.process.step.BuildStep} objects. Each step is a single remote
command, possibly a shell command.
During the build, I put status information into my C{BuildStatus}
gatherer.
After the build, I go away.
I can be used by a factory by setting buildClass on
L{buildbot.process.factory.BuildFactory}
@ivar requests: the list of L{BuildRequest}s that triggered me
@ivar build_status: the L{buildbot.status.build.BuildStatus} that
collects our status
"""
implements(interfaces.IBuildControl)
workdir = "build"
build_status = None
reason = "changes"
finished = False
results = None
stopped = False
set_runtime_properties = True
def __init__(self, requests):
self.requests = requests
self.locks = []
self.releaseLockInstance = None
# build a source stamp
self.sources = requests[0].mergeSourceStampsWith(requests[1:])
self.reason = requests[0].reason
self.progress = None
self.currentStep = None
self.slaveEnvironment = {}
self.terminate = False
self._acquiringLock = None
def setBuilder(self, builder):
"""
Set the given builder as our builder.
@type builder: L{buildbot.process.builder.Builder}
"""
self.builder = builder
def setLocks(self, lockList):
# convert all locks into their real forms
self.locks = [(self.builder.botmaster.getLockFromLockAccess(access), access)
for access in lockList ]
def setSlaveEnvironment(self, env):
self.slaveEnvironment = env
def getSourceStamp(self, codebase=''):
for source in self.sources:
if source.codebase == codebase:
return source
return None
def getAllSourceStamps(self):
return list(self.sources)
def allChanges(self):
for s in self.sources:
for c in s.changes:
yield c
def allFiles(self):
# return a list of all source files that were changed
files = []
for c in self.allChanges():
for f in c.files:
files.append(f)
return files
def __repr__(self):
return "<Build %s>" % (self.builder.name,)
def blamelist(self):
blamelist = []
for c in self.allChanges():
if c.who not in blamelist:
blamelist.append(c.who)
for source in self.sources:
if source.patch_info: #Add patch author to blamelist
blamelist.append(source.patch_info[0])
blamelist.sort()
return blamelist
def changesText(self):
changetext = ""
for c in self.allChanges():
changetext += "-" * 60 + "\n\n" + c.asText() + "\n"
# consider sorting these by number
return changetext
def setStepFactories(self, step_factories):
"""Set a list of 'step factories', which are tuples of (class,
kwargs), where 'class' is generally a subclass of step.BuildStep .
These are used to create the Steps themselves when the Build starts
(as opposed to when it is first created). By creating the steps
later, their __init__ method will have access to things like
build.allFiles() ."""
self.stepFactories = list(step_factories)
useProgress = True
def getSlaveCommandVersion(self, command, oldversion=None):
return self.slavebuilder.getSlaveCommandVersion(command, oldversion)
def getSlaveName(self):
return self.slavebuilder.slave.slavename
def setupProperties(self):
props = interfaces.IProperties(self)
# give the properties a reference back to this build
props.build = self
# start with global properties from the configuration
master = self.builder.botmaster.master
props.updateFromProperties(master.config.properties)
# from the SourceStamps, which have properties via Change
for change in self.allChanges():
props.updateFromProperties(change.properties)
# and finally, get any properties from requests (this is the path
# through which schedulers will send us properties)
for rq in self.requests:
props.updateFromProperties(rq.properties)
# now set some properties of our own, corresponding to the
# build itself
props.setProperty("buildnumber", self.build_status.number, "Build")
if self.sources and len(self.sources) == 1:
# old interface for backwards compatibility
source = self.sources[0]
props.setProperty("branch", source.branch, "Build")
props.setProperty("revision", source.revision, "Build")
props.setProperty("repository", source.repository, "Build")
props.setProperty("codebase", source.codebase, "Build")
props.setProperty("project", source.project, "Build")
self.builder.setupProperties(props)
def setupSlaveBuilder(self, slavebuilder):
self.slavebuilder = slavebuilder
self.path_module = slavebuilder.slave.path_module
# navigate our way back to the L{buildbot.buildslave.BuildSlave}
# object that came from the config, and get its properties
buildslave_properties = slavebuilder.slave.properties
self.getProperties().updateFromProperties(buildslave_properties)
if slavebuilder.slave.slave_basedir:
self.setProperty("builddir",
self.path_module.join(
slavebuilder.slave.slave_basedir,
self.builder.config.slavebuilddir),
"Slave")
self.slavename = slavebuilder.slave.slavename
self.build_status.setSlavename(self.slavename)
def startBuild(self, build_status, expectations, slavebuilder):
"""This method sets up the build, then starts it by invoking the
first Step. It returns a Deferred which will fire when the build
finishes. This Deferred is guaranteed to never errback."""
# we are taking responsibility for watching the connection to the
# remote. This responsibility was held by the Builder until our
# startBuild was called, and will not return to them until we fire
# the Deferred returned by this method.
log.msg("%s.startBuild" % self)
self.build_status = build_status
# now that we have a build_status, we can set properties
self.setupProperties()
self.setupSlaveBuilder(slavebuilder)
slavebuilder.slave.updateStatusBuildStarted(build=build_status)
# then narrow SlaveLocks down to the right slave
self.locks = [(l.getLock(self.slavebuilder.slave), a)
for l, a in self.locks ]
self.remote = slavebuilder.remote
self.remote.notifyOnDisconnect(self.lostRemote)
metrics.MetricCountEvent.log('active_builds', 1)
d = self.deferred = defer.Deferred()
def _uncount_build(res):
metrics.MetricCountEvent.log('active_builds', -1)
return res
d.addBoth(_uncount_build)
@defer.inlineCallbacks
def _release_slave(res, slave, build_status):
slavebuilder.buildFinished(slave)
if slave and build_status:
yield slave.updateStatusBuildFinished(result=res, build=build_status)
defer.returnValue(res)
d.addCallback(_release_slave, slavebuilder.slave, build_status)
try:
self.setupBuild(expectations) # create .steps
except:
# the build hasn't started yet, so log the exception as a point
# event instead of flunking the build.
# TODO: associate this failure with the build instead.
# this involves doing
# self.build_status.buildStarted() from within the exception
# handler
log.msg("Build.setupBuild failed")
klog.err_json(Failure())
self.builder.builder_status.addPointEvent(["setupBuild",
"exception"])
self.finished = True
self.results = EXCEPTION
self.deferred = None
d.callback(self)
return d
self.build_status.buildStarted(self)
self.acquireLocks().addCallback(self._startBuild_2)
return d
@staticmethod
def canStartWithSlavebuilder(lockList, slavebuilder):
for lock, access in lockList:
slave_lock = lock.getLock(slavebuilder.slave)
if not slave_lock.isAvailable(None, access):
return False
return True
def acquireLocks(self, res=None):
self._acquiringLock = None
if not self.locks:
return defer.succeed(None)
if self.stopped:
return defer.succeed(None)
log.msg("acquireLocks(build %s, locks %s)" % (self, self.locks))
for lock, access in self.locks:
if not lock.isAvailable(self, access):
log.msg("Build %s waiting for lock %s" % (self, lock))
d = lock.waitUntilMaybeAvailable(self, access)
d.addCallback(self.acquireLocks)
self._acquiringLock = (lock, access, d)
return d
# all locks are available, claim them all
for lock, access in self.locks:
lock.claim(self, access)
return defer.succeed(None)
def _startBuild_2(self, res):
self.startNextStep()
def setupStep(self, factory, stepnames):
step = factory.buildStep()
step.setBuild(self)
step.setBuildSlave(self.slavebuilder.slave)
if callable(self.workdir):
step.setDefaultWorkdir(self.workdir(self.sources))
else:
step.setDefaultWorkdir(self.workdir)
name = step.name
if stepnames.has_key(name):
count = stepnames[name]
count += 1
stepnames[name] = count
name = step.name + "_%d" % count
else:
stepnames[name] = 0
step.name = name
return name, step
def setupStepStatus(self, factory, stepnames, index=None):
name, step = self.setupStep(factory, stepnames)
step_status = self.build_status.getStepByName(name)
stepNotAddedOrStepAlreadyExecuted = step_status is None or step_status.finished is not None
if stepNotAddedOrStepAlreadyExecuted:
name = name + "_%s" % self.slavename if step_status else name
step_status = self.build_status.addStepWithName(name, type(step), index)
step.setStepStatus(step_status)
sp = None
if self.useProgress:
sp = step.setupProgress()
return sp, step
def maybeAddGlobalFactoryInitialSteps(self, laststep, stepnames, stepProgresses):
if 'initialSteps' not in self.builder.botmaster.master.config.globalFactory \
or self.builder.config.excludeGlobalFactory:
return
intialSteps = self.builder.botmaster.master.config.globalFactory['initialSteps']
if intialSteps and intialSteps.steps:
status_index = self.build_status.steps.index(laststep) + 1 if laststep else 0
for factory in intialSteps.steps:
index = intialSteps.steps.index(factory)
sp, step = self.setupStepStatus(factory, stepnames, index=status_index+index)
self.steps.insert(index, step)
if sp:
stepProgresses.insert(index, sp)
def maybeAddGlobalFactoryLastSteps(self, stepnames, stepProgresses):
if 'lastSteps' not in self.builder.botmaster.master.config.globalFactory \
or self.builder.config.excludeGlobalFactory:
return
lastSteps = self.builder.botmaster.master.config.globalFactory['lastSteps']
if lastSteps and lastSteps.steps:
for factory in lastSteps.steps:
sp, step = self.setupStepStatus(factory, stepnames)
self.steps.append(step)
if sp:
stepProgresses.append(sp)
def createSteps(self, sps):
stepnames = {}
laststep = None
for factory in self.stepFactories:
name, step = self.setupStep(factory, stepnames)
# tell the BuildStatus about the step. This will create a
# BuildStepStatus and bind it to the Step.
if self.build_status.results == RESUME:
step_status = self.build_status.getStepByName(name)
if step_status is None:
# previous build not saved properly
self.build_status.retryResume()
else:
step_status = self.build_status.addStepWithName(name, type(step))
if step_status.finished:
laststep = step_status
continue
step.setStepStatus(step_status)
self.steps.append(step)
sp = None
if self.useProgress:
# XXX: maybe bail if step.progressMetrics is empty? or skip
# progress for that one step (i.e. "it is fast"), or have a
# separate "variable" flag that makes us bail on progress
# tracking
sp = step.setupProgress()
if sp:
sps.append(sp)
self.maybeAddGlobalFactoryInitialSteps(laststep, stepnames=stepnames, stepProgresses=sps)
self.maybeAddGlobalFactoryLastSteps(stepnames=stepnames, stepProgresses=sps)
def setupBuild(self, expectations):
# create the actual BuildSteps. If there are any name collisions, we
# add a count to the loser until it is unique.
self.steps = []
self.stepStatuses = {}
sps = []
self.createSteps(sps)
# Create a buildbot.status.progress.BuildProgress object. This is
# called once at startup to figure out how to build the long-term
# Expectations object, and again at the start of each build to get a
# fresh BuildProgress object to track progress for that individual
# build. TODO: revisit at-startup call
if self.useProgress:
self.progress = BuildProgress(sps)
if self.progress and expectations:
self.progress.setExpectationsFrom(expectations)
# we are now ready to set up our BuildStatus.
# pass all sourcestamps to the buildstatus
self.build_status.setSourceStamps(self.sources)
self.build_status.setReason(self.reason)
self.builder.builder_status.reason = self.reason
self.build_status.setBlamelist(self.blamelist())
self.build_status.setProgress(self.progress)
if len(self.requests) > 0:
self.build_status.setSubmitted(self.requests[0].submittedAt)
self.setProperty("submittedTime", self.requests[0].submittedAt, "buildrequest")
brids = [req.id for req in self.requests]
self.build_status.setBuildRequestIDs(brids)
self.setProperty("brids", brids, "buildrequest")
self.build_status.setBuildChainID(self.requests[0].buildChainID)
self.setProperty("buildChainID", self.requests[0].buildChainID, "buildrequest")
# gather owners from build requests
owners = [r.properties['owner'] for r in self.requests
if r.properties.has_key('owner')]
if owners: self.setProperty('owners', owners, self.reason)
self.build_status.setOwners(owners)
self.results = [] # list of FAILURE, SUCCESS, WARNINGS, SKIPPED
self.result = SUCCESS # overall result, may downgrade after each step
self.text = [] # list of text string lists (text2)
@defer.inlineCallbacks
def getBuildChain(self):
master = self.builder.botmaster.parent
startbrid = self.requests[0].buildChainID if len(self.requests) > 0 and self.requests[0].buildChainID else None
buildchain = yield master.db.buildrequests.getBuildRequestBuildChain(startbrid)
defer.returnValue(buildchain)
def getBuildRequestID(self):
return self.requests[0].id if len(self.requests) > 0 else None
def getNextStep(self):
"""This method is called to obtain the next BuildStep for this build.
When it returns None (or raises a StopIteration exception), the build
is complete."""
if not self.steps:
return None
if not self.remote:
return None
if self.terminate or self.stopped:
# Run any remaining alwaysRun steps, and skip over the others
while True:
s = self.steps.pop(0)
if s.alwaysRun:
return s
if not self.steps:
return None
else:
return self.steps.pop(0)
def startNextStep(self):
try:
s = self.getNextStep()
except StopIteration:
s = None
if not s:
return self.allStepsDone()
self.currentStep = s
d = defer.maybeDeferred(s.startStep, self.remote)
d.addCallback(self._stepDone, s)
d.addErrback(self.buildException)
def _stepDone(self, results, step):
self.currentStep = None
if self.finished:
return # build was interrupted, don't keep building
terminate = self.stepDone(results, step) # interpret/merge results
if terminate:
self.terminate = True
return self.startNextStep()
def stepDone(self, result, step):
"""This method is called when the BuildStep completes. It is passed a
status object from the BuildStep and is responsible for merging the
Step's results into those of the overall Build."""
terminate = False
text = None
if type(result) == types.TupleType:
result, text = result
assert type(result) == type(SUCCESS)
log.msg(" step '%s' complete: %s" % (step.name, Results[result]))
self.results.append(result)
if text:
self.text.extend(text)
if not self.remote:
terminate = True
possible_overall_result = result
if result == FAILURE:
if not step.flunkOnFailure:
possible_overall_result = SUCCESS
if step.warnOnFailure:
possible_overall_result = WARNINGS
if step.flunkOnFailure:
possible_overall_result = FAILURE
if step.haltOnFailure:
terminate = True
elif result == WARNINGS:
if not step.warnOnWarnings:
possible_overall_result = SUCCESS
else:
possible_overall_result = WARNINGS
if step.flunkOnWarnings:
possible_overall_result = FAILURE
elif result in (EXCEPTION, RETRY, DEPENDENCY_FAILURE, INTERRUPTED):
terminate = True
if result in (FAILURE, EXCEPTION) and step.pauseSlaveOnFailure:
self.slavebuilder.slave.slave_status.setPaused(True)
# if we skipped this step, then don't adjust the build status
if result != SKIPPED:
self.result = worst_status(self.result, possible_overall_result)
return terminate
def lostRemote(self, remote=None):
# the slave went away. There are several possible reasons for this,
# and they aren't necessarily fatal. For now, kill the build, but
# TODO: see if we can resume the build when it reconnects.
log.msg("%s.lostRemote" % self)
self.remote = None
self.result = RETRY
self.text = ["lost", "remote"]
if self.currentStep:
# this should cause the step to finish.
log.msg(" stopping currentStep", self.currentStep)
self.text += ["slave"]
self.currentStep.addErrorResult(Failure(error.ConnectionLost()))
self.currentStep.interrupt(Failure(error.ConnectionLost()))
else:
self.stopped = True
if self._acquiringLock:
lock, access, d = self._acquiringLock
lock.stopWaitingUntilAvailable(self, access, d)
d.callback(None)
def stopBuild(self, reason="<no reason given>"):
# the idea here is to let the user cancel a build because, e.g.,
# they realized they committed a bug and they don't want to waste
# the time building something that they know will fail. Another
# reason might be to abandon a stuck build. We want to mark the
# build as failed quickly rather than waiting for the slave's
# timeout to kill it on its own.
log.msg(" %s: stopping build: %s" % (self, reason))
if self.finished:
return
# TODO: include 'reason' in this point event
self.builder.builder_status.addPointEvent(['interrupt'])
self.stopped = True
if self.currentStep:
self.currentStep.interrupt(reason)
self.result = INTERRUPTED
if self._acquiringLock:
lock, access, d = self._acquiringLock
lock.stopWaitingUntilAvailable(self, access, d)
d.callback(None)
def allStepsDone(self):
if self.result == FAILURE or self.result == DEPENDENCY_FAILURE:
text = ["Build Failed"]
elif self.result == WARNINGS:
text = ["Build Finished with Warnings"]
elif self.result == EXCEPTION:
text = ["Build Caught Exception"]
elif self.result == RETRY:
text = ["Build Caught Exception, Will Retry"]
elif self.result == INTERRUPTED:
text = ["Build Interrupted"]
else:
reusedOldBuild = self.getProperty("reusedOldBuild", False)
if reusedOldBuild:
text = ["Successful Build Found (did not rebuild)"]
self.result = NOT_REBUILT
else:
text = ["Build Finished Successfully"]
return self.buildFinished(text, self.result)
def buildException(self, why):
log.msg("%s.buildException" % self)
klog.err_json(why)
# try to finish the build, but since we've already faced an exception,
# this may not work well.
try:
self.buildFinished(["Build Caught Exception"], DEPENDENCY_FAILURE)
except:
klog.err_json(Failure(), 'while finishing a build with an exception')
def buildFinished(self, text, results):
"""This method must be called when the last Step has completed. It
marks the Build as complete and returns the Builder to the 'idle'
state.
It takes two arguments which describe the overall build status:
text, results. 'results' is one of SUCCESS, WARNINGS, or FAILURE.
If 'results' is SUCCESS or WARNINGS, we will permit any dependant
builds to start. If it is 'FAILURE', those builds will be
abandoned."""
self.finished = True
if self.remote:
self.remote.dontNotifyOnDisconnect(self.lostRemote)
self.remote = None
self.results = results
log.msg(" %s: build finished #%s results %s" % (self, self.build_status.number, self.results))
self.build_status.setText(text)
self.build_status.setResults(results)
self.build_status.buildFinished()
if self.progress and results == SUCCESS:
# XXX: also test a 'timing consistent' flag?
log.msg(" setting expectations for next time")
self.builder.setExpectations(self.progress)
# TODO: check why callbacks are not triggered when stopping master and retrying builds
# this maybe cause by the upstream merged
eventually(self.releaseLocks)
self.deferred.callback(self)
self.deferred = None
def releaseLocks(self):
if self.locks:
log.msg("releaseLocks(%s): %s" % (self, self.locks))
for lock, access in self.locks:
if lock.isOwner(self, access):
lock.release(self, access)
else:
if self.releaseLockInstance:
lock.release(self.releaseLockInstance, access)
else:
# This should only happen if we've been interrupted
assert self.stopped
# IBuildControl
def getStatus(self):
return self.build_status
def setupBuild(self, expectations):
# create the actual BuildSteps. If there are any name collisions, we
# add a count to the loser until it is unique.
self.steps = []
self.stepStatuses = {}
stepnames = []
sps = []
for factory, args in self.stepFactories:
args = args.copy()
try:
step = factory(**args)
except:
log.msg("error while creating step, factory=%s, args=%s" %
(factory, args))
raise
step.setBuild(self)
step.setBuildSlave(self.slavebuilder.slave)
step.setDefaultWorkdir(self.workdir)
name = step.name
count = 1
# LOCAL MOZILLA PATCH:
# buildbotcustom.process.factory.ReleaseTaggingFactory uses
# more than 100 ShellCommands when it runs - this has been bumped up
# to support that. upstream buildbot bug here:
# http://buildbot.net/trac/ticket/366
while name in stepnames and count < 1000:
count += 1
name = step.name + "_%d" % count
if name in stepnames:
raise RuntimeError("duplicate step '%s'" % step.name)
step.name = name
stepnames.append(name)
self.steps.append(step)
# tell the BuildStatus about the step. This will create a
# BuildStepStatus and bind it to the Step.
step_status = self.build_status.addStepWithName(name)
step.setStepStatus(step_status)
sp = None
if self.useProgress:
# XXX: maybe bail if step.progressMetrics is empty? or skip
# progress for that one step (i.e. "it is fast"), or have a
# separate "variable" flag that makes us bail on progress
# tracking
sp = step.setupProgress()
if sp:
sps.append(sp)
# Create a buildbot.status.progress.BuildProgress object. This is
# called once at startup to figure out how to build the long-term
# Expectations object, and again at the start of each build to get a
# fresh BuildProgress object to track progress for that individual
# build. TODO: revisit at-startup call
if self.useProgress:
self.progress = BuildProgress(sps)
if self.progress and expectations:
self.progress.setExpectationsFrom(expectations)
# we are now ready to set up our BuildStatus.
self.build_status.setSourceStamp(self.source)
self.build_status.setReason(self.reason)
self.build_status.setBlamelist(self.blamelist())
self.build_status.setProgress(self.progress)
self.results = [] # list of FAILURE, SUCCESS, WARNINGS, SKIPPED
self.result = SUCCESS # overall result, may downgrade after each step
self.text = [] # list of text string lists (text2)
def setupBuild(self, expectations):
# create the actual BuildSteps. If there are any name collisions, we
# add a count to the loser until it is unique.
self.steps = []
self.executedSteps = []
self.stepStatuses = {}
stepnames = {}
sps = []
for factory in self.stepFactories:
step = factory.buildStep()
step.setBuild(self)
step.setBuildSlave(self.slavebuilder.slave)
# TODO: remove once we don't have anything depending on setDefaultWorkdir
if callable(self.workdir):
step.setDefaultWorkdir(self.workdir(self.sources))
else:
step.setDefaultWorkdir(self.workdir)
name = step.name
if name in stepnames:
count = stepnames[name]
count += 1
stepnames[name] = count
name = step.name + "_%d" % count
else:
stepnames[name] = 0
step.name = name
self.steps.append(step)
sp = None
if self.useProgress:
# XXX: maybe bail if step.progressMetrics is empty? or skip
# progress for that one step (i.e. "it is fast"), or have a
# separate "variable" flag that makes us bail on progress
# tracking
sp = step.setupProgress()
if sp:
sps.append(sp)
# Create a buildbot.status.progress.BuildProgress object. This is
# called once at startup to figure out how to build the long-term
# Expectations object, and again at the start of each build to get a
# fresh BuildProgress object to track progress for that individual
# build. TODO: revisit at-startup call
if self.useProgress:
self.progress = BuildProgress(sps)
if self.progress and expectations:
self.progress.setExpectationsFrom(expectations)
# we are now ready to set up our BuildStatus.
# pass all sourcestamps to the buildstatus
self.build_status.setSourceStamps(self.sources)
self.build_status.setReason(self.reason)
self.build_status.setBlamelist(self.blamelist())
self.build_status.setProgress(self.progress)
# gather owners from build requests
owners = [r.properties['owner'] for r in self.requests
if "owner" in r.properties]
if owners:
self.setProperty('owners', owners, self.reason)
self.results = [] # list of FAILURE, SUCCESS, WARNINGS, SKIPPED
self.result = SUCCESS # overall result, may downgrade after each step
self.text = [] # list of text string lists (text2)
def setupBuild(self, expectations):
# create the actual BuildSteps. If there are any name collisions, we
# add a count to the loser until it is unique.
self.steps = []
self.stepStatuses = {}
stepnames = []
sps = []
for factory, args in self.stepFactories:
args = args.copy()
try:
step = factory(**args)
except:
log.msg("error while creating step, factory=%s, args=%s"
% (factory, args))
raise
step.setBuild(self)
step.setBuildSlave(self.slavebuilder.slave)
step.setDefaultWorkdir(self.workdir)
name = step.name
count = 1
# LOCAL MOZILLA PATCH:
# buildbotcustom.process.factory.ReleaseTaggingFactory uses
# more than 100 ShellCommands when it runs - this has been bumped up
# to support that. upstream buildbot bug here:
# http://buildbot.net/trac/ticket/366
while name in stepnames and count < 1000:
count += 1
name = step.name + "_%d" % count
if name in stepnames:
raise RuntimeError("duplicate step '%s'" % step.name)
step.name = name
stepnames.append(name)
self.steps.append(step)
# tell the BuildStatus about the step. This will create a
# BuildStepStatus and bind it to the Step.
step_status = self.build_status.addStepWithName(name)
step.setStepStatus(step_status)
sp = None
if self.useProgress:
# XXX: maybe bail if step.progressMetrics is empty? or skip
# progress for that one step (i.e. "it is fast"), or have a
# separate "variable" flag that makes us bail on progress
# tracking
sp = step.setupProgress()
if sp:
sps.append(sp)
# Create a buildbot.status.progress.BuildProgress object. This is
# called once at startup to figure out how to build the long-term
# Expectations object, and again at the start of each build to get a
# fresh BuildProgress object to track progress for that individual
# build. TODO: revisit at-startup call
if self.useProgress:
self.progress = BuildProgress(sps)
if self.progress and expectations:
self.progress.setExpectationsFrom(expectations)
# we are now ready to set up our BuildStatus.
self.build_status.setSourceStamp(self.source)
self.build_status.setReason(self.reason)
self.build_status.setBlamelist(self.blamelist())
self.build_status.setProgress(self.progress)
self.results = [] # list of FAILURE, SUCCESS, WARNINGS, SKIPPED
self.result = SUCCESS # overall result, may downgrade after each step
self.text = [] # list of text string lists (text2)