def __init__(
self,
command,
description=None,
descriptionDone=None,
descriptionSuffix=None,
env=None,
path=None,
usePTY=0,
interruptSignal="KILL",
**kwargs
):
BuildStep.__init__(self, **kwargs)
self.command = command
if description:
self.description = description
if isinstance(self.description, str):
self.description = [self.description]
if descriptionDone:
self.descriptionDone = descriptionDone
if isinstance(self.descriptionDone, str):
self.descriptionDone = [self.descriptionDone]
if descriptionSuffix:
self.descriptionSuffix = descriptionSuffix
if isinstance(self.descriptionSuffix, str):
self.descriptionSuffix = [self.descriptionSuffix]
self.env = env
self.path = path
self.usePTY = usePTY
self.interruptSignal = interruptSignal
def __init__(self, **kwargs):
BuildStep.__init__(self, **kwargs)
if self.upstreamSteps is None:
raise ValueError("you must supply upstreamSteps")
if len(self.upstreamSteps) < 1:
raise ValueError("upstreamSteps must be a non-empty list")
if self.idlePolicy not in self.VALID_IDLE_POLICIES:
raise ValueError(
"invalid value for idlePolicy: %r (must be one of %s)"
% (self.idlePolicy,
", ".join(map(repr, self.VALID_IDLE_POLICIES))))
# list of build steps (as BuildStepStatus objects) that we're
# currently waiting on
self._blocking_steps = []
# set of builders (as BuilderStatus objects) that have to start
# a Build before we can block on one of their BuildSteps
self._blocking_builders = set()
self._overall_code = builder.SUCCESS # assume the best
self._overall_text = []
self._timer = None # object returned by reactor.callLater()
self._timed_out = False
def __init__(self, data, log='output', **kwargs):
self.data = data
self.log = log
BuildStep.__init__(self, **kwargs)
self.addFactoryArguments(data=data, log=log)
def __init__(
self,
slavesrc,
masterdest,
workdir="build",
maxsize=None,
blocksize=16 * 1024,
compress=None,
**buildstep_kwargs
):
BuildStep.__init__(self, **buildstep_kwargs)
self.addFactoryArguments(
slavesrc=slavesrc,
masterdest=masterdest,
workdir=workdir,
maxsize=maxsize,
blocksize=blocksize,
compress=compress,
)
self.slavesrc = slavesrc
self.masterdest = masterdest
self.workdir = workdir
self.maxsize = maxsize
self.blocksize = blocksize
assert compress in (None, "gz", "bz2")
self.compress = compress
def __init__(self, command,
description=None, descriptionDone=None, descriptionSuffix=None,
env=None, path=None, usePTY=0,
**kwargs):
BuildStep.__init__(self, **kwargs)
self.addFactoryArguments(description=description,
descriptionDone=descriptionDone,
descriptionSuffix=descriptionSuffix,
env=env, path=path, usePTY=usePTY,
command=command)
self.command=command
if description:
self.description = description
if isinstance(self.description, str):
self.description = [self.description]
if descriptionDone:
self.descriptionDone = descriptionDone
if isinstance(self.descriptionDone, str):
self.descriptionDone = [self.descriptionDone]
if descriptionSuffix:
self.descriptionSuffix = descriptionSuffix
if isinstance(self.descriptionSuffix, str):
self.descriptionSuffix = [self.descriptionSuffix]
self.env=env
self.path=path
self.usePTY=usePTY
def __init__(self, property_name, value, **kwargs):
self.property_name = property_name
self.value = value
BuildStep.__init__(self, **kwargs)
self.addFactoryArguments(property_name=property_name, value=value)
def __init__(self, arch, branch, channel, ostree_dir, **kwargs):
kwargs = self.setupShellMixin(kwargs, prohibitArgs=["command"])
BuildStep.__init__(self, haltOnFailure=True, **kwargs)
self.arch = arch
self.branch = branch
self.channel = channel
self.ostree_dir = ostree_dir
def __init__(self, setup, config, env, **kwargs):
self.setup = setup
self.config = config
self.env_dict = env
self.consumer = None
kwargs = self.setupShellMixin(kwargs, prohibitArgs=['command'])
BuildStep.__init__(self, **kwargs)
def __init__(self, slavesrc, masterdest,
workdir=None, maxsize=None, blocksize=16*1024, mode=None,
keepstamp=False, url=None,
**buildstep_kwargs):
BuildStep.__init__(self, **buildstep_kwargs)
self.addFactoryArguments(slavesrc=slavesrc,
masterdest=masterdest,
workdir=workdir,
maxsize=maxsize,
blocksize=blocksize,
mode=mode,
keepstamp=keepstamp,
url=url,
)
self.slavesrc = slavesrc
self.masterdest = masterdest
self.workdir = workdir
self.maxsize = maxsize
self.blocksize = blocksize
if not isinstance(mode, (int, type(None))):
raise config.ConfigErrors([
'mode must be an integer or None' ])
self.mode = mode
self.keepstamp = keepstamp
self.url = url
def __init__(
self,
slavesrc,
masterdest,
workdir=None,
maxsize=None,
blocksize=16 * 1024,
mode=None,
keepstamp=False,
**buildstep_kwargs
):
BuildStep.__init__(self, **buildstep_kwargs)
self.addFactoryArguments(
slavesrc=slavesrc,
masterdest=masterdest,
workdir=workdir,
maxsize=maxsize,
blocksize=blocksize,
mode=mode,
keepstamp=keepstamp,
)
self.slavesrc = slavesrc
self.masterdest = masterdest
self.workdir = workdir
self.maxsize = maxsize
self.blocksize = blocksize
assert isinstance(mode, (int, type(None)))
self.mode = mode
self.keepstamp = keepstamp
def __init__(self, project, **kwargs):
self.inplace_lines = None
self.project = project
kwargs = self.setupShellMixin(kwargs, prohibitArgs=['command'])
BuildStep.__init__(self,
name=self.NAME,
hideStepIf=ShowStepIfSuccessful, **kwargs)
def __init__(self, objdir, milestone, baseurl, appendDatedDir=True,
snippetType='complete', hashType='SHA512', doStepIf=True,
name='create_update_snippet'):
BuildStep.__init__(self, name=name, doStepIf=doStepIf)
self.addFactoryArguments(
objdir=objdir,
milestone=milestone,
baseurl=baseurl,
appendDatedDir=appendDatedDir
)
# This seems like a reasonable place to store snippets
self.updateDir = path.join(objdir, 'dist', 'update')
self.milestone = milestone
self.baseurl = baseurl
self.hashType = hashType
self.appendDatedDir = appendDatedDir
assert snippetType in ['complete', 'partial']
self.snippetType = snippetType
assert hashType in ['SHA512']
self.hashType = hashType
self.maxsize = 16384
self.mode = None
self.blocksize = 4096
self.cmd = None
self.stdio_log = None
def finished(self, result):
if self.cmd.stderr != '':
self.addCompleteLog('stderr', self.cmd.stderr)
if self.cmd.rc is None or self.cmd.rc == 0:
return BuildStep.finished(self, SUCCESS)
return BuildStep.finished(self, FAILURE)
def __init__(self, command, env=None, workdir=None, usePTY=0, interruptSignal="KILL", **kwargs):
BuildStep.__init__(self, **kwargs)
self.command = command
self.env = env
self.workdir = workdir
self.usePTY = usePTY
self.interruptSignal = interruptSignal
def interrupt(self, reason):
try:
self.process.signalProcess(self.interruptSignal)
except KeyError: # Process not started yet
pass
except error.ProcessExitedAlready:
pass
BuildStep.interrupt(self, reason)
def __init__(self, command, **kwargs):
self.env = kwargs.pop("env", None)
self.usePTY = kwargs.pop("usePTY", 0)
self.interruptSignal = kwargs.pop("interruptSignal", "KILL")
BuildStep.__init__(self, **kwargs)
self.command = command
self.masterWorkdir = self.workdir
def __init__(self, builderNames = None, **kwargs):
if builderNames is None:
raise TypeError('argument builderNames is required')
self.builderNames = builderNames
BuildStep.__init__(self, **kwargs)
self.addFactoryArguments(builderNames = builderNames)
def __init__(self, command, **kwargs):
self.env = kwargs.pop('env', None)
self.usePTY = kwargs.pop('usePTY', 0)
self.interruptSignal = kwargs.pop('interruptSignal', 'KILL')
BuildStep.__init__(self, **kwargs)
self.command = command
self.masterWorkdir = self.workdir
def finished(self, result):
if self.cmd.stderr != '':
self.addCompleteLog('stderr', self.cmd.stderr)
if self.cmd.rc is None or self.cmd.rc == 0:
self.step_status.setColor('green')
return BuildStep.finished(self, SUCCESS)
self.step_status.setColor('red')
return BuildStep.finished(self, FAILURE)
def __init__(self, timeout=5, **kwargs):
"""
@type timeout: int
@param timeout: the number of seconds to delay before completing
"""
BuildStep.__init__(self, **kwargs)
self.addFactoryArguments(timeout=timeout)
self.timeout = timeout
self.timer = None
def __init__(self, schedulerNames=None, sourceStamp=None, sourceStamps=None,
updateSourceStamp=None, alwaysUseLatest=False,
waitForFinish=False, set_properties=None,
copy_properties=None, parent_relationship="Triggered from",
unimportantSchedulerNames=None, **kwargs):
if schedulerNames is None:
schedulerNames = []
if unimportantSchedulerNames is None:
unimportantSchedulerNames = []
if not schedulerNames:
config.error(
"You must specify a scheduler to trigger")
if (sourceStamp or sourceStamps) and (updateSourceStamp is not None):
config.error(
"You can't specify both sourceStamps and updateSourceStamp")
if (sourceStamp or sourceStamps) and alwaysUseLatest:
config.error(
"You can't specify both sourceStamps and alwaysUseLatest")
if alwaysUseLatest and (updateSourceStamp is not None):
config.error(
"You can't specify both alwaysUseLatest and updateSourceStamp"
)
if not set(schedulerNames).issuperset(set(unimportantSchedulerNames)):
config.error(
"unimportantSchedulerNames must be a subset of schedulerNames"
)
self.schedulerNames = schedulerNames
self.unimportantSchedulerNames = unimportantSchedulerNames
self.sourceStamps = sourceStamps or []
if sourceStamp:
self.sourceStamps.append(sourceStamp)
if updateSourceStamp is not None:
self.updateSourceStamp = updateSourceStamp
else:
self.updateSourceStamp = not (alwaysUseLatest or self.sourceStamps)
self.alwaysUseLatest = alwaysUseLatest
self.waitForFinish = waitForFinish
if set_properties is None:
set_properties = {}
if copy_properties is None:
copy_properties = []
properties = {}
properties.update(set_properties)
for i in copy_properties:
properties[i] = Property(i)
self.set_properties = properties
self.parent_relationship = parent_relationship
self.running = False
self.ended = False
self.brids = []
self.triggeredNames = None
self.waitForFinishDeferred = None
BuildStep.__init__(self, **kwargs)
def __init__(self, command,
env=None, workdir=None, usePTY=0, interruptSignal="KILL",
**kwargs):
BuildStep.__init__(self, **kwargs)
self.command = command
self.env = env
self.workdir = workdir
self.usePTY = usePTY
self.interruptSignal = interruptSignal
def finished(self, result):
# Subclasses may choose to skip a transfer. In those cases, self.cmd
# will be None, and we should just let BuildStep.finished() handle
# the rest
if result == SKIPPED:
return BuildStep.finished(self, SKIPPED)
if self.cmd.didFail():
return BuildStep.finished(self, FAILURE)
return BuildStep.finished(self, SUCCESS)
def __init__(self, command, **kwargs):
self.env = kwargs.pop('env', None)
self.usePTY = kwargs.pop('usePTY', 0)
self.interruptSignal = kwargs.pop('interruptSignal', 'KILL')
self.logEnviron = kwargs.pop('logEnviron', True)
BuildStep.__init__(self, **kwargs)
self.command = command
self.masterWorkdir = self.workdir
def finished(self, result):
# Subclasses may choose to skip a transfer. In those cases, self.cmd
# will be None, and we should just let BuildStep.finished() handle
# the rest
if result == SKIPPED:
return BuildStep.finished(self, SKIPPED)
if self.cmd.didFail():
return BuildStep.finished(self, FAILURE)
return BuildStep.finished(self, SUCCESS)
def test_getSummaryStatistic(self):
b = self.build
b.executedSteps = [BuildStep(), BuildStep(), BuildStep()]
b.executedSteps[0].setStatistic('casualties', 7)
b.executedSteps[2].setStatistic('casualties', 4)
add = operator.add
self.assertEqual(b.getSummaryStatistic('casualties', add), 11)
self.assertEqual(b.getSummaryStatistic('casualties', add, 10), 21)
def setUp(self):
config = """
from buildbot.status import html
from buildbot.process.factory import BasicBuildFactory
from buildbot.buildslave import BuildSlave
f1 = BasicBuildFactory('cvsroot', 'cvsmodule')
BuildmasterConfig = {
'slaves': [BuildSlave('bot1', 'passwd1')],
'schedulers': [],
'builders': [{'name': 'builder1', 'slavename': 'bot1',
'builddir':'workdir', 'factory':f1}],
'slavePortnum': 0,
'status': [html.WebStatus(http_port=0)],
}
"""
if os.path.exists("test_logfile"):
shutil.rmtree("test_logfile")
os.mkdir("test_logfile")
self.master = m = ConfiguredMaster("test_logfile", config)
m.startService()
# hack to find out what randomly-assigned port it is listening on
port = self.find_webstatus(m).getPortnum()
self.port = port
# insert an event
req = base.BuildRequest("reason", sourcestamp.SourceStamp())
build1 = base.Build([req])
bs = m.status.getBuilder("builder1").newBuild()
bs.setReason("reason")
bs.buildStarted(build1)
step1 = BuildStep(name="setup")
step1.setBuild(build1)
bss = bs.addStepWithName("setup")
step1.setStepStatus(bss)
bss.stepStarted()
log1 = step1.addLog("output")
log1.addStdout("some stdout\n")
log1.finish()
log2 = step1.addHTMLLog("error", "<html>ouch</html>")
log3 = step1.addLog("big")
log3.addStdout("big log\n")
for i in range(1000):
log3.addStdout("a" * 500)
log3.addStderr("b" * 500)
log3.finish()
log4 = step1.addCompleteLog("bigcomplete",
"big2 log\n" + "a" * 1 * 1000 * 1000)
step1.step_status.stepFinished(builder.SUCCESS)
bs.buildFinished()
def __init__(self, schedulerNames=None, sourceStamp=None, sourceStamps=None,
updateSourceStamp=None, alwaysUseLatest=False,
waitForFinish=False, set_properties=None,
copy_properties=None, parent_relationship="Triggered from",
unimportantSchedulerNames=None, **kwargs):
if schedulerNames is None:
schedulerNames = []
if unimportantSchedulerNames is None:
unimportantSchedulerNames = []
if not schedulerNames:
config.error(
"You must specify a scheduler to trigger")
if (sourceStamp or sourceStamps) and (updateSourceStamp is not None):
config.error(
"You can't specify both sourceStamps and updateSourceStamp")
if (sourceStamp or sourceStamps) and alwaysUseLatest:
config.error(
"You can't specify both sourceStamps and alwaysUseLatest")
if alwaysUseLatest and (updateSourceStamp is not None):
config.error(
"You can't specify both alwaysUseLatest and updateSourceStamp"
)
if not set(schedulerNames).issuperset(set(unimportantSchedulerNames)):
config.error(
"unimportantSchedulerNames must be a subset of schedulerNames"
)
self.schedulerNames = schedulerNames
self.unimportantSchedulerNames = unimportantSchedulerNames
self.sourceStamps = sourceStamps or []
if sourceStamp:
self.sourceStamps.append(sourceStamp)
if updateSourceStamp is not None:
self.updateSourceStamp = updateSourceStamp
else:
self.updateSourceStamp = not (alwaysUseLatest or self.sourceStamps)
self.alwaysUseLatest = alwaysUseLatest
self.waitForFinish = waitForFinish
if set_properties is None:
set_properties = {}
if copy_properties is None:
copy_properties = []
properties = {}
properties.update(set_properties)
for i in copy_properties:
properties[i] = Property(i)
self.set_properties = properties
self.parent_relationship = parent_relationship
self.running = False
self.ended = False
self.brids = []
self.triggeredNames = None
BuildStep.__init__(self, **kwargs)
def __init__(self, s, slavedest, workdir=None, maxsize=None, blocksize=16 * 1024, mode=None, **buildstep_kwargs):
BuildStep.__init__(self, **buildstep_kwargs)
self.s = s
self.slavedest = slavedest
self.workdir = workdir
self.maxsize = maxsize
self.blocksize = blocksize
if not isinstance(mode, (int, type(None))):
config.error("mode must be an integer or None")
self.mode = mode
def interrupt(self, reason):
if self.running:
BuildStep.interrupt(self, reason)
if self.step_status.isWaitingForLocks():
self.addCompleteLog('interrupt while waiting for locks',
str(reason))
else:
self.addCompleteLog('interrupt', str(reason))
self.running = False
self.finished(EXCEPTION)
def __init__(self):
BuildStep.__init__(self,
haltOnFailure=False,
flunkOnWarnings=False,
flunkOnFailure=True,
warnOnWarnings=True,
warnOnFailure=False,
alwaysRun=False,
name='fake')
self._summary = {u'step': u'result', u'build': u'build result'}
self._expected_results = SUCCESS
def __init__(self, treename, l10nbuilds, cb=None, **kwargs):
"""Create a TreeLoader step. In addition to the standard arguments,
treename is the name of the tree,
l10nbuilds is the local ini file describing the builds,
cb is a callback with signature (tree, changes=None)
"""
BuildStep.__init__(self, **kwargs)
self.addFactoryArguments(treename=treename, l10nbuilds=l10nbuilds, cb=cb)
self.treename = treename
self.l10nbuilds = l10nbuilds
self.cb = cb
def __init__(self, stepToWatchForFailure=None, timeout=2700, **kwargs):
""" timeout - default is 45min because you pay same for 1st hour of EC2 so if an average test takes
10 min to start and 5 minutes, that leaves 45 minutes to $ free
stepToWatchForFailure - is a step in this builder by this name should fail, then this will conditionally hold
otherwise this will not hold. If no step is given, this will ALWAYS hold
"""
BuildStep.__init__(self, **kwargs)
self.addFactoryArguments(timeout=timeout, stepToWatchForFailure=stepToWatchForFailure)
self.defaultTimeout = timeout
self.timer = None
self.stepToWatchForFailure = stepToWatchForFailure
self.doStepIf = self.shouldHold
def finished(self, result):
# Subclasses may choose to skip a transfer. In those cases, self.cmd
# will be None, and we should just let BuildStep.finished() handle
# the rest
if result == SKIPPED:
return BuildStep.finished(self, SKIPPED)
if self.cmd.stderr != '':
self.addCompleteLog('stderr', self.cmd.stderr)
if self.cmd.rc is None or self.cmd.rc == 0:
return BuildStep.finished(self, SUCCESS)
return BuildStep.finished(self, FAILURE)
def finished(self, result):
# Subclasses may choose to skip a transfer. In those cases, self.cmd
# will be None, and we should just let BuildStep.finished() handle
# the rest
if result == SKIPPED:
return BuildStep.finished(self, SKIPPED)
if self.cmd.stderr != '':
self.addCompleteLog('stderr', self.cmd.stderr)
if self.cmd.rc is None or self.cmd.rc == 0:
return BuildStep.finished(self, SUCCESS)
return BuildStep.finished(self, FAILURE)
def __init__(self, treename, l10nbuilds, cb=None, **kwargs):
'''Create a TreeLoader step. In addition to the standard arguments,
treename is the name of the tree,
l10nbuilds is the local ini file describing the builds,
cb is a callback with signature (tree, changes=None)
'''
BuildStep.__init__(self, **kwargs)
self.addFactoryArguments(treename=treename,
l10nbuilds=l10nbuilds,
cb=cb)
self.treename = treename
self.l10nbuilds = l10nbuilds
self.cb = cb
def __init__(self, s, slavedest, workdir=None, maxsize=None, blocksize=16 * 1024, mode=None, **buildstep_kwargs):
BuildStep.__init__(self, **buildstep_kwargs)
self.addFactoryArguments(
s=s, slavedest=slavedest, workdir=workdir, maxsize=maxsize, blocksize=blocksize, mode=mode
)
self.s = s
self.slavedest = slavedest
self.workdir = workdir
self.maxsize = maxsize
self.blocksize = blocksize
assert isinstance(mode, (int, type(None)))
self.mode = mode
def setUp(self):
config = """
from buildbot.status import html
from buildbot.process.factory import BasicBuildFactory
from buildbot.buildslave import BuildSlave
f1 = BasicBuildFactory('cvsroot', 'cvsmodule')
BuildmasterConfig = {
'slaves': [BuildSlave('bot1', 'passwd1')],
'schedulers': [],
'builders': [{'name': 'builder1', 'slavename': 'bot1',
'builddir':'workdir', 'factory':f1}],
'slavePortnum': 0,
'status': [html.WebStatus(http_port=0)],
}
"""
if os.path.exists("test_logfile"):
shutil.rmtree("test_logfile")
os.mkdir("test_logfile")
self.master = m = ConfiguredMaster("test_logfile", config)
m.startService()
# hack to find out what randomly-assigned port it is listening on
port = self.find_webstatus(m).getPortnum()
self.port = port
# insert an event
req = base.BuildRequest("reason", sourcestamp.SourceStamp())
build1 = base.Build([req])
bs = m.status.getBuilder("builder1").newBuild()
bs.setReason("reason")
bs.buildStarted(build1)
step1 = BuildStep(name="setup")
step1.setBuild(build1)
bss = bs.addStepWithName("setup")
step1.setStepStatus(bss)
bss.stepStarted()
log1 = step1.addLog("output")
log1.addStdout("some stdout\n")
log1.finish()
log2 = step1.addHTMLLog("error", "<html>ouch</html>")
log3 = step1.addLog("big")
log3.addStdout("big log\n")
for i in range(1000):
log3.addStdout("a" * 500)
log3.addStderr("b" * 500)
log3.finish()
log4 = step1.addCompleteLog("bigcomplete",
"big2 log\n" + "a" * 1*1000*1000)
step1.step_status.stepFinished(builder.SUCCESS)
bs.buildFinished()
def __init__(self, url, method, **kwargs):
if txrequests is None:
config.error("Need to install txrequest to use this step:\n\n pip install txrequests")
if method not in ('POST', 'GET', 'PUT', 'DELETE', 'HEAD', 'OPTIONS'):
config.error("Wrong method given: '%s' is not known" % method)
self.method = method
self.url = url
for param in HTTPStep.requestsParams:
setattr(self, param, kwargs.pop(param, None))
BuildStep.__init__(self, **kwargs)
def __init__(self, url, method, **kwargs):
if txrequests is None or requests is None:
config.error("Need to install txrequest to use this step:\n\n pip install txrequests")
if method not in ('POST', 'GET', 'PUT', 'DELETE', 'HEAD', 'OPTIONS'):
config.error("Wrong method given: '%s' is not known" % method)
self.method = method
self.url = url
for param in HTTPStep.requestsParams:
setattr(self, param, kwargs.pop(param, None))
BuildStep.__init__(self, **kwargs)
def __init__(self, slavesrc, masterdest,
workdir=None, maxsize=None, blocksize=16*1024,
compress=None, url=None, **buildstep_kwargs):
BuildStep.__init__(self, **buildstep_kwargs)
self.slavesrc = slavesrc
self.masterdest = masterdest
self.workdir = workdir
self.maxsize = maxsize
self.blocksize = blocksize
if compress not in (None, 'gz', 'bz2'):
config.error(
"'compress' must be one of None, 'gz', or 'bz2'")
self.compress = compress
self.url = url
def test_addStep_ArgumentsInTheWrongPlace(self):
self.assertRaises(TypeError,
self.factory.addStep,
BuildStep(),
name="name")
# this also raises a deprecation error, which we don't care about (see
# test_s)
self.flushWarnings()
def finished(self, result):
self.step_status.setText(['create', self.snippetType, 'snippet'])
if self.cmd and self.cmd.stderr != '':
self.addCompleteLog('stderr', self.cmd.stderr)
if self.stdio_log:
self.stdio_log.addStdout("Snippet generation complete\n\n")
if self.cmd:
if self.cmd.rc is None or self.cmd.rc == 0:
# Other BuildSteps will probably want this data.
self.setProperty(
self.snippetType + 'snippetFilename',
path.join(self.updateDir, self.snippetFilename))
return BuildStep.finished(self, SUCCESS)
return BuildStep.finished(self, result)
def __init__(self,
s,
slavedest,
workdir=None,
maxsize=None,
blocksize=16 * 1024,
mode=None,
**buildstep_kwargs):
BuildStep.__init__(self, **buildstep_kwargs)
self.s = s
self.slavedest = slavedest
self.workdir = workdir
self.maxsize = maxsize
self.blocksize = blocksize
if not isinstance(mode, (int, type(None))):
config.error('mode must be an integer or None')
self.mode = mode
def checker(step: BuildStep) -> bool:
if artifact_type not in ['sdks', 'cache', 'build']:
raise ValueError("is_artifact_save_necessary: Unsupported artifact type {!r}".format(artifact_type))
artifact_produced_property = "produce_{}_artifacts".format(artifact_type)
#print("DEBUG: {!r} property = {!r}".format(
# artifact_produced_property, step.getProperty(artifact_produced_property)))
#print("DEBUG: {!r} property .split() = {!r}".format(
# "artifacts_produced", str(step.getProperty("artifacts_produced")).split()))
#print("DEBUG: my boolean evaluation = {!r}".format(
# bool(step.getProperty(artifact_produced_property)) and
# (artifact_type in
# str(step.getProperty("artifacts_produced")).split())
#))
return (
bool(step.getProperty(artifact_produced_property)) and
(artifact_type in
str(step.getProperty("artifacts_produced")).split())
)
def __init__(self, mastersrc, slavedest,
workdir=None, maxsize=None, blocksize=16*1024, mode=None,
**buildstep_kwargs):
BuildStep.__init__(self, **buildstep_kwargs)
self.addFactoryArguments(mastersrc=mastersrc,
slavedest=slavedest,
workdir=workdir,
maxsize=maxsize,
blocksize=blocksize,
mode=mode,
)
self.mastersrc = mastersrc
self.slavedest = slavedest
self.workdir = workdir
self.maxsize = maxsize
self.blocksize = blocksize
assert isinstance(mode, (int, type(None)))
self.mode = mode
def __init__(self, slavesrc, masterdest,
workdir="build", maxsize=None, blocksize=16*1024,
compress=None, **buildstep_kwargs):
BuildStep.__init__(self, **buildstep_kwargs)
self.addFactoryArguments(slavesrc=slavesrc,
masterdest=masterdest,
workdir=workdir,
maxsize=maxsize,
blocksize=blocksize,
compress=compress,
)
self.slavesrc = slavesrc
self.masterdest = masterdest
self.workdir = workdir
self.maxsize = maxsize
self.blocksize = blocksize
assert compress in (None, 'gz', 'bz2')
self.compress = compress
def __init__(self,
command,
description=None,
descriptionDone=None,
**kwargs):
BuildStep.__init__(self, **kwargs)
self.addFactoryArguments(description=description,
descriptionDone=descriptionDone,
command=command)
self.command = command
if description:
self.description = description
if isinstance(self.description, str):
self.description = [self.description]
if descriptionDone:
self.descriptionDone = descriptionDone
if isinstance(self.descriptionDone, str):
self.descriptionDone = [self.descriptionDone]
def __init__(self, objdir, milestone, baseurl, appendDatedDir=True):
BuildStep.__init__(self)
major, minor, point = buildbot.version.split(".", 3)
# Buildbot 0.7.5 and below do not require this
if int(minor) >= 7 and int(point) >= 6:
self.addFactoryArguments(objdir=objdir,
milestone=milestone,
baseurl=baseurl,
appendDatedDir=appendDatedDir)
# This seems like a reasonable place to store snippets
self.updateDir = path.join(objdir, 'dist', 'update')
self.milestone = milestone
self.baseurl = baseurl
self.appendDatedDir = appendDatedDir
self.maxsize = 16384
self.mode = None
self.blocksize = 4096
def __init__(self,
description=None,
descriptionDone=None,
descriptionSuffix=None,
**kw):
BuildStep.__init__(self, **kw)
# GR: taken from master, apparently not handled by base class
if description:
self.description = description
if isinstance(description, str):
self.description = [self.description]
if descriptionDone:
self.descriptionDone = descriptionDone
if isinstance(descriptionDone, str):
self.descriptionDone = [self.descriptionDone]
if descriptionSuffix:
self.descriptionSuffix = descriptionSuffix
if isinstance(descriptionSuffix, str):
self.descriptionSuffix = [self.descriptionSuffix]
def __init__(self,
slavesrc,
masterdest,
workdir=None,
maxsize=None,
blocksize=16 * 1024,
compress=None,
url=None,
**buildstep_kwargs):
BuildStep.__init__(self, **buildstep_kwargs)
self.slavesrc = slavesrc
self.masterdest = masterdest
self.workdir = workdir
self.maxsize = maxsize
self.blocksize = blocksize
if compress not in (None, 'gz', 'bz2'):
config.error("'compress' must be one of None, 'gz', or 'bz2'")
self.compress = compress
self.url = url
def __init__(self, s, slavedest,
workdir=None, maxsize=None, blocksize=16*1024, mode=None,
**buildstep_kwargs):
BuildStep.__init__(self, **buildstep_kwargs)
self.addFactoryArguments(s=s,
slavedest=slavedest,
workdir=workdir,
maxsize=maxsize,
blocksize=blocksize,
mode=mode,
)
self.s = s
self.slavedest = slavedest
self.workdir = workdir
self.maxsize = maxsize
self.blocksize = blocksize
if not isinstance(mode, (int, type(None))):
raise config.ConfigErrors([
'mode must be an integer or None' ])
self.mode = mode
def __init__(self,
slavesrc,
masterdest,
workdir=None,
maxsize=None,
blocksize=16 * 1024,
mode=None,
keepstamp=False,
url=None,
**buildstep_kwargs):
BuildStep.__init__(self, **buildstep_kwargs)
self.slavesrc = slavesrc
self.masterdest = masterdest
self.workdir = workdir
self.maxsize = maxsize
self.blocksize = blocksize
if not isinstance(mode, (int, type(None))):
config.error('mode must be an integer or None')
self.mode = mode
self.keepstamp = keepstamp
self.url = url
def __init__(self, command,
description=None, descriptionDone=None,
env=None, path=None, usePTY=0,
**kwargs):
BuildStep.__init__(self, **kwargs)
self.addFactoryArguments(description=description,
descriptionDone=descriptionDone,
env=env, path=path, usePTY=usePTY,
command=command)
self.command=command
if description:
self.description = description
if isinstance(self.description, str):
self.description = [self.description]
if descriptionDone:
self.descriptionDone = descriptionDone
if isinstance(self.descriptionDone, str):
self.descriptionDone = [self.descriptionDone]
self.env=env
self.path=path
self.usePTY=usePTY
def __init__(self,
builderNames=None,
isRelevant=None,
preProcess=None,
**kwargs):
BuildStep.__init__(self, **kwargs)
self._builder_names = builderNames
if isRelevant is None:
config.error('You must provide a function to check '
'if a build is relevant')
if not callable(isRelevant):
config.error('isRelevant must be a callable')
if preProcess is None:
preProcess = lambda x: x
if not callable(preProcess):
config.error('preProcess must be callable')
self._is_relevant = isRelevant
self._pre_process = preProcess
def __init__(self, slavesrc, masterdest,
workdir=None, maxsize=None, blocksize=16*1024,
compress=None, url=None, **buildstep_kwargs):
BuildStep.__init__(self, **buildstep_kwargs)
self.addFactoryArguments(slavesrc=slavesrc,
masterdest=masterdest,
workdir=workdir,
maxsize=maxsize,
blocksize=blocksize,
compress=compress,
url=url,
)
self.slavesrc = slavesrc
self.masterdest = masterdest
self.workdir = workdir
self.maxsize = maxsize
self.blocksize = blocksize
if compress not in (None, 'gz', 'bz2'):
raise config.ConfigErrors([
"'compress' must be one of None, 'gz', or 'bz2'" ])
self.compress = compress
self.url = url
def __init__(self,
url,
method,
description=None,
descriptionDone=None,
**kwargs):
if txrequests is None or requests is None:
config.error(
"Need to install txrequest to use this step:\n\n pip install txrequests"
)
self.method = method
self.url = url
self.requestkwargs = {'method': method, 'url': url}
for p in HTTPStep.requestsParams:
v = kwargs.pop(p, None)
self.__dict__[p] = v
if method not in ('POST', 'GET', 'PUT', 'DELETE', 'HEAD', 'OPTIONS'):
config.error("Wrong method given: '%s' is not known" % method)
if description is not None:
self.description = description
if descriptionDone is not None:
self.descriptionDone = descriptionDone
BuildStep.__init__(self, **kwargs)
def test_addStep(self):
# create a string random string that will probably not collide
# with what is already in the factory
string = ''.join(choice(ascii_uppercase) for x in range(6))
length = len(self.factory.steps)
step = BuildStep(name=string)
self.factory.addStep(step)
# check if the number of nodes grew by one
self.assertTrue(length + 1, len(self.factory.steps))
# check if the 'right' node added in the factory
self.assertEqual(self.factory.steps[-1],
_BuildStepFactory(BuildStep, name=string))
def __init__(self, command,
description=None, descriptionDone=None, descriptionSuffix=None,
env=None, path=None, usePTY=0, interruptSignal="KILL",
**kwargs):
BuildStep.__init__(self, **kwargs)
self.command = command
if description:
self.description = description
if isinstance(self.description, str):
self.description = [self.description]
if descriptionDone:
self.descriptionDone = descriptionDone
if isinstance(self.descriptionDone, str):
self.descriptionDone = [self.descriptionDone]
if descriptionSuffix:
self.descriptionSuffix = descriptionSuffix
if isinstance(self.descriptionSuffix, str):
self.descriptionSuffix = [self.descriptionSuffix]
self.env = env
self.path = path
self.usePTY = usePTY
self.interruptSignal = interruptSignal
def test_init_none(self):
"""Default steps can be uninitialized by setting None"""
self.factory = GNUAutoconf(source=BuildStep(),
compile=None,
test=None,
distcheck=None)
for step in self.factory.steps:
try:
cmd = step.buildStep().command
self.assertNotIn(cmd, [['make', 'all'], ['make', 'check'],
['make', 'distcheck']],
f"Build step {cmd} should not be present.")
except (AttributeError, KeyError):
pass
