def test_getClientFor_errors_when_no_connections(self): service = RegionService(sentinel.ipcWorker) service.connections.clear() return assert_fails_with( service.getClientFor(factory.make_UUID(), timeout=0), exceptions.NoConnectionsAvailable, )
def test_removeConnectionFor_is_okay_if_connection_is_not_there(self): service = RegionService(sentinel.ipcWorker) uuid = factory.make_UUID() service._removeConnectionFor(uuid, DummyConnection()) self.assertEqual({uuid: set()}, service.connections)
def test_migrates_nodegroup_subnet(self): rack = factory.make_RackController() vlan = factory.make_VLAN() subnet = factory.make_Subnet(vlan=vlan) ip = factory.pick_ip_in_Subnet(subnet) interfaces = { factory.make_name("eth0"): { "type": "physical", "mac_address": factory.make_mac_address(), "parents": [], "links": [{ "mode": "static", "address": "%s/%d" % (str(ip), subnet.get_ipnetwork().prefixlen), }], "enabled": True, } } rack.update_interfaces(interfaces) ng_uuid = factory.make_UUID() NodeGroupToRackController.objects.create(uuid=ng_uuid, subnet=subnet) handle_upgrade(rack, ng_uuid) vlan = reload_object(vlan) self.assertEqual(rack.system_id, vlan.primary_rack.system_id) self.assertTrue(vlan.dhcp_on) self.assertItemsEqual([], NodeGroupToRackController.objects.all())
def test_create_raid_0_with_a_spare_fails(self): """Checks it's not possible to create a RAID 0 using 4 raw devices, 5 partitions and one spare device (because a RAID-0 cannot have spares).""" self.become_admin() node = factory.make_Node(status=NODE_STATUS.READY) bds = [ factory.make_PhysicalBlockDevice(node=node, size=(MIN_BLOCK_DEVICE_SIZE * 2) + PARTITION_TABLE_EXTRA_SPACE) for i in range(10) ] for bd in bds[5:]: factory.make_PartitionTable(block_device=bd) block_devices = [ bd.id for bd in bds[1:] if bd.get_partitiontable() is None ] partitions = [ bd.get_partitiontable().add_partition(size=MIN_PARTITION_SIZE).id for bd in bds[5:] ] uuid4 = factory.make_UUID() uri = get_raid_devices_uri(node) response = self.client.post( uri, { 'name': 'md0', 'uuid': uuid4, 'level': FILESYSTEM_GROUP_TYPE.RAID_0, 'block_devices': block_devices, 'partitions': partitions, 'spare_devices': [bds[0].id], 'spare_partitions': [], }) self.assertEqual(http.client.BAD_REQUEST, response.status_code, response.content)
def test_logs_migration(self): logger = self.useFixture(FakeLogger("maas")) rack = factory.make_RackController() vlan = factory.make_VLAN() subnet = factory.make_Subnet(vlan=vlan) ip = factory.pick_ip_in_Subnet(subnet) interfaces = { factory.make_name("eth0"): { "type": "physical", "mac_address": factory.make_mac_address(), "parents": [], "links": [{ "mode": "static", "address": "%s/%d" % (str(ip), subnet.get_ipnetwork().prefixlen), }], "enabled": True, } } rack.update_interfaces(interfaces) ng_uuid = factory.make_UUID() NodeGroupToRackController.objects.create(uuid=ng_uuid, subnet=subnet) handle_upgrade(rack, ng_uuid) vlan = reload_object(vlan) self.assertEqual( "DHCP setting from NodeGroup(%s) have been migrated to %s." % (ng_uuid, vlan), logger.output.strip(), )
def test__raises_exception_if_nodegroup_doesnt_exist(self): uuid = factory.make_UUID() d = call_responder( Region(), ListNodePowerParameters, {'uuid': uuid}) return assert_fails_with(d, NoSuchCluster)
def test_removeConnectionFor_fires_disconnected_event(self): service = RegionService(sentinel.ipcWorker) uuid = factory.make_UUID() c1 = DummyConnection() mock_fire = self.patch(service.events.disconnected, "fire") service._removeConnectionFor(uuid, c1) self.assertThat(mock_fire, MockCalledOnceWith(uuid))
def test__raises_BootConfigNoResponse_for_unknown_node(self): rack_controller = factory.make_RackController() local_ip = factory.make_ip_address() remote_ip = factory.make_ip_address() mac = factory.make_mac_address(delimiter='-') hardware_uuid = factory.make_UUID() self.assertRaises( BootConfigNoResponse, get_config, rack_controller.system_id, local_ip, remote_ip, mac=mac, hardware_uuid=hardware_uuid)
def test_addConnectionFor_adds_connection(self): service = RegionService(sentinel.ipcWorker) uuid = factory.make_UUID() c1 = DummyConnection() c2 = DummyConnection() service._addConnectionFor(uuid, c1) service._addConnectionFor(uuid, c2) self.assertEqual({uuid: {c1, c2}}, service.connections)
def test_getAllClients(self): service = RegionService(sentinel.ipcWorker) uuid1 = factory.make_UUID() c1 = DummyConnection() c2 = DummyConnection() service.connections[uuid1].update({c1, c2}) uuid2 = factory.make_UUID() c3 = DummyConnection() c4 = DummyConnection() service.connections[uuid2].update({c3, c4}) clients = service.getAllClients() self.assertThat(list(clients), MatchesAny( MatchesSetwise( Equals(RackClient(c1, {})), Equals(RackClient(c3, {}))), MatchesSetwise( Equals(RackClient(c1, {})), Equals(RackClient(c4, {}))), MatchesSetwise( Equals(RackClient(c2, {})), Equals(RackClient(c3, {}))), MatchesSetwise( Equals(RackClient(c2, {})), Equals(RackClient(c4, {}))), ))
def test_getConnectionFor_cancels_waiter_when_it_times_out(self): service = RegionService(sentinel.ipcWorker) uuid = factory.make_UUID() d = service._getConnectionFor(uuid, 1) # A waiter is added for the connection we're interested in. self.assertEqual({uuid: {d}}, service.waiters) d = assert_fails_with(d, CancelledError) def check(_): # The waiter has been unregistered. self.assertEqual({uuid: set()}, service.waiters) return d.addCallback(check)
def test_getConnectionFor_returns_existing_connection(self): service = RegionService(sentinel.ipcWorker) uuid = factory.make_UUID() conn = DummyConnection() service._addConnectionFor(uuid, conn) d = service._getConnectionFor(uuid, 1) # No waiter is added because a connection is available. self.assertEqual({uuid: set()}, service.waiters) def check(conn_returned): self.assertEquals(conn, conn_returned) return d.addCallback(check)
def test_register_calls_handle_upgrade(self): yield self.installFakeRegion() rack_controller = yield deferToDatabase(factory.make_RackController) protocol = self.make_Region() protocol.transport = MagicMock() ng_uuid = factory.make_UUID() mock_handle_upgrade = self.patch(regionservice.rackcontrollers, "handle_upgrade") yield call_responder( protocol, RegisterRackController, { "system_id": rack_controller.system_id, "hostname": rack_controller.hostname, "interfaces": {}, "nodegroup_uuid": ng_uuid, }) self.assertThat(mock_handle_upgrade, MockCalledOnceWith(rack_controller, ng_uuid))
def test_addConnectionFor_notifies_waiters(self): service = RegionService(sentinel.ipcWorker) uuid = factory.make_UUID() c1 = DummyConnection() c2 = DummyConnection() waiter1 = Mock() waiter2 = Mock() service.waiters[uuid].add(waiter1) service.waiters[uuid].add(waiter2) service._addConnectionFor(uuid, c1) service._addConnectionFor(uuid, c2) self.assertEqual({uuid: {c1, c2}}, service.connections) # Both mock waiters are called twice. A real waiter would only be # called once because it immediately unregisters itself once called. self.assertThat(waiter1.callback, MockCallsMatch(call(c1), call(c2))) self.assertThat(waiter2.callback, MockCallsMatch(call(c1), call(c2)))
def test_getConnectionFor_waits_for_connection(self): service = RegionService(sentinel.ipcWorker) uuid = factory.make_UUID() conn = DummyConnection() # Add the connection later (we're in the reactor thread right # now so this won't happen until after we return). reactor.callLater(0, service._addConnectionFor, uuid, conn) d = service._getConnectionFor(uuid, 1) # A waiter is added for the connection we're interested in. self.assertEqual({uuid: {d}}, service.waiters) def check(conn_returned): self.assertEqual(conn, conn_returned) # The waiter has been unregistered. self.assertEqual({uuid: set()}, service.waiters) return d.addCallback(check)
def test_migrates_nodegroup_subnet(self): rack = factory.make_RackController() vlan = factory.make_VLAN() subnet = factory.make_Subnet(vlan=vlan) ip = factory.pick_ip_in_Subnet(subnet) data = FakeCommissioningData() data.create_physical_network("eth0") data.networks["eth0"].addresses = [ LXDAddress(str(ip), subnet.get_ipnetwork().prefixlen) ] update_node_interfaces(rack, data.render()) ng_uuid = factory.make_UUID() NodeGroupToRackController.objects.create(uuid=ng_uuid, subnet=subnet) handle_upgrade(rack, ng_uuid) vlan = reload_object(vlan) self.assertEqual(rack.system_id, vlan.primary_rack.system_id) self.assertTrue(vlan.dhcp_on) self.assertItemsEqual([], NodeGroupToRackController.objects.all())
def test_getClientFor_returns_random_connection(self): c1 = DummyConnection() c2 = DummyConnection() chosen = DummyConnection() service = RegionService(sentinel.ipcWorker) uuid = factory.make_UUID() conns_for_uuid = service.connections[uuid] conns_for_uuid.update({c1, c2}) def check_choice(choices): self.assertItemsEqual(choices, conns_for_uuid) return chosen self.patch(random, "choice", check_choice) def check(client): self.assertThat(client, Equals(RackClient(chosen, {}))) self.assertIs(client.cache, service.connectionsCache[client._conn]) return service.getClientFor(uuid).addCallback(check)
def test_logs_migration(self): logger = self.useFixture(FakeLogger("maas")) rack = factory.make_RackController() vlan = factory.make_VLAN() subnet = factory.make_Subnet(vlan=vlan) ip = factory.pick_ip_in_Subnet(subnet) data = FakeCommissioningData() data.create_physical_network("eth0") data.networks["eth0"].addresses = [ LXDAddress(str(ip), subnet.get_ipnetwork().prefixlen) ] update_node_interfaces(rack, data.render()) ng_uuid = factory.make_UUID() NodeGroupToRackController.objects.create(uuid=ng_uuid, subnet=subnet) handle_upgrade(rack, ng_uuid) vlan = reload_object(vlan) self.assertEqual( "DHCP setting from NodeGroup(%s) have been migrated to %s." % (ng_uuid, vlan), logger.output.strip(), )
def test_getConnectionFor_with_concurrent_waiters(self): service = RegionService(sentinel.ipcWorker) uuid = factory.make_UUID() conn = DummyConnection() # Add the connection later (we're in the reactor thread right # now so this won't happen until after we return). reactor.callLater(0, service._addConnectionFor, uuid, conn) d1 = service._getConnectionFor(uuid, 1) d2 = service._getConnectionFor(uuid, 1) # A waiter is added for each call to _getConnectionFor(). self.assertEqual({uuid: {d1, d2}}, service.waiters) d = DeferredList((d1, d2)) def check(results): self.assertEqual([(True, conn), (True, conn)], results) # The waiters have both been unregistered. self.assertEqual({uuid: set()}, service.waiters) return d.addCallback(check)
def test_get_local_cluster_UUID_returns_cluster_UUID(self): uuid = factory.make_UUID() self.useFixture(ClusterConfigurationFixture(cluster_uuid=uuid)) self.assertEqual(uuid, get_local_cluster_UUID())
def test_getAllClients_empty_connections(self): service = RegionService(sentinel.ipcWorker) service.connections.clear() uuid1 = factory.make_UUID() service.connections[uuid1] = set() self.assertThat(service.getAllClients(), Equals([]))