def test_worker_registers_and_deregisters(self):
pid = random.randint(1, 512)
self.patch(os, "getpid").return_value = pid
(
master,
connected,
disconnected,
) = self.make_IPCMasterService_with_wrap()
yield master.startService()
worker = IPCWorkerService(reactor, socket_path=self.ipc_path)
yield worker.startService()
yield connected.get(timeout=2)
self.assertIn(pid, master.connections)
def getProcessFromDB():
region = RegionController.objects.get_running_controller()
return RegionControllerProcess.objects.get(region=region, pid=pid)
process = yield deferToDatabase(getProcessFromDB)
self.assertEquals(process.id, master.connections[pid]["process_id"])
worker_procId = yield worker.processId.get(timeout=2)
self.assertEquals(process.id, worker_procId)
yield worker.stopService()
yield disconnected.get(timeout=2)
self.assertEquals({}, master.connections)
process = yield deferToDatabase(reload_object, process)
self.assertIsNone(process)
yield master.stopService()
def test_master_calls_killWorker_on_deregister(self):
pid = random.randint(1, 512)
self.patch(os, "getpid").return_value = pid
workers = MagicMock()
master, connected, disconnected = self.make_IPCMasterService_with_wrap(
workers=workers)
yield master.startService()
worker = IPCWorkerService(reactor, socket_path=self.ipc_path)
yield worker.startService()
yield connected.get(timeout=2)
yield worker.stopService()
yield disconnected.get(timeout=2)
yield master.stopService()
self.assertThat(workers.killWorker, MockCalledOnceWith(pid))
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_worker_registers_and_deregisters(self):
pid = random.randint(1, 512)
self.patch(os, 'getpid').return_value = pid
master, connected, disconnected = self.make_IPCMasterService()
yield master.startService()
worker = IPCWorkerService(reactor, socket_path=self.ipc_path)
yield worker.startService()
yield connected.get(timeout=2)
self.assertIn(pid, master.connections)
yield worker.stopService()
yield disconnected.get(timeout=2)
self.assertEquals({}, master.connections)
yield master.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_worker_registers_rpc_endpoints(self):
yield deferToDatabase(load_builtin_scripts)
pid = random.randint(1, 512)
self.patch(os, "getpid").return_value = pid
(
master,
connected,
disconnected,
) = self.make_IPCMasterService_with_wrap()
rpc_started = self.wrap_async_method(master, "registerWorkerRPC")
yield master.startService()
worker = IPCWorkerService(reactor, socket_path=self.ipc_path)
rpc = RegionService(worker)
yield worker.startService()
yield rpc.startService()
yield connected.get(timeout=2)
yield rpc_started.get(timeout=2)
def getEndpoints():
region = RegionController.objects.get_running_controller()
process = RegionControllerProcess.objects.get(region=region,
pid=pid)
return set([(endpoint.address, endpoint.port) for endpoint in (
RegionControllerProcessEndpoint.objects.filter(
process=process))])
endpoints = yield deferToDatabase(getEndpoints)
self.assertEqual(
master._getListenAddresses(master.connections[pid]["rpc"]["port"]),
endpoints,
)
yield rpc.stopService()
yield worker.stopService()
yield disconnected.get(timeout=2)
yield master.stopService()
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()
def test_worker_registers_and_unregister_rpc_connection(self):
yield deferToDatabase(load_builtin_scripts)
pid = random.randint(1, 512)
self.patch(os, "getpid").return_value = pid
(
master,
connected,
disconnected,
) = self.make_IPCMasterService_with_wrap()
rpc_started = self.wrap_async_method(master, "registerWorkerRPC")
yield master.startService()
worker = IPCWorkerService(reactor, socket_path=self.ipc_path)
rpc = RegionService(worker)
yield worker.startService()
yield rpc.startService()
yield connected.get(timeout=2)
yield rpc_started.get(timeout=2)
rackd = yield deferToDatabase(factory.make_RackController)
connid = str(uuid.uuid4())
address = factory.make_ipv4_address()
port = random.randint(1000, 5000)
yield worker.rpcRegisterConnection(connid, rackd.system_id, address,
port)
def getConnection():
region = RegionController.objects.get_running_controller()
process = RegionControllerProcess.objects.get(region=region,
pid=pid)
endpoint = RegionControllerProcessEndpoint.objects.get(
process=process, address=address, port=port)
return RegionRackRPCConnection.objects.filter(
endpoint=endpoint, rack_controller=rackd).first()
connection = yield deferToDatabase(getConnection)
self.assertIsNotNone(connection)
self.assertEqual(
{connid: (rackd.system_id, address, port)},
master.connections[pid]["rpc"]["connections"],
)
yield worker.rpcUnregisterConnection(connid)
connection = yield deferToDatabase(getConnection)
self.assertIsNone(connection)
yield rpc.stopService()
yield worker.stopService()
yield disconnected.get(timeout=2)
yield master.stopService()
def make_IPCWorkerService():
from maasserver.ipc import IPCWorkerService
return IPCWorkerService(reactor)