def test_TriggerStepMultiMasterMode(self):
m = fakemaster.FakeMaster()
m.maybeStartBuildsForSlave = lambda slave: True
m.status = master.Status(m)
m.config.buildbotURL = "baseurl/"
m.config.multiMaster = True
m.db = fakedb.FakeDBConnector(self)
scheduler_a = FakeTriggerable(name='a')
m.allSchedulers = lambda: [scheduler_a]
def trigger_sch(sourcestamps = None, set_props=None, triggeredbybrid=None, reason=None):
rows = [ fakedb.MasterConfig(id=1, buildbotURL="build-master-01/", objectid=1),
fakedb.MasterConfig(id=2, buildbotURL="build-master-02/", objectid=2),
fakedb.SourceStampSet(id=1),
fakedb.SourceStamp(id=1, sourcestampsetid=1, codebase='c',
branch="az", repository="xz", revision="ww"),
fakedb.Buildset(id=1, reason='because', sourcestampsetid=1),
fakedb.BuildRequest(id=1, buildsetid=1, buildername="builder1", submitted_at=130000),
fakedb.BuildRequest(id=2, buildsetid=1, buildername="builder2", submitted_at=130000),
fakedb.BuildRequestClaim(brid=1, objectid=2, claimed_at=130000),
fakedb.BuildRequestClaim(brid=2, objectid=1, claimed_at=130000),
fakedb.Build(id=1, number=1, brid=1),
fakedb.Build(id=2, number=1, brid=2)]
d = m.db.insertTestData(rows)
d.addCallback(lambda _: (SUCCESS, {'builder1': 1L, 'builder2': 2L}))
return d
scheduler_a.trigger = trigger_sch
self.step = trigger.Trigger(schedulerNames=['a'], waitForFinish=True)
self.step.addCompleteLog = lambda x,y: True
self.step.step_status = Mock()
self.step.step_status.getLogs = lambda: []
self.expected_urls = []
self.step.step_status.addURL = lambda text, path, results=None: \
self.expected_urls.append({'text': text, 'path': path})
self.step.build = fakebuild.FakeBuild()
self.step.build.builder.botmaster = m.botmaster
self.step.build.getAllSourceStamps = lambda: []
self.step.build.build_status.getAllGotRevisions = lambda: {}
request = Mock()
request.id = 1
self.step.build.requests = [request]
self.remote = Mock(name="SlaveBuilder(remote)")
yield self.step.startStep(self.remote)
self.assertEquals(len(self.expected_urls), 2)
self.assertTrue({'text': 'builder1 #1', 'path': 'build-master-02/builders/builder1/builds/1'}
in self.expected_urls)
self.assertTrue({'text': 'builder1 #1', 'path': 'build-master-02/builders/builder1/builds/1'}
in self.expected_urls)
def setUp(self):
# set up a full master serving HTTP
yield self.setUpRealDatabase(table_names=['masters', 'objects', 'object_state'],
sqlite_memory=False)
master = fakemaster.FakeMaster(reactor)
master.config.db = dict(db_url=self.db_url)
master.db = dbconnector.DBConnector('basedir')
yield master.db.setServiceParent(master)
yield master.db.setup(check_version=False)
master.config.mq = dict(type='simple')
master.mq = mqconnector.MQConnector()
yield master.mq.setServiceParent(master)
yield master.mq.setup()
master.data = dataconnector.DataConnector()
yield master.data.setServiceParent(master)
master.config.www = dict(
port='tcp:0:interface=127.0.0.1',
debug=True,
auth=auth.NoAuth(),
authz=authz.Authz(),
avatar_methods=[],
logfileName='http.log')
master.www = wwwservice.WWWService()
yield master.www.setServiceParent(master)
yield master.www.startService()
yield master.www.reconfigServiceWithBuildbotConfig(master.config)
session = mock.Mock()
session.uid = "0"
master.www.site.sessionFactory = mock.Mock(return_value=session)
# now that we have a port, construct the real URL and insert it into
# the config. The second reconfig isn't really required, but doesn't
# hurt.
self.url = 'http://127.0.0.1:%d/' % master.www.getPortnum()
self.url = unicode2bytes(self.url)
master.config.buildbotURL = self.url
yield master.www.reconfigServiceWithBuildbotConfig(master.config)
self.master = master
# build an HTTP agent, using an explicit connection pool if Twisted
# supports it (Twisted 13.0.0 and up)
if hasattr(client, 'HTTPConnectionPool'):
self.pool = client.HTTPConnectionPool(reactor)
self.agent = client.Agent(reactor, pool=self.pool)
else:
self.pool = None
self.agent = client.Agent(reactor)
def setUp(self):
# set up a full master serving HTTP
yield self.setUpRealDatabase(table_names=['masters'],
sqlite_memory=False)
master = fakemaster.FakeMaster()
master.config.db = dict(db_url=self.db_url)
master.db = dbconnector.DBConnector(master, 'basedir')
yield master.db.setup(check_version=False)
master.config.mq = dict(type='simple')
master.mq = mqconnector.MQConnector(master)
master.mq.setup()
master.data = dataconnector.DataConnector(master)
master.config.www = dict(port='tcp:0:interface=127.0.0.1',
debug=True,
auth=auth.NoAuth(),
url="not yet known",
avatar_methods=[])
master.www = wwwservice.WWWService(master)
yield master.www.startService()
yield master.www.reconfigService(master.config)
# now that we have a port, construct the real URL and insert it into
# the config. The second reconfig isn't really required, but doesn't
# hurt.
self.url = 'http://127.0.0.1:%d/' % master.www.getPortnum()
master.config.www['url'] = self.url
yield master.www.reconfigService(master.config)
self.master = master
# build an HTTP agent, using an explicit connection pool if Twisted
# supports it (Twisted 13.0.0 and up)
if hasattr(client, 'HTTPConnectionPool'):
self.pool = client.HTTPConnectionPool(reactor)
self.agent = client.Agent(reactor, pool=self.pool)
else:
self.pool = None
self.agent = client.Agent(reactor)
def setUp(self):
self.project = 'proj0'
self.builder_name = '{}-test-builder'.format(self.project)
self.builder_status = fakemaster.FakeBuilderStatus(
buildername=self.builder_name,
project=self.project,
)
self.master = fakemaster.FakeMaster()
self.site = mock.Mock(buildbot_service=mock.Mock(master=self.master), )
self.request = DummyRequest([])
self.request.site = self.site
self.resource = status_json.StartBuildJsonResource(
self.master.status,
self.builder_status,
)
def setUp(self):
yield self.setUpRealDatabase(table_names=[
'objects', 'object_state', 'masters', 'workers',
'configured_workers', 'connected_workers', 'builder_masters',
'builders'
],
sqlite_memory=False)
master = fakemaster.FakeMaster(reactor)
master.data = dataconnector.DataConnector()
master.data.setServiceParent(master)
master.config.db = dict(db_url=self.db_url)
master.db = dbconnector.DBConnector('basedir')
master.db.setServiceParent(master)
yield master.db.setup(check_version=False)
master.config.mq = dict(type='simple')
master.mq = mqconnector.MQConnector()
master.mq.setServiceParent(master)
master.mq.setup()
master.config.www = dict(port='tcp:0:interface=127.0.0.1',
debug=True,
auth=auth.NoAuth(),
authz=authz.Authz(),
avatar_methods=[],
logfileName='http.log')
master.www = wwwservice.WWWService()
master.www.setServiceParent(master)
yield master.www.startService()
yield master.www.reconfigServiceWithBuildbotConfig(master.config)
session = mock.Mock()
session.uid = "0"
master.www.site.sessionFactory = mock.Mock(return_value=session)
# now that we have a port, construct the real URL and insert it into
# the config. The second reconfig isn't really required, but doesn't
# hurt.
self.url = 'http://127.0.0.1:%d/' % master.www.getPortnum()
self.url = unicode2bytes(self.url)
master.config.buildbotURL = self.url
yield master.www.reconfigServiceWithBuildbotConfig(master.config)
self.master = master
self.agent = client.Agent(reactor)
# create a telegram bot service
tb = master.config.services['TelegramBot'] = telegram.TelegramBot(
bot_token='12345:secret',
useWebhook=True,
chat_ids=[-123456],
notify_events=['worker'])
tb._get_http = self.get_http
tb.setServiceParent(self.master)
self.bot_url = self.url + b"telegram12345:secret"
yield tb.startService()
self.sent_messages = []
def send_message(chat, message, **kwargs):
self.sent_messages.append((chat, message))
tb.bot.send_message = send_message
def test_interruptConnectionLostShouldRetry(self):
self.master = fakemaster.FakeMaster()
self.master.maybeStartBuildsForSlave = lambda slave: True
self.master.db = fakedb.FakeDBConnector(self)
rows = [fakedb.SourceStampSet(id=1),
fakedb.SourceStamp(id=1, sourcestampsetid=1, codebase='c', branch="az", repository="xz", revision="ww"),
fakedb.Buildset(id=1, reason='because', sourcestampsetid=1),
fakedb.BuildRequest(id=1, buildsetid=1, buildername="bldr", submitted_at=130000)]
yield self.master.db.insertTestData(rows)
self.master.status = master.Status(self.master)
self.master.config.buildbotURL = "baseurl/"
self.scheduler_a = a = FakeTriggerable(name='a')
self.scheduler_b = b = FakeTriggerable(name='b')
def allSchedulers():
return [a, b]
self.master.allSchedulers = allSchedulers
self.factory = factory.BuildFactory()
self.step = trigger.Trigger(schedulerNames=['a'], waitForFinish=True)
self.step.addCompleteLog = lambda x,y: True
self.factory.addStep(self.step)
config_args = dict(name="bldr", slavename="slv", builddir="bdir",
slavebuilddir="sbdir", project='default', factory=self.factory)
builder_config = config.BuilderConfig(**config_args)
self.bldr = Builder(builder_config.name, _addServices=False)
self.bldr.master = self.master
self.bldr.botmaster = self.master.botmaster
mastercfg = config.MasterConfig()
mastercfg.builders = [ builder_config ]
self.bldr.startService()
yield self.bldr.reconfigService(mastercfg)
def newBuild(buildrequests):
self.build = Build(buildrequests)
self.build.setStepFactories([fakebuild.FakeStepFactory(self.step)])
return self.build
self.bldr.config.factory.newBuild = newBuild
self.bldr.notifyRequestsRemoved = lambda x: True
sb = Mock(spec=['isAvailable'], name='test-slave-1')
sb.name = 'test-slave-1'
sb.isAvailable.return_value = 1
sb.slave = Mock()
sb.slave.updateStatusBuildFinished = lambda result, build: result
sb.slave.properties = properties.Properties()
sb.prepare = lambda x, y: True
sb.ping = lambda timeout: True
sb.buildStarted = lambda: True
sb.buildFinished = lambda _: False
sb.setSlaveIdle = lambda: False
sb.remote = Mock()
self.bldr.slaves.append(sb)
self.assertEqual(self.master.db.buildrequests.claims, {})
from buildbot.process import buildrequestdistributor
self.brd = buildrequestdistributor.BuildRequestDistributor(self.master.botmaster)
self.brd.startService()
yield self.brd._maybeStartBuildsOnBuilder(self.bldr)
self.assertEqual(self.master.db.buildrequests.claims[1].brid, 1)
self.build.build_status.saveYourself = lambda: True
self.build.currentStep.start()
self.build.lostRemote()
self.assertEqual(self.master.db.buildrequests.claims, {})
if self.brd.running:
self.brd.stopService()