def do_test_master(self): # create the master and set its config m = BuildMaster(self.basedir, self.configfile) # update the DB yield m.db.setup(check_version=False) yield m.db.model.upgrade() # stub out m.db.setup since it was already called above m.db.setup = lambda: None # mock reactor.stop (which trial *really* doesn't # like test code to call!) mock_reactor = mock.Mock(spec=reactor) mock_reactor.callWhenRunning = reactor.callWhenRunning # start the service yield m.startService(_reactor=mock_reactor) self.failIf(mock_reactor.stop.called, "startService tried to stop the reactor; check logs") # hang out for a fraction of a second, to let startup processes run d = defer.Deferred() reactor.callLater(0.01, d.callback, None) yield d # stop the service yield m.stopService() # and shutdown the db threadpool, as is normally done at reactor stop m.db.pool.shutdown()
def do_test_master(self): # create the master and set its config m = BuildMaster(self.basedir, self.configfile) m.config = config.MasterConfig.loadConfig( self.basedir, self.configfile) # update the DB yield m.db.setup(check_version=False) yield m.db.model.upgrade() # stub out m.db.setup since it was already called above m.db.setup = lambda : None # mock reactor.stop (which trial *really* doesn't # like test code to call!) mock_reactor = mock.Mock(spec=reactor) mock_reactor.callWhenRunning = reactor.callWhenRunning # start the service yield m.startService(_reactor=mock_reactor) self.failIf(mock_reactor.stop.called, "startService tried to stop the reactor; check logs") # stop the service yield m.stopService() # and shutdown the db threadpool, as is normally done at reactor stop m.db.pool.shutdown()
def getMaster(case, reactor, config_dict): """ Create a started ``BuildMaster`` with the given configuration. """ basedir = FilePath(case.mktemp()) basedir.createDirectory() config_dict['buildbotNetUsageData'] = None master = BuildMaster( basedir.path, reactor=reactor, config_loader=DictLoader(config_dict)) if 'db_url' not in config_dict: config_dict['db_url'] = 'sqlite://' # TODO: Allow BuildMaster to transparently upgrade the database, at least # for tests. master.config.db['db_url'] = config_dict['db_url'] yield master.db.setup(check_version=False) yield master.db.model.upgrade() master.db.setup = lambda: None yield master.startService() # and shutdown the db threadpool, as is normally done at reactor stop case.addCleanup(master.db.pool.shutdown) case.addCleanup(master.stopService) defer.returnValue(master)
def do_test_master(self): # create the master and set its config m = BuildMaster(self.basedir, self.configfile) m.config = config.MasterConfig.loadConfig(self.basedir, self.configfile) # update the DB yield m.db.setup(check_version=False) yield m.db.model.upgrade() # stub out m.db.setup since it was already called above m.db.setup = lambda: None # mock reactor.stop (which trial *really* doesn't # like test code to call!) mock_reactor = mock.Mock(spec=reactor) mock_reactor.callWhenRunning = reactor.callWhenRunning # start the service yield m.startService(_reactor=mock_reactor) self.failIf(mock_reactor.stop.called, "startService tried to stop the reactor; check logs") # stop the service yield m.stopService() # and shutdown the db threadpool, as is normally done at reactor stop m.db.pool.shutdown()
def setupConfig(self, configFunc): """ Setup and start a master configured by the function configFunc defined in the test module. @type configFunc: string @param configFunc: name of a function without argument defined in the test module that returns a BuildmasterConfig object. """ self.basedir = os.path.abspath('basdir') self.setUpDirs(self.basedir) self.configfile = os.path.join(self.basedir, 'master.cfg') if self.proto == 'pb': proto = '{"pb": {"port": "tcp:0:interface=127.0.0.1"}}' elif self.proto == 'null': proto = '{"null": {}}' # We create a master.cfg, which loads the configuration from the # test module. Only the slave config is kept there, as it should not # be changed open(self.configfile, "w").write( textwrap.dedent(""" from buildbot.buildslave import BuildSlave from %s import %s c = BuildmasterConfig = %s() c['slaves'] = [BuildSlave("local1", "localpw")] c['protocols'] = %s """ % (self.__class__.__module__, configFunc, configFunc, proto))) # create the master and set its config m = BuildMaster(self.basedir, self.configfile) self.master = m # update the DB yield m.db.setup(check_version=False) yield m.db.model.upgrade() # stub out m.db.setup since it was already called above m.db.setup = lambda: None # mock reactor.stop (which trial *really* doesn't # like test code to call!) mock_reactor = mock.Mock(spec=reactor) mock_reactor.callWhenRunning = reactor.callWhenRunning # start the service yield m.startService(_reactor=mock_reactor) self.failIf(mock_reactor.stop.called, "startService tried to stop the reactor; check logs") if self.proto == 'pb': # We find out the slave port automatically slavePort = list(itervalues( m.pbmanager.dispatchers))[0].port.getHost().port # create a slave, and attach it to the master, it will be started, and stopped # along with the master s = BuildSlave("127.0.0.1", slavePort, "local1", "localpw", self.basedir, False, False) elif self.proto == 'null': s = LocalBuildSlave("local1", self.basedir, False) s.setServiceParent(m)
def do_test_master(self): # create the master and set its config m = BuildMaster(self.basedir, self.configfile) # update the DB yield m.db.setup(check_version=False) yield m.db.model.upgrade() # stub out m.db.setup since it was already called above m.db.setup = lambda: None # mock reactor.stop (which trial *really* doesn't # like test code to call!) mock_reactor = mock.Mock(spec=reactor) mock_reactor.callWhenRunning = reactor.callWhenRunning mock_reactor.getThreadPool = reactor.getThreadPool mock_reactor.callFromThread = reactor.callFromThread # start the service yield m.startService(_reactor=mock_reactor) self.failIf(mock_reactor.stop.called, "startService tried to stop the reactor; check logs") # hang out for a fraction of a second, to let startup processes run d = defer.Deferred() reactor.callLater(0.01, d.callback, None) yield d # stop the service yield m.stopService() # and shutdown the db threadpool, as is normally done at reactor stop m.db.pool.shutdown()
def setupConfig(self, configFunc): """ Setup and start a master configured by the function configFunc defined in the test module. @type configFunc: string @param configFunc: name of a function without argument defined in the test module that returns a BuildmasterConfig object. """ self.basedir = os.path.abspath('basdir') self.setUpDirs(self.basedir) self.configfile = os.path.join(self.basedir, 'master.cfg') if self.proto == 'pb': proto = '{"pb": {"port": "tcp:0:interface=127.0.0.1"}}' elif self.proto == 'null': proto = '{"null": {}}' # We create a master.cfg, which loads the configuration from the # test module. Only the slave config is kept there, as it should not # be changed open(self.configfile, "w").write(textwrap.dedent(""" from buildbot.buildslave import BuildSlave from %s import %s c = BuildmasterConfig = %s() c['slaves'] = [BuildSlave("local1", "localpw")] c['protocols'] = %s """ % (self.__class__.__module__, configFunc, configFunc, proto))) # create the master and set its config m = BuildMaster(self.basedir, self.configfile) self.master = m # update the DB yield m.db.setup(check_version=False) yield m.db.model.upgrade() # stub out m.db.setup since it was already called above m.db.setup = lambda: None # mock reactor.stop (which trial *really* doesn't # like test code to call!) mock_reactor = mock.Mock(spec=reactor) mock_reactor.callWhenRunning = reactor.callWhenRunning # start the service yield m.startService(_reactor=mock_reactor) self.failIf(mock_reactor.stop.called, "startService tried to stop the reactor; check logs") if self.proto == 'pb': # We find out the slave port automatically slavePort = list(itervalues(m.pbmanager.dispatchers))[0].port.getHost().port # create a slave, and attach it to the master, it will be started, and stopped # along with the master s = BuildSlave("127.0.0.1", slavePort, "local1", "localpw", self.basedir, False, False) elif self.proto == 'null': s = LocalBuildSlave("local1", self.basedir, False) s.setServiceParent(m)
def setupConfig(self, config_dict): """ Setup and start a master configured by the function configFunc defined in the test module. @type config_dict: dict @param configFunc: The BuildmasterConfig dictionary. """ self.basedir = os.path.abspath('basdir') self.setUpDirs(self.basedir) # mock reactor.stop (which trial *really* doesn't # like test code to call!) mock_reactor = mock.Mock(spec=reactor) mock_reactor.callWhenRunning = reactor.callWhenRunning mock_reactor.getThreadPool = reactor.getThreadPool mock_reactor.callFromThread = reactor.callFromThread workerclass = worker.Worker if self.proto == 'pb': proto = {"pb": {"port": "tcp:0:interface=127.0.0.1"}} elif self.proto == 'null': proto = {"null": {}} workerclass = worker.LocalWorker config_dict['workers'] = [workerclass("local1", "localpw")] config_dict['protocols'] = proto # create the master and set its config m = BuildMaster(self.basedir, reactor=mock_reactor, config_loader=DictLoader(config_dict)) self.master = m # update the DB yield m.db.setup(check_version=False) yield m.db.model.upgrade() # stub out m.db.setup since it was already called above m.db.setup = lambda: None # start the service yield m.startService() self.failIf(mock_reactor.stop.called, "startService tried to stop the reactor; check logs") if self.proto == 'pb': # We find out the worker port automatically workerPort = list(itervalues( m.pbmanager.dispatchers))[0].port.getHost().port # create a worker, and attach it to the master, it will be started, and stopped # along with the master self.w = BuildSlave("127.0.0.1", workerPort, "local1", "localpw", self.basedir, False, False) elif self.proto == 'null': self.w = None if self.w is not None: self.w.setServiceParent(m)
def setUp(self): self.basedir = os.path.abspath('basdir') self.setUpDirs(self.basedir) self.configfile = os.path.join(self.basedir, 'master.cfg') # We create a master.cfg, which loads the configuration from the # test module. Only the slave config is kept there, as it should not # be changed open(self.configfile, "w").write(textwrap.dedent(""" from buildbot.buildslave import BuildSlave from %s import masterConfig c = BuildmasterConfig = masterConfig() c['slaves'] = [BuildSlave("local1", "localpw")] c['protocols'] = {"pb": {"port": "tcp:0:interface=127.0.0.1"}} """ % self.__class__.__module__)) # create the master and set its config m = BuildMaster(self.basedir, self.configfile) self.master = m # update the DB yield m.db.setup(check_version=False) yield m.db.model.upgrade() # stub out m.db.setup since it was already called above m.db.setup = lambda: None # mock reactor.stop (which trial *really* doesn't # like test code to call!) mock_reactor = mock.Mock(spec=reactor) mock_reactor.callWhenRunning = reactor.callWhenRunning # start the service yield m.startService(_reactor=mock_reactor) self.failIf(mock_reactor.stop.called, "startService tried to stop the reactor; check logs") # We find out the slave port automatically slavePort = m.pbmanager.dispatchers.values()[0].port.getHost().port # create a slave, and attach it to the master, it will be started, and stopped # along with the master s = BuildSlave("127.0.0.1", slavePort, "local1", "localpw", self.basedir, False, False) s.setServiceParent(m)
def getMaster(case, reactor, config_dict): """ Create a started ``BuildMaster`` with the given configuration. """ basedir = FilePath(case.mktemp()) basedir.createDirectory() master = BuildMaster(basedir.path, reactor=reactor, config_loader=DictLoader(config_dict)) if 'db_url' not in config_dict: config_dict['db_url'] = 'sqlite://' # TODO: Allow BuildMaster to transparently upgrade the database, at least for tests. master.config.db['db_url'] = config_dict['db_url'] yield master.db.setup(check_version=False) yield master.db.model.upgrade() master.db.setup = lambda: None yield master.startService() defer.returnValue(master)
def _run_master(self, loaded_config): # create the master m = BuildMaster(self.basedir, self.configfile) # update the DB yield m.db.setup(check_version=False) yield m.db.model.upgrade() # stub out m.db.setup since it was already called above m.db.setup = lambda: None # mock reactor.stop (which trial *really* doesn't # like test code to call!) mock_reactor = mock.Mock(spec=reactor) mock_reactor.callWhenRunning = reactor.callWhenRunning mock_reactor.getThreadPool = reactor.getThreadPool mock_reactor.callFromThread = reactor.callFromThread # mock configuration loading @classmethod def loadConfig(cls, basedir, filename): return loaded_config with mock.patch('buildbot.config.MasterConfig.loadConfig', loadConfig): # start the service yield m.startService(_reactor=mock_reactor) self.failIf(mock_reactor.stop.called, "startService tried to stop the reactor; check logs") # hang out for a fraction of a second, to let startup processes run d = defer.Deferred() reactor.callLater(0.01, d.callback, None) yield d # stop the service yield m.stopService() # and shutdown the db threadpool, as is normally done at reactor stop m.db.pool.shutdown()
def setupConfig(self, configFunc): """ Setup and start a master configured by the function configFunc defined in the test module. @type configFunc: string @param configFunc: name of a function without argument defined in the test module that returns a BuildmasterConfig object. """ self.basedir = os.path.abspath("basdir") self.setUpDirs(self.basedir) self.configfile = os.path.join(self.basedir, "master.cfg") workerclass = "BuildWorker" if self.proto == "pb": proto = '{"pb": {"port": "tcp:0:interface=127.0.0.1"}}' elif self.proto == "null": proto = '{"null": {}}' workerclass = "LocalBuildWorker" # We create a master.cfg, which loads the configuration from the # test module. Only the worker config is kept there, as it should not # be changed open(self.configfile, "w").write( textwrap.dedent( """ from buildbot.plugins import buildworker from {module} import {configFunc} c = BuildmasterConfig = {configFunc}() c['workers'] = [buildworker.{workerclass}("local1", "localpw")] c['protocols'] = {proto} """ ).format(module=self.__class__.__module__, configFunc=configFunc, proto=proto, workerclass=workerclass) ) # create the master and set its config m = BuildMaster(self.basedir, self.configfile) self.master = m # update the DB yield m.db.setup(check_version=False) yield m.db.model.upgrade() # stub out m.db.setup since it was already called above m.db.setup = lambda: None # mock reactor.stop (which trial *really* doesn't # like test code to call!) mock_reactor = mock.Mock(spec=reactor) mock_reactor.callWhenRunning = reactor.callWhenRunning # start the service yield m.startService(_reactor=mock_reactor) self.failIf(mock_reactor.stop.called, "startService tried to stop the reactor; check logs") if self.proto == "pb": # We find out the worker port automatically workerPort = list(itervalues(m.pbmanager.dispatchers))[0].port.getHost().port # create a worker, and attach it to the master, it will be started, and stopped # along with the master s = BuildWorker("127.0.0.1", workerPort, "local1", "localpw", self.basedir, False, False) elif self.proto == "null": s = None if s is not None: s.setServiceParent(m)
basedir.createDirectory() config_dict['buildbotNetUsageData'] = None master = BuildMaster( basedir.path, reactor=reactor, config_loader=DictLoader(config_dict)) if 'db_url' not in config_dict: config_dict['db_url'] = 'sqlite://' # TODO: Allow BuildMaster to transparently upgrade the database, at least # for tests. master.config.db['db_url'] = config_dict['db_url'] yield master.db.setup(check_version=False) yield master.db.model.upgrade() master.db.setup = lambda: None yield master.startService() case.addCleanup(master.stopService) return master class RunMasterBase(unittest.TestCase): proto = "null" if Worker is None: skip = "buildbot-worker package is not installed" @defer.inlineCallbacks def setupConfig(self, config_dict, startWorker=True): """ Setup and start a master configured
def setupConfig(self, config_dict, startWorker=True): """ Setup and start a master configured by the function configFunc defined in the test module. @type config_dict: dict @param configFunc: The BuildmasterConfig dictionary. """ self.basedir = os.path.abspath('basdir') self.setUpDirs(self.basedir) self.addCleanup(self.tearDownDirs) # mock reactor.stop (which trial *really* doesn't # like test code to call!) stop = mock.create_autospec(reactor.stop) self.patch(reactor, 'stop', stop) if startWorker: if self.proto == 'pb': proto = {"pb": {"port": "tcp:0:interface=127.0.0.1"}} workerclass = worker.Worker elif self.proto == 'null': proto = {"null": {}} workerclass = worker.LocalWorker config_dict['workers'] = [workerclass("local1", "localpw")] config_dict['protocols'] = proto # create the master and set its config m = BuildMaster(self.basedir, reactor=reactor, config_loader=DictLoader(config_dict)) self.master = m # update the DB yield m.db.setup(check_version=False) yield m.db.model.upgrade() # stub out m.db.setup since it was already called above m.db.setup = lambda: None # start the service yield m.startService() self.failIf(stop.called, "startService tried to stop the reactor; check logs") # and shutdown the db threadpool, as is normally done at reactor stop self.addCleanup(m.db.pool.shutdown) self.addCleanup(m.stopService) if not startWorker: return if self.proto == 'pb': # We find out the worker port automatically workerPort = list(itervalues( m.pbmanager.dispatchers))[0].port.getHost().port # create a worker, and attach it to the master, it will be started, and stopped # along with the master self.w = BuildSlave("127.0.0.1", workerPort, "local1", "localpw", self.basedir, False, False) elif self.proto == 'null': self.w = None if self.w is not None: self.w.startService() self.addCleanup(self.w.stopService) @defer.inlineCallbacks def dump(): if not self._passed: dump = StringIO.StringIO() print("FAILED! dumping build db for debug", file=dump) builds = yield self.master.data.get(("builds", )) for build in builds: yield self.printBuild(build, dump, withLogs=True) raise self.failureException(dump.getvalue()) self.addCleanup(dump)
def setupConfig(self, config_dict, startWorker=True): """ Setup and start a master configured by the function configFunc defined in the test module. @type config_dict: dict @param configFunc: The BuildmasterConfig dictionary. """ self.basedir = os.path.abspath('basdir') self.setUpDirs(self.basedir) self.addCleanup(self.tearDownDirs) # mock reactor.stop (which trial *really* doesn't # like test code to call!) stop = mock.create_autospec(reactor.stop) self.patch(reactor, 'stop', stop) if startWorker: if self.proto == 'pb': proto = {"pb": {"port": "tcp:0:interface=127.0.0.1"}} workerclass = worker.Worker elif self.proto == 'null': proto = {"null": {}} workerclass = worker.LocalWorker config_dict['workers'] = [workerclass("local1", "localpw")] config_dict['protocols'] = proto # create the master and set its config m = BuildMaster(self.basedir, reactor=reactor, config_loader=DictLoader(config_dict)) self.master = m # update the DB yield m.db.setup(check_version=False) yield m.db.model.upgrade() # stub out m.db.setup since it was already called above m.db.setup = lambda: None # start the service yield m.startService() self.failIf(stop.called, "startService tried to stop the reactor; check logs") # and shutdown the db threadpool, as is normally done at reactor stop self.addCleanup(m.db.pool.shutdown) self.addCleanup(m.stopService) if not startWorker: return if self.proto == 'pb': # We find out the worker port automatically workerPort = list(itervalues(m.pbmanager.dispatchers))[ 0].port.getHost().port # create a worker, and attach it to the master, it will be started, and stopped # along with the master self.w = BuildSlave( "127.0.0.1", workerPort, "local1", "localpw", self.basedir, False, False) elif self.proto == 'null': self.w = None if self.w is not None: self.w.startService() self.addCleanup(self.w.stopService) @defer.inlineCallbacks def dump(): if not self._passed: dump = StringIO.StringIO() print("FAILED! dumping build db for debug", file=dump) builds = yield self.master.data.get(("builds",)) for build in builds: yield self.printBuild(build, dump, withLogs=True) raise self.failureException(dump.getvalue()) self.addCleanup(dump)