buildbot.steps.transfer.FileDownload

Package buildbot :: Package steps :: Module transfer :: Class FileDownload

Class FileDownload

BuildStep --+
            |
           FileDownload

Download the first 'maxsize' bytes of a file, from the buildmaster to the buildslave. Set the mode of the file

Arguments:

['mastersrc'] filename of source file at master
['slavedest'] filename of destination file at slave
['workdir']   string with slave working directory relative to builder
              base dir, default 'build'
['maxsize']   maximum size of the file, default None (=unlimited)
['blocksize'] maximum size of each block being transfered
['mode']      use this to set the access permissions of the resulting
              buildslave-side file. This is traditionally an octal
              integer, like 0644 to be world-readable (but not
              world-writable), or 0600 to only be readable by
              the buildslave account, or 0755 to be world-executable.
              The default (=None) is to leave it up to the umask of
              the buildslave process.

Method Summary
	`__init__(self, build, mastersrc, slavedest, workdir, maxsize, blocksize, mode, **buildstep_kwargs)`
	`finished(self, result)`
	`start(self)` Begin the step.
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)`
	`getProperty(self, propname)`
	`getSlaveName(self)`
	`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).
	`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.

Instance Variable Summary
Inherited from BuildStep
`buildbot.process.base.Build`	`build`: the parent Build which is executing this step
`buildbot.status.progress.StepProgress`	`progress`: tracks ETA for the step
`buildbot.status.builder.BuildStepStatus`	`step_status`: collects output status

Class Variable Summary
`str`	`name` = `'download'`
Inherited from BuildStep
`bool`	`flunkOnFailure` = `False`
`bool`	`flunkOnWarnings` = `False`
`bool`	`haltOnFailure` = `False`
`list`	`locks` = `[]`
`list`	`parms` = `['build', 'name', 'locks', 'haltOnFailure', 'flu...`
`tuple`	`progressMetrics` = `()`
`bool`	`useProgress` = `True`
`bool`	`warnOnFailure` = `False`
`bool`	`warnOnWarnings` = `False`

Method Details

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)

Class Variable Details

name

Type:: str
Value:: 'download'

Generated by Epydoc 2.1 on Sun Dec 10 22:04:44 2006

http://epydoc.sf.net