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)