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([]))
