I run a 'lint' checker over a set of .xhtml files. Any deviations from
recommended style is flagged and put in the output log.
This step looks at .changes in the parent Build to extract a list of
Lore XHTML files to check.
| Method Summary |
| |
__init__(self,
python,
**kwargs)
|
| |
commandComplete(self,
cmd)
This is a general-purpose hook method for subclasses. |
| |
evaluateCommand(self,
cmd)
Decide whether the command was SUCCESS, WARNINGS, or FAILURE. |
| |
getText2(self,
cmd,
results)
We have decided to add a short note about ourselves to the overall
build description, probably because something went wrong. |
| |
start(self)
Begin the step. |
| Inherited from ShellCommand |
| |
checkForOldSlaveAndLogfiles(self) |
| |
describe(self,
done)
Return a list of short strings to describe this step, for the status
display. |
| |
setCommand(self,
command) |
| |
setupEnvironment(self,
cmd) |
| 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) |
| |
getColor(self,
cmd,
results) |
| |
getText(self,
cmd,
results) |
| |
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. |
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.steps.shell.ShellCommand.start (inherited documentation)
|