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 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 _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)