class BuilderNewStyle(object, PropertiesMixin): bb_requests = None # list of buildbot.process.buildrequest.BuildRequest bb_build = None #: :type bb_build: buildbot.process.Build workdir = '.' factorySteps = None # old-style static steps def __code_completion_helper__(self): if __debug__: self.bb_requests = BuildRequest() self.bb_build = Build() def __init__(self, **kwargs): if not hasattr(self, 'builderName'): self.builderName = kwargs.pop('builderName', None) if not hasattr(self, 'useSlave'): self.useSlave = kwargs.pop('useSlave', None) if not hasattr(self, 'tags'): self.tags = list(kwargs.pop('tags', [])) if not hasattr(self, 'builder_properties'): self.builder_properties = kwargs.pop('builder_properties', {}) self.locks = kwargs.pop('locks', []) assert len(kwargs.keys()) == 0, 'Unknown parameters: ' + ' '.join(kwargs.keys()) def onNewBuild(self): ''' It is called for cloned self object. Current build properties can be found via self.bb_requests Here we can populate "static" set of build steps ''' self.fillStaticSteps() pass @defer.inlineCallbacks def run_(self): yield self.runPrepare() yield self.run() pass @defer.inlineCallbacks def runPrepare(self): yield None pass @defer.inlineCallbacks def run(self): yield None pass @defer.inlineCallbacks def runCleanup(self): yield None pass def fillStaticSteps(self): pass def initConstants(self): pass def getName(self): if self.builderName: raise Exception('implement getName() method or pass "builderName" ctor parameter') return self.builderName def getSlaves(self): if self.useSlave is None: raise Exception('implement getSlaves() method or pass "useSlave" ctor parameter') return [self.useSlave] if isinstance(self.useSlave, str) else self.useSlave def getFactory(self): return BuildFactoryWrapper(self) def getFactoryProperties(self, props): return props def getTags(self): return self.tags def canStartBuild(self, bldr, builder, breq): print('canStartBuild: {} on {}'.format(self.getName(), builder.slave.slavename)) buildworker = None if 'buildworker' in breq.properties: buildworker = breq.properties['buildworker'] elif 'buildworker' in bldr.config.properties: buildworker = bldr.config.properties['buildworker'] if buildworker: if not isinstance(buildworker, (list, tuple)): buildworker = str(buildworker).split(',') return builder.slave.slavename in buildworker return True def register(self): self.initConstants() return BuilderConfig( name=self.getName(), slavenames=self.getSlaves(), factory=self.getFactory(), mergeRequests=False, tags=list(set(self.getTags())), properties=self.getFactoryProperties(props=self.builder_properties), canStartBuild = self.canStartBuild, locks=self.locks) # # Helpers # def addFactoryStep(self, step): assert self.bb_build is None, 'Build started, can\'t add factory step, use runtime step' self.factorySteps.append(step) def addStep(self, step, insertPosition=0, addToQueue=True): ''' Add step into build. insertPosition=None - append insertPosition=0 - insert insertPosition=someStep - insert after specified step ''' assert self.bb_build is not None, 'Build is not created, run this method only from run/runCleanup methods' return self.bb_build.addStep(step, insertPosition, addToQueue) def processStep(self, step): ''' Process specified step It is Deferred call, use yield! Throws BuildFailed if step was failed (and build terminates) ''' return self.bb_build.processStep(step)