def test_startService_calls_coreHandler_with_monitoring_processes(self):
@transactional
def create_process_and_racks():
process = factory.make_RegionControllerProcess()
rack_controllers = [
factory.make_RackController(managing_process=process)
for _ in range(3)
]
return process, rack_controllers
process, rack_controllers = yield deferToDatabase(
create_process_and_racks)
ipcWorker = IPCWorkerService(sentinel.reactor)
ipcWorker.processId.set(process.id)
listener = PostgresListenerService()
service = RackControllerService(ipcWorker, listener)
mock_coreHandler = self.patch(service, "coreHandler")
yield service.startService()
calls = [
call("sys_core_%d" % process.id, "watch_%d" % rack.id)
for rack in rack_controllers
]
self.assertThat(mock_coreHandler, MockCallsMatch(*calls))
def test_startService_waits_for_channel_registrar(self):
def fake_run_channel_registrar():
listener.channelRegistrarDone = deferred
def fake_core_handler(channel, message):
core_handler_calls.append((channel, message))
regionProcessId = random.randint(0, 100)
ipcWorker = IPCWorkerService(sentinel.reactor)
ipcWorker.processId.set(regionProcessId)
listener = self.make_listener_without_delay()
yield listener.startService()
deferred = Deferred()
listener.runChannelRegistrar = fake_run_channel_registrar
deferred.errback(Failure(RuntimeError("boom")))
core_handler_calls = []
listener.coreHandler = fake_core_handler
service = RackControllerService(ipcWorker, listener)
try:
yield service.startService()
except RuntimeError:
pass
else:
raise AssertionError("Should have failed.")
self.assertEqual([], core_handler_calls)
self.assertIsNotNone(service.starting)
yield listener.stopService()
def test_startService_sets_starting_to_result_of_processId_get(self):
ipcWorker = create_autospec(IPCWorkerService(sentinel.reactor),
spec_set=True)
service = RackControllerService(ipcWorker, sentinel.listener)
observed = service.startService()
processId = ipcWorker.processId
self.assertEqual(processId.get.return_value, observed)
self.assertEqual(processId.get.return_value, service.starting)
def test_startService_handles_cancel(self):
ipcWorker = IPCWorkerService(sentinel.reactor)
listener = PostgresListenerService()
service = RackControllerService(ipcWorker, listener)
starting = service.startService()
self.assertIs(starting, service.starting)
# Should not raise an exception and starting should be set to None.
starting.cancel()
self.assertIsNone(service.starting)
def test_startService_clears_starting_once_complete(self):
regionProcessId = random.randint(0, 100)
ipcWorker = IPCWorkerService(sentinel.reactor)
ipcWorker.processId.set(regionProcessId)
listener = PostgresListenerService()
service = RackControllerService(ipcWorker, listener)
yield service.startService()
self.assertIsNone(service.starting)
def test_startService_registers_with_postgres_listener(self):
regionProcessId = random.randint(0, 100)
ipcWorker = IPCWorkerService(sentinel.reactor)
ipcWorker.processId.set(regionProcessId)
listener = Mock()
service = RackControllerService(ipcWorker, listener)
yield service.startService()
self.assertThat(
listener.register,
MockCalledOnceWith("sys_core_%d" % regionProcessId,
service.coreHandler))
self.assertEqual(regionProcessId, service.processId)
def test_startService_registers_with_postgres_listener(self):
regionProcessId = random.randint(0, 100)
ipcWorker = IPCWorkerService(sentinel.reactor)
ipcWorker.processId.set(regionProcessId)
listener = PostgresListenerService()
yield listener.startService()
service = RackControllerService(ipcWorker, listener)
yield service.startService()
yield listener.channelRegistrarDone
sys_channel = f"sys_core_{regionProcessId}"
self.assertIn(sys_channel, listener.listeners)
self.assertIn(sys_channel, listener.registeredChannels)
self.assertIn(service.coreHandler, listener.listeners[sys_channel])
self.assertEqual(regionProcessId, service.processId)
yield listener.stopService()
