def start(self):
slavever = self.slaveVersion('stat')
if not slavever:
raise BuildSlaveTooOldError("slave is too old, does not know "
"about stat")
cmd = LoggedRemoteCommand('stat', {'file': self.file})
d = self.runCommand(cmd)
d.addCallback(lambda res: self.commandComplete(cmd))
d.addErrback(self.failed)
def start(self):
slavever = self.slaveVersion('rmdir')
if not slavever:
raise BuildSlaveTooOldError("slave is too old, does not know "
"about rmdir")
cmd = buildstep.RemoteCommand('rmdir', {'dir': self.dir})
d = self.runCommand(cmd)
d.addCallback(lambda res: self.commandComplete(cmd))
d.addErrback(self.failed)
def start(self):
version = self.slaveVersion("uploadFile")
if not version:
m = "slave is too old, does not know about uploadFile"
raise BuildSlaveTooOldError(m)
source = self.slavesrc
masterdest = self.masterdest
# we rely upon the fact that the buildmaster runs chdir'ed into its
# basedir to make sure that relative paths in masterdest are expanded
# properly. TODO: maybe pass the master's basedir all the way down
# into the BuildStep so we can do this better.
masterdest = os.path.expanduser(masterdest)
log.msg("FileUpload started, from slave %r to master %r" %
(source, masterdest))
self.step_status.setText(['uploading', os.path.basename(source)])
if self.url is not None:
self.addURL(os.path.basename(masterdest), self.url)
# we use maxsize to limit the amount of data on both sides
fileWriter = _FileWriter(masterdest, self.maxsize, self.mode)
if self.keepstamp and self.slaveVersionIsOlderThan(
"uploadFile", "2.13"):
m = (
"This buildslave (%s) does not support preserving timestamps. "
"Please upgrade the buildslave." % self.build.slavename)
raise BuildSlaveTooOldError(m)
# default arguments
args = {
'slavesrc': source,
'workdir': self._getWorkdir(),
'writer': fileWriter,
'maxsize': self.maxsize,
'blocksize': self.blocksize,
'keepstamp': self.keepstamp,
}
self.cmd = StatusRemoteCommand('uploadFile', args)
d = self.runCommand(self.cmd)
d.addCallback(self.finished).addErrback(self.failed)
def startVC(self, branch, revision, patch):
self.args['branch'] = branch
self.args['revision'] = revision
self.args['patch'] = patch
slavever = self.slaveVersion("git")
if not slavever:
raise BuildSlaveTooOldError("slave is too old, does not know "
"about git")
cmd = LoggedRemoteCommand("git", self.args)
self.startCommand(cmd)
def startVC(self, branch, revision, patch):
slavever = self.slaveVersion("darcs")
if not slavever:
m = "slave is too old, does not know about darcs"
raise BuildSlaveTooOldError(m)
if self.slaveVersionIsOlderThan("darcs", "1.39"):
if revision:
# TODO: revisit this once we implement computeSourceRevision
m = "0.6.6 slaves can't handle args['revision']"
raise BuildSlaveTooOldError(m)
# the slave doesn't know to avoid re-using the same sourcedir
# when the branch changes. We have no way of knowing which branch
# the last build used, so if we're using a non-default branch and
# either 'update' or 'copy' modes, it is safer to refuse to
# build, and tell the user they need to upgrade the buildslave.
if (branch != self.branch
and self.args['mode'] in ("update", "copy")):
m = ("This buildslave (%s) does not know about multiple "
"branches, and using mode=%s would probably build the "
"wrong tree. "
"Refusing to build. Please upgrade the buildslave to "
"buildbot-0.7.0 or newer." %
(self.build.slavename, self.args['mode']))
raise BuildSlaveTooOldError(m)
if self.repourl:
assert not branch # we need baseURL= to use branches
self.args['repourl'] = self.repourl
else:
self.args['repourl'] = self.baseURL + branch
self.args['revision'] = revision
self.args['patch'] = patch
revstuff = []
if branch is not None and branch != self.branch:
revstuff.append("[branch]")
self.description.extend(revstuff)
self.descriptionDone.extend(revstuff)
cmd = RemoteCommand("darcs", self.args)
self.startCommand(cmd)
def start(self):
slavever = self.slaveVersion('rmdir')
if not slavever:
raise BuildSlaveTooOldError("slave is too old, does not know "
"about rmdir")
properties = self.build.getProperties()
cmd = LoggedRemoteCommand('rmdir',
{'dir': properties.render(self.dir)})
d = self.runCommand(cmd)
d.addCallback(lambda res: self.commandComplete(cmd))
d.addErrback(self.failed)
def checkCompatibility(self):
''' Handle compatibility between old slaves/svn clients '''
slavever = self.slaveVersion("svn", "old")
if not slavever:
m = "slave does not have the 'svn' command"
raise BuildSlaveTooOldError(m)
if self.slaveVersionIsOlderThan("svn", "1.39"):
# the slave doesn't know to avoid re-using the same sourcedir
# when the branch changes. We have no way of knowing which branch
# the last build used, so if we're using a non-default branch and
# either 'update' or 'copy' modes, it is safer to refuse to
# build, and tell the user they need to upgrade the buildslave.
if (self.args['branch'] != self.branch
and self.args['mode'] in ("update", "copy")):
m = ("This buildslave (%s) does not know about multiple "
"branches, and using mode=%s would probably build the "
"wrong tree. "
"Refusing to build. Please upgrade the buildslave to "
"buildbot-0.7.0 or newer." %
(self.build.slavename, self.args['mode']))
raise BuildSlaveTooOldError(m)
if (self.depth is not None) and self.slaveVersionIsOlderThan(
"svn", "2.9"):
m = ("This buildslave (%s) does not support svn depth "
"arguments. Refusing to build. "
"Please upgrade the buildslave." % (self.build.slavename))
raise BuildSlaveTooOldError(m)
if (self.username is not None or self.password is not None) \
and self.slaveVersionIsOlderThan("svn", "2.8"):
m = ("This buildslave (%s) does not support svn usernames "
"and passwords. "
"Refusing to build. Please upgrade the buildslave to "
"buildbot-0.7.10 or newer." % (self.build.slavename, ))
raise BuildSlaveTooOldError(m)
def start(self):
version = self.slaveVersion("downloadFile")
if not version:
m = "slave is too old, does not know about downloadFile"
raise BuildSlaveTooOldError(m)
self.step_status.setText(['creating', 'snippets'])
self.stdio_log = self.addLog("stdio")
self.stdio_log.addStdout("Starting snippet generation\n")
d = self.makeSnippet()
d.addCallback(self.finished).addErrback(self.failed)
def __call__(self, step):
slavever = step.slaveVersion('stat')
if not slavever:
raise BuildSlaveTooOldError("slave is too old, does not know "
"about stat")
def commandComplete(cmd):
# False if any filesystem object with the given name exists.
return (cmd.rc != 0)
cmd = LoggedRemoteCommand('stat', {'file': self.filename})
d = step.runCommand(cmd)
d.addCallback(lambda res: commandComplete(cmd))
return d
def startVC(self, branch, revision, patch):
slavever = self.slaveVersion("mtn")
if not slavever:
raise BuildSlaveTooOldError("slave is too old, does not know "
"about mtn")
self.args['repourl'] = self.repourl
if branch:
self.args['branch'] = branch
self.args['revision'] = revision
self.args['patch'] = patch
cmd = RemoteCommand("mtn", self.args)
self.startCommand(cmd)
def _start(self):
self.args['command'] = self.command
if self.remote_command == "shell":
# non-ShellCommand slavecommands are responsible for doing this
# fixup themselves
if self.step.slaveVersion("shell", "old") == "old":
self.args['dir'] = self.args['workdir']
if ('user' in self.args
and self.step.slaveVersionIsOlderThan("shell", "2.16")):
m = "slave does not support the 'user' parameter"
raise BuildSlaveTooOldError(m)
what = "command '%s' in dir '%s'" % (self.args['command'],
self.args['workdir'])
log.msg(what)
return RemoteCommand._start(self)
def checkSlaveVersion(self, cmd, branch):
warnings = []
slavever = self.slaveVersion(cmd)
if not slavever:
m = "slave is too old, does not know about %s" % cmd
raise BuildSlaveTooOldError(m)
# slave 1.28 and later understand 'revision'
if self.slaveVersionIsOlderThan(cmd, "1.28"):
if not self.alwaysUseLatest:
# we don't know whether our requested revision is the latest
# or not. If the tree does not change very quickly, this will
# probably build the right thing, so emit a warning rather
# than refuse to build at all
m = "WARNING, buildslave is too old to use a revision"
log.msg(m)
warnings.append(m + "\n")
if self.slaveVersionIsOlderThan(cmd, "1.39"):
# the slave doesn't know to avoid re-using the same sourcedir
# when the branch changes. We have no way of knowing which branch
# the last build used, so if we're using a non-default branch and
# either 'update' or 'copy' modes, it is safer to refuse to
# build, and tell the user they need to upgrade the buildslave.
if (branch != self.branch
and self.args['mode'] in ("update", "copy")):
m = ("This buildslave (%s) does not know about multiple "
"branches, and using mode=%s would probably build the "
"wrong tree. "
"Refusing to build. Please upgrade the buildslave to "
"buildbot-0.7.0 or newer." %
(self.build.slavename, self.args['mode']))
log.msg(m)
raise BuildSlaveTooOldError(m)
return warnings
def start(self):
slavever = self.slaveVersion('cpdir')
if not slavever:
raise BuildSlaveTooOldError("slave is too old, does not know "
"about cpdir")
args = {'fromdir': self.src, 'todir': self.dest}
if self.timeout:
args['timeout'] = self.timeout
if self.maxTime:
args['maxTime'] = self.maxTime
cmd = remotecommand.RemoteCommand('cpdir', args)
d = self.runCommand(cmd)
d.addCallback(lambda res: self.commandComplete(cmd))
d.addErrback(self.failed)
def start(self):
self.checkSlaveVersion("uploadDirectory")
self.checkSlaveVersion("uploadFile")
self.checkSlaveVersion("stat")
masterdest = os.path.expanduser(self.masterdest)
sources = self.slavesrcs
if self.keepstamp and self.slaveVersionIsOlderThan(
"uploadFile", "2.13"):
m = (
"This buildslave (%s) does not support preserving timestamps. "
"Please upgrade the buildslave." % self.build.slavename)
raise BuildSlaveTooOldError(m)
if not sources:
return self.finished(SKIPPED)
@defer.inlineCallbacks
def uploadSources():
for source in sources:
result = yield self.startUpload(source, masterdest)
if result == FAILURE:
defer.returnValue(FAILURE)
return
defer.returnValue(SUCCESS)
d = uploadSources()
@d.addCallback
def allUploadsDone(result):
d = defer.maybeDeferred(self.allUploadsDone, result, sources,
masterdest)
d.addCallback(lambda _: result)
return d
log.msg("MultipleFileUpload started, from slave %r to master %r" %
(sources, masterdest))
nsrcs = len(sources)
self.step_status.setText([
'uploading',
'%d %s' % (nsrcs, 'file' if nsrcs == 1 else 'files')
])
d.addCallback(self.finished).addErrback(self.failed)
def startVC(self, branch, revision, patch):
if self.slaveVersionIsOlderThan("cvs", "1.39"):
# the slave doesn't know to avoid re-using the same sourcedir
# when the branch changes. We have no way of knowing which branch
# the last build used, so if we're using a non-default branch and
# either 'update' or 'copy' modes, it is safer to refuse to
# build, and tell the user they need to upgrade the buildslave.
if (branch != self.branch
and self.args['mode'] in ("update", "copy")):
m = ("This buildslave (%s) does not know about multiple "
"branches, and using mode=%s would probably build the "
"wrong tree. "
"Refusing to build. Please upgrade the buildslave to "
"buildbot-0.7.0 or newer." %
(self.build.slavename, self.args['mode']))
log.msg(m)
raise BuildSlaveTooOldError(m)
if branch is None:
branch = "HEAD"
self.args['branch'] = branch
self.args['revision'] = revision
self.args['patch'] = patch
if self.args['branch'] == "HEAD" and self.args['revision']:
# special case. 'cvs update -r HEAD -D today' gives no files
# TODO: figure out why, see if it applies to -r BRANCH
self.args['branch'] = None
# deal with old slaves
warnings = []
slavever = self.slaveVersion("cvs", "old")
if slavever == "old":
# 0.5.0
if self.args['mode'] == "export":
self.args['export'] = 1
elif self.args['mode'] == "clobber":
self.args['clobber'] = 1
elif self.args['mode'] == "copy":
self.args['copydir'] = "source"
self.args['tag'] = self.args['branch']
assert not self.args['patch'] # 0.5.0 slave can't do patch
cmd = LoggedRemoteCommand("cvs", self.args)
self.startCommand(cmd, warnings)
def start(self):
properties = self.build.getProperties()
version = self.slaveVersion("downloadFile")
if not version:
m = "slave is too old, does not know about downloadFile"
raise BuildSlaveTooOldError(m)
# we are currently in the buildmaster's basedir, so any non-absolute
# paths will be interpreted relative to that
source = os.path.expanduser(properties.render(self.mastersrc))
slavedest = properties.render(self.slavedest)
log.msg("FileDownload started, from master %r to slave %r" %
(source, slavedest))
self.step_status.setColor('yellow')
self.step_status.setText(
['downloading', "to",
os.path.basename(slavedest)])
# setup structures for reading the file
try:
fp = open(source, 'rb')
except IOError:
# if file does not exist, bail out with an error
self.addCompleteLog('stderr',
'File %r not available at master' % source)
# TODO: once BuildStep.start() gets rewritten to use
# maybeDeferred, just re-raise the exception here.
reactor.callLater(0, BuildStep.finished, self, FAILURE)
return
fileReader = _FileReader(fp)
# default arguments
args = {
'slavedest': slavedest,
'maxsize': self.maxsize,
'reader': fileReader,
'blocksize': self.blocksize,
'workdir': self.workdir,
'mode': self.mode,
}
self.cmd = StatusRemoteCommand('downloadFile', args)
d = self.runCommand(self.cmd)
d.addCallback(self.finished).addErrback(self.failed)
def startVC(self, branch, revision, patch):
slavever = self.slaveVersion('git')
if not slavever:
raise BuildSlaveTooOldError("slave is too old, does not know "
"about git")
self.branch = branch or 'master'
self.revision = revision
self.method = self._getMethod()
self.stdio_log = self.addLog("stdio")
if self.mode == 'incremental':
d = self.incremental()
elif self.mode == 'full':
d = self.full()
d.addCallback(self.parseGotRevision)
d.addCallback(self.finish)
d.addErrback(self.failed)
return d
def start(self):
version = self.slaveVersion("uploadDirectory")
if not version:
m = "slave is too old, does not know about uploadDirectory"
raise BuildSlaveTooOldError(m)
source = self.slavesrc
masterdest = self.masterdest
# we rely upon the fact that the buildmaster runs chdir'ed into its
# basedir to make sure that relative paths in masterdest are expanded
# properly. TODO: maybe pass the master's basedir all the way down
# into the BuildStep so we can do this better.
masterdest = os.path.expanduser(masterdest)
log.msg("DirectoryUpload started, from slave %r to master %r" %
(source, masterdest))
self.step_status.setText(['uploading', os.path.basename(source)])
if self.url is not None:
self.addURL(os.path.basename(masterdest), self.url)
# we use maxsize to limit the amount of data on both sides
dirWriter = _DirectoryWriter(masterdest, self.maxsize, self.compress,
0600)
# default arguments
args = {
'slavesrc': source,
'workdir': self._getWorkdir(),
'writer': dirWriter,
'maxsize': self.maxsize,
'blocksize': self.blocksize,
'compress': self.compress
}
self.cmd = makeStatusRemoteCommand(self, 'uploadDirectory', args)
d = self.runCommand(self.cmd)
@d.addErrback
def cancel(res):
dirWriter.cancel()
return res
d.addCallback(self.finished).addErrback(self.failed)
def start(self):
self.checkSlaveHasCommand("uploadFile")
source = self.slavesrc
masterdest = self.masterdest
# we rely upon the fact that the buildmaster runs chdir'ed into its
# basedir to make sure that relative paths in masterdest are expanded
# properly. TODO: maybe pass the master's basedir all the way down
# into the BuildStep so we can do this better.
masterdest = os.path.expanduser(masterdest)
log.msg("FileUpload started, from slave %r to master %r" %
(source, masterdest))
self.descriptionDone = "uploading %s" % os.path.basename(source)
if self.url is not None:
self.addURL(os.path.basename(os.path.normpath(masterdest)),
self.url)
# we use maxsize to limit the amount of data on both sides
fileWriter = remotetransfer.FileWriter(masterdest, self.maxsize,
self.mode)
if self.keepstamp and self.slaveVersionIsOlderThan(
"uploadFile", "2.13"):
m = (
"This buildslave (%s) does not support preserving timestamps. "
"Please upgrade the buildslave." % self.build.slavename)
raise BuildSlaveTooOldError(m)
# default arguments
args = {
'slavesrc': source,
'workdir': self.workdir,
'writer': fileWriter,
'maxsize': self.maxsize,
'blocksize': self.blocksize,
'keepstamp': self.keepstamp,
}
cmd = makeStatusRemoteCommand(self, 'uploadFile', args)
d = self.runTransferCommand(cmd, fileWriter)
d.addCallback(self.finished).addErrback(self.failed)
def start(self):
if self.suppressionFile == None:
return ShellCommand.start(self)
version = self.slaveVersion("uploadFile")
if not version:
m = "Slave is too old, does not know about uploadFile"
raise BuildSlaveTooOldError(m)
self.myFileWriter = StringFileWriter()
args = {
'slavesrc': self.suppressionFile,
'workdir': self.workdir,
'writer': self.myFileWriter,
'maxsize': None,
'blocksize': 32 * 1024,
}
cmd = SilentRemoteCommand('uploadFile', args)
d = self.runCommand(cmd)
d.addCallback(self.uploadDone)
d.addErrback(self.failed)
def startVC(self, branch, revision, patch):
slavever = self.slaveVersion("hg")
if not slavever:
raise BuildSlaveTooOldError("slave is too old, does not know "
"about hg")
if self.repourl:
assert not branch # we need baseURL= to use branches
self.args['repourl'] = self.repourl
else:
self.args['repourl'] = self.baseURL + branch
self.args['revision'] = revision
self.args['patch'] = patch
revstuff = []
if branch is not None and branch != self.branch:
revstuff.append("[branch]")
self.description.extend(revstuff)
self.descriptionDone.extend(revstuff)
cmd = LoggedRemoteCommand("hg", self.args)
self.startCommand(cmd)
def __call__(self, step):
slavever = step.slaveVersion('stat')
if not slavever:
raise BuildSlaveTooOldError("slave is too old, does not know "
"about stat")
def commandComplete(cmd):
if cmd.rc != 0:
return False
s = cmd.updates["stat"][-1]
filemode = s[stat.ST_MODE]
if stat.S_ISREG(filemode) or stat.S_ISLNK(filemode):
# True only if this is a file or a link and not any other file
# system object.
return True
else:
return False
cmd = LoggedRemoteCommand('stat', {'file': self.filename})
d = step.runCommand(cmd)
d.addCallback(lambda res: commandComplete(cmd))
return d
def start(self):
version = self.slaveVersion("uploadFile")
properties = self.build.getProperties()
if not version:
m = "slave is too old, does not know about uploadFile"
raise BuildSlaveTooOldError(m)
source = properties.render(self.slavesrc)
masterdest = properties.render(self.masterdest)
# we rely upon the fact that the buildmaster runs chdir'ed into its
# basedir to make sure that relative paths in masterdest are expanded
# properly. TODO: maybe pass the master's basedir all the way down
# into the BuildStep so we can do this better.
masterdest = os.path.expanduser(masterdest)
log.msg("FileUpload started, from slave %r to master %r" %
(source, masterdest))
self.step_status.setColor('yellow')
self.step_status.setText(['uploading', os.path.basename(source)])
# we use maxsize to limit the amount of data on both sides
fileWriter = _FileWriter(masterdest, self.maxsize, self.mode)
# default arguments
args = {
'slavesrc': source,
'workdir': self.workdir,
'writer': fileWriter,
'maxsize': self.maxsize,
'blocksize': self.blocksize,
}
self.cmd = StatusRemoteCommand('uploadFile', args)
d = self.runCommand(self.cmd)
d.addCallback(self.finished).addErrback(self.failed)
def checkInstall(hgInstalled):
if not hgInstalled:
raise BuildSlaveTooOldError(
"Mercurial is not installed on slave")
return 0
def checkInstall(svnInstalled):
if not svnInstalled:
raise BuildSlaveTooOldError("SVN is not installed on slave")
return 0
def checkInstall(darcsInstalled):
if not darcsInstalled:
raise BuildSlaveTooOldError("Darcs is not installed on slave")
return 0
def checkInstall(p4Installed):
if not p4Installed:
raise BuildSlaveTooOldError("p4 is not installed on slave")
return 0
def checkInstall(monotoneInstalled):
if not monotoneInstalled:
raise BuildSlaveTooOldError(
"Monotone is not installed on slave")
return 0
def checkInstall(bzrInstalled):
if not bzrInstalled:
raise BuildSlaveTooOldError("bzr is not installed on slave")
return 0
def checkInstall(gitInstalled):
if not gitInstalled:
raise BuildSlaveTooOldError("git is not installed on slave")
return 0
