| Method Summary |
| |
__init__(self,
workdir,
mode,
alwaysUseLatest,
timeout,
retry,
**kwargs) |
| |
commandComplete(self,
cmd)
This is a general-purpose hook method for subclasses. |
| |
computeSourceRevision(self,
changes)
Each subclass must implement this method to do something more precise
than -rHEAD every time. |
| |
describe(self,
done)
|
| |
start(self)
Begin the step. |
| Inherited from LoggingBuildStep |
| |
checkDisconnect(self,
f) |
| |
createSummary(self,
log)
To create summary logs, do something like this: warnings =
grep('^Warning:', log.getText()) self.addCompleteLog('warnings',
warnings) |
| |
evaluateCommand(self,
cmd)
Decide whether the command was SUCCESS, WARNINGS, or FAILURE. |
| |
getColor(self,
cmd,
results) |
| |
getText(self,
cmd,
results) |
| |
getText2(self,
cmd,
results)
We have decided to add a short note about ourselves to the overall
build description, probably because something went wrong. |
| |
interrupt(self,
reason)
Halt the command, either because the user has decided to cancel the
build ('reason' is a string), or because the slave has disconnected
('reason' is a ConnectionLost Failure). |
| |
maybeGetText2(self,
cmd,
results) |
| |
setStatus(self,
cmd,
results) |
| |
setupLogfiles(self,
cmd,
logfiles)
Set up any additional logfiles= logs. |
| |
startCommand(self,
cmd,
errorMessages) |
| Inherited from BuildStep |
| |
acquireLocks(self,
res) |
| |
addCompleteLog(self,
name,
text) |
| |
addHTMLLog(self,
name,
html) |
| |
addLog(self,
name) |
| |
addLogObserver(self,
logname,
observer) |
| |
addURL(self,
name,
url)
Add a BuildStep URL to this step. |
| |
failed(self,
why) |
| |
finished(self,
results) |
| |
getProperty(self,
propname) |
| |
getSlaveName(self) |
| |
releaseLocks(self) |
| |
runCommand(self,
c) |
| |
setProgress(self,
metric,
value)
BuildSteps can call self.setProgress() to announce progress along some
metric. |
| |
setProperty(self,
propname,
value) |
| |
setStepStatus(self,
step_status) |
| |
setupProgress(self) |
| |
slaveVersion(self,
command,
oldversion)
Return the version number of the given slave command. |
| |
slaveVersionIsOlderThan(self,
command,
minversion) |
| |
startStep(self,
remote)
Begin the step. |
__init__(self,
workdir,
mode='update',
alwaysUseLatest=False,
timeout=1200,
retry=None,
**kwargs)
(Constructor)
-
- Parameters:
workdir -
local directory (relative to the Builder's root) where the
tree should be placed
(type=string)
mode -
the kind of VC operation that is desired:
-
'update': specifies that the checkout/update should be
performed directly into the workdir. Each build is performed
in the same directory, allowing for incremental builds. This
minimizes disk space, bandwidth, and CPU time. However, it
may encounter problems if the build process does not handle
dependencies properly (if you must sometimes do a 'clean
build' to make sure everything gets compiled), or if source
files are deleted but generated files can influence test
behavior (e.g. python's .pyc files), or when source
directories are deleted but generated files prevent CVS from
removing them.
-
'copy': specifies that the source-controlled workspace
should be maintained in a separate directory (called the
'copydir'), using checkout or update as necessary. For each
build, a new workdir is created with a copy of the source
tree (rm -rf workdir; cp -r copydir workdir). This doubles
the disk space required, but keeps the bandwidth low (update
instead of a full checkout). A full 'clean' build is
performed each time. This avoids any generated-file build
problems, but is still occasionally vulnerable to problems
such as a CVS repository being manually rearranged (causing
CVS errors on update) which are not an issue with a full
checkout.
-
'clobber': specifies that the working directory should be
deleted each time, necessitating a full checkout for each
build. This insures a clean build off a complete checkout,
avoiding any of the problems described above, but is
bandwidth intensive, as the whole source tree must be pulled
down for each build.
-
'export': is like 'clobber', except that e.g. the 'cvs
export' command is used to create the working directory. This
command removes all VC metadata files (the CVS/.svn/{arch}
directories) from the tree, which is sometimes useful for
creating source tarballs (to avoid including the metadata in
the tar file). Not all VC systems support export.
(type=string)
alwaysUseLatest -
whether to always update to the most recent available sources
for this build.
Normally the Source step asks its Build for a list of all
Changes that are supposed to go into the build, then computes a
'source stamp' (revision number or timestamp) that will cause
exactly that set of changes to be present in the checked out
tree. This is turned into, e.g., 'cvs update -D timestamp', or
'svn update -r revnum'. If alwaysUseLatest=True, bypass this
computation and always update to the latest available sources for
each build.
The source stamp helps avoid a race condition in which someone
commits a change after the master has decided to start a build
but before the slave finishes checking out the sources. At best
this results in a build which contains more changes than the
buildmaster thinks it has (possibly resulting in the wrong person
taking the blame for any problems that result), at worst is can
result in an incoherent set of sources (splitting a non-atomic
commit) which may not build at all.
(type=boolean)
retry -
if provided, VC update failures are re-attempted up to REPEATS
times, with DELAY seconds between each attempt. Some users have
slaves with poor connectivity to their VC repository, and they
say that up to 80% of their build failures are due to transient
network failures that could be handled by simply retrying a
couple times.
(type=tuple of ints (delay, repeats) (or None))
- Overrides:
buildbot.process.buildstep.LoggingBuildStep.__init__
|
start(self)
Begin the step. Override this method and add code to do local
processing, fire off remote commands, etc.
To spawn a command in the buildslave, create a RemoteCommand
instance and run it with self.runCommand:
c = RemoteCommandFoo(args)
d = self.runCommand(c)
d.addCallback(self.fooDone).addErrback(self.failed)
As the step runs, it should send status information to the
BuildStepStatus:
self.step_status.setColor('red')
self.step_status.setText(['compile', 'failed'])
self.step_status.setText2(['4', 'warnings'])
To have some code parse stdio (or other log stream) in realtime, add
a LogObserver subclass. This observer can use self.step.setProgress()
to provide better progress notification to the step.:
self.addLogObserver('stdio', MyLogObserver())
To add a LogFile, use self.addLog. Make sure it gets closed when it
finishes. When giving a Logfile to a RemoteShellCommand, just ask it to
close the log when the command completes:
log = self.addLog('output')
cmd = RemoteShellCommand(args)
cmd.useLog(log, closeWhenFinished=True)
You can also create complete Logfiles with generated text in a
single step:
self.addCompleteLog('warnings', text)
When the step is done, it should call self.finished(result).
'result' will be provided to the buildbot.process.base.Build, and should
be one of the constants defined above: SUCCESS, WARNINGS, FAILURE, or
SKIPPED.
If the step encounters an exception, it should call
self.failed(why). 'why' should be a Failure object. This automatically
fails the whole build with an exception. It is a good idea to add
self.failed as an errback to any Deferreds you might obtain.
If the step decides it does not need to be run, start() can return
the constant SKIPPED. This fires the callback immediately: it is not
necessary to call .finished yourself. This can also indicate to the
status-reporting mechanism that this step should not be displayed.
-
- Overrides:
buildbot.process.buildstep.BuildStep.start (inherited documentation)
|