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