def test_get_maas_stats(self):
# Make one component of everything
factory.make_RegionRackController()
factory.make_RegionController()
factory.make_RackController()
factory.make_Machine(cpu_count=2, memory=200)
factory.make_Machine(cpu_count=3, memory=100)
factory.make_Device()
stats = get_maas_stats()
machine_stats = get_machine_stats()
# Due to floating point calculation subtleties, sometimes the value the
# database returns is off by one compared to the value Python
# calculates, so just get it directly from the database for the test.
total_storage = machine_stats['total_storage']
compare = {
"controllers": {
"regionracks": 1,
"regions": 1,
"racks": 1,
},
"nodes": {
"machines": 2,
"devices": 1,
},
"machine_stats": {
"total_cpu": 5,
"total_mem": 300,
"total_storage": total_storage,
},
}
self.assertEquals(stats, json.dumps(compare))
def test__alternates_include_one_ip_address_per_region_and_maas_url(self):
factory.make_Subnet(cidr="192.168.0.0/24")
maas_url = "http://192.168.0.254/MAAS"
rack = factory.make_RackController(url=maas_url)
r1 = factory.make_RegionController()
factory.make_Interface(node=r1, ip="192.168.0.1")
factory.make_Interface(node=r1, ip="192.168.0.254")
r2 = factory.make_RegionController()
factory.make_Interface(node=r2, ip="192.168.0.2")
factory.make_Interface(node=r2, ip="192.168.0.3")
r3 = factory.make_RegionController()
factory.make_Interface(node=r3, ip="192.168.0.4")
factory.make_Interface(node=r3, ip="192.168.0.5")
# Make the "current" region controller r1.
self.patch(server_address, "get_maas_id").return_value = r1.system_id
region_ips = get_maas_facing_server_addresses(rack,
include_alternates=True)
self.assertThat(
region_ips,
Equals([
IPAddress("192.168.0.254"),
IPAddress("192.168.0.1"),
IPAddress("192.168.0.2"),
IPAddress("192.168.0.4"),
]),
)
def test__alternates_use_consistent_subnet(self):
factory.make_Subnet(cidr='192.168.0.0/24')
factory.make_Subnet(cidr='192.168.1.0/24')
maas_url = 'http://192.168.0.1/MAAS'
rack = factory.make_RackController(url=maas_url)
r1 = factory.make_RegionController()
factory.make_Interface(node=r1, ip='192.168.0.1')
factory.make_Interface(node=r1, ip='192.168.1.254')
r2 = factory.make_RegionController()
factory.make_Interface(node=r2, ip='192.168.0.2')
factory.make_Interface(node=r2, ip='192.168.1.3')
r3 = factory.make_RegionController()
factory.make_Interface(node=r3, ip='192.168.0.4')
factory.make_Interface(node=r3, ip='192.168.1.5')
# Make the "current" region controller r1.
self.patch(server_address, 'get_maas_id').return_value = r1.system_id
region_ips = get_maas_facing_server_addresses(rack,
include_alternates=True)
self.assertThat(
region_ips,
Equals([
IPAddress("192.168.0.1"),
IPAddress("192.168.0.2"),
IPAddress("192.168.0.4"),
]))
def test__alternates_support_ipv4_and_ipv6(self):
factory.make_Subnet(cidr='192.168.0.0/24')
factory.make_Subnet(cidr='192.168.1.0/24')
factory.make_Subnet(cidr='2001:db8::/64')
maas_url = 'http://maas.io/MAAS'
self.patch_resolve_hostname(["192.168.0.1", "2001:db8::1"])
rack = factory.make_RackController(url=maas_url)
r1 = factory.make_RegionController()
factory.make_Interface(node=r1, ip='192.168.0.1')
factory.make_Interface(node=r1, ip='2001:db8::1')
factory.make_Interface(node=r1, ip='192.168.1.254')
r2 = factory.make_RegionController()
factory.make_Interface(node=r2, ip='192.168.0.2')
factory.make_Interface(node=r2, ip='2001:db8::2')
r3 = factory.make_RegionController()
factory.make_Interface(node=r3, ip='192.168.0.4')
factory.make_Interface(node=r3, ip='2001:db8::4')
# Make the "current" region controller r1.
self.patch(server_address, 'get_maas_id').return_value = r1.system_id
region_ips = get_maas_facing_server_addresses(rack,
include_alternates=True)
self.assertThat(
region_ips,
Equals([
IPAddress("2001:db8::1"),
IPAddress("192.168.0.1"),
IPAddress("2001:db8::2"),
IPAddress("2001:db8::4"),
IPAddress("192.168.0.2"),
IPAddress("192.168.0.4"),
]))
def test_get_maas_stats(self):
# Make one component of everything
factory.make_RegionRackController()
factory.make_RegionController()
factory.make_RackController()
factory.make_Machine(cpu_count=2, memory=200, status=NODE_STATUS.READY)
factory.make_Machine(status=NODE_STATUS.READY)
factory.make_Machine(status=NODE_STATUS.NEW)
for _ in range(4):
factory.make_Machine(status=NODE_STATUS.ALLOCATED)
factory.make_Machine(
cpu_count=3, memory=100, status=NODE_STATUS.FAILED_DEPLOYMENT
)
for _ in range(2):
factory.make_Machine(status=NODE_STATUS.DEPLOYED)
factory.make_Device()
factory.make_Device()
subnets = Subnet.objects.all()
v4 = [net for net in subnets if net.get_ip_version() == 4]
v6 = [net for net in subnets if net.get_ip_version() == 6]
stats = get_maas_stats()
machine_stats = get_machine_stats()
# Due to floating point calculation subtleties, sometimes the value the
# database returns is off by one compared to the value Python
# calculates, so just get it directly from the database for the test.
total_storage = machine_stats["total_storage"]
expected = {
"controllers": {"regionracks": 1, "regions": 1, "racks": 1},
"nodes": {"machines": 10, "devices": 2},
"machine_stats": {
"total_cpu": 5,
"total_mem": 300,
"total_storage": total_storage,
},
"machine_status": {
"new": 1,
"ready": 2,
"allocated": 4,
"deployed": 2,
"commissioning": 0,
"testing": 0,
"deploying": 0,
"failed_deployment": 1,
"failed_commissioning": 0,
"failed_testing": 0,
"broken": 0,
},
"network_stats": {
"spaces": Space.objects.count(),
"fabrics": Fabric.objects.count(),
"vlans": VLAN.objects.count(),
"subnets_v4": len(v4),
"subnets_v6": len(v6),
},
}
self.assertEqual(json.loads(stats), expected)
def test_GET_region_controllers_query_count(self):
# Patch middleware so it does not affect query counting.
self.patch(middleware.ExternalComponentsMiddleware,
'_check_rack_controller_connectivity')
self.become_admin()
tag = factory.make_Tag()
for _ in range(3):
region = factory.make_RegionController()
region.tags.add(tag)
num_queries1, response1 = count_queries(self.client.get,
self.get_tag_uri(tag),
{'op': 'region_controllers'})
for _ in range(3):
region = factory.make_RegionController()
region.tags.add(tag)
num_queries2, response2 = count_queries(self.client.get,
self.get_tag_uri(tag),
{'op': 'region_controllers'})
# Make sure the responses are ok as it's not useful to compare the
# number of queries if they are not.
parsed_result_1 = json.loads(
response1.content.decode(settings.DEFAULT_CHARSET))
parsed_result_2 = json.loads(
response2.content.decode(settings.DEFAULT_CHARSET))
self.assertEqual([http.client.OK, http.client.OK, 3, 6], [
response1.status_code,
response2.status_code,
len(extract_system_ids(parsed_result_1)),
len(extract_system_ids(parsed_result_2)),
])
self.assertEquals(num_queries1, num_queries2 - 6)
def test_read_returns_limited_fields(self):
self.become_admin()
factory.make_RegionController()
response = self.client.get(reverse('regioncontrollers_handler'))
parsed_result = json_load_bytes(response.content)
self.assertItemsEqual([
'system_id',
'hostname',
'domain',
'fqdn',
'architecture',
'cpu_count',
'memory',
'swap_size',
'osystem',
'power_state',
'power_type',
'resource_uri',
'distro_series',
'interface_set',
'ip_addresses',
'zone',
'status_action',
'node_type',
'node_type_name',
'current_commissioning_result_id',
'current_testing_result_id',
'current_installation_result_id',
], list(parsed_result[0]))
def test_allows_separate_observations_per_region(self):
r1 = factory.make_RegionController()
r2 = factory.make_RegionController()
rdns1 = factory.make_RDNS("10.0.0.1", "test.maasr1", r1)
rdns2 = factory.make_RDNS("10.0.0.1", "test.maasr2", r2)
result1 = RDNS.objects.get_current_entry("10.0.0.1", r1)
result2 = RDNS.objects.get_current_entry("10.0.0.1", r2)
self.assertThat(rdns1.id, Equals(result1.id))
self.assertThat(rdns2.id, Equals(result2.id))
self.assertThat(rdns1.id, Not(Equals(rdns2.id)))
def test_disabled_configuration_causes_interface_update(self):
factory.make_RegionRackController()
factory.make_RegionController()
factory.make_RackController()
mock_update_discovery_state = self.patch(
Controller, "update_discovery_state")
Config.objects.set_config('network_discovery', 'disabled')
self.expectThat(
mock_update_discovery_state,
MockCallsMatch(*[call(NetworkDiscoveryConfig(
active=False, passive=False))] * 3))
def test_read_returns_limited_fields(self):
self.become_admin()
factory.make_RegionController()
response = self.client.get(reverse("regioncontrollers_handler"))
parsed_result = json_load_bytes(response.content)
self.assertItemsEqual(
[
"system_id",
"hostname",
"description",
"hardware_uuid",
"domain",
"fqdn",
"architecture",
"cpu_count",
"cpu_speed",
"memory",
"swap_size",
"osystem",
"power_state",
"power_type",
"resource_uri",
"distro_series",
"interface_set",
"ip_addresses",
"zone",
"status_action",
"node_type",
"node_type_name",
"current_commissioning_result_id",
"current_testing_result_id",
"current_installation_result_id",
"version",
"commissioning_status",
"commissioning_status_name",
"testing_status",
"testing_status_name",
"cpu_test_status",
"cpu_test_status_name",
"memory_test_status",
"memory_test_status_name",
"network_test_status",
"network_test_status_name",
"storage_test_status",
"storage_test_status_name",
"other_test_status",
"other_test_status_name",
"hardware_info",
"tag_names",
"interface_test_status",
"interface_test_status_name",
],
list(parsed_result[0]),
)
def test_get_query_count(self):
user = factory.make_User()
handler = ZoneHandler(user, {})
zone = factory.make_Zone()
for _ in range(3):
factory.make_Node(zone=zone)
for _ in range(3):
factory.make_Device(zone=zone)
for _ in range(3):
factory.make_RackController(zone=zone)
for _ in range(3):
factory.make_RegionController(zone=zone)
count, _ = count_queries(handler.get, {"id": zone.id})
self.assertEqual(count, 3)
def setUp(self):
super(TestRegisterRackController, self).setUp()
self.this_region = factory.make_RegionController()
mock_running = self.patch(
RegionController.objects,
"get_running_controller")
mock_running.return_value = self.this_region
def test_create_services_for_region_controller(self):
controller = factory.make_RegionController()
Service.objects.create_services_for(controller)
self.assertThat(
Service.objects.filter(node=controller),
HasLength(len(REGION_SERVICES)),
)
def test_PUT_updates_region_controller(self):
self.become_admin()
region = factory.make_RegionController()
zone = factory.make_zone()
response = self.client.put(self.get_region_uri(region),
{'zone': zone.name})
self.assertEqual(http.client.OK, response.status_code)
self.assertEqual(zone.name, reload_object(region).zone.name)
def test_deleting_controller_causes_old_notifications_to_go_away(self):
c1 = factory.make_RegionRackController()
c2 = factory.make_RegionController()
ControllerInfo.objects.set_version(c1, "2.3.0~beta2-6000-g123abc")
ControllerInfo.objects.set_version(c2, "2.3.0~beta2-6001-g234bcd")
self.assertThat(get_version_notifications().count(), Equals(1))
c2.delete()
self.assertThat(get_version_notifications().count(), Equals(0))
def test_creates_services_when_region_converts_to_region_rack(self):
controller = factory.make_RegionController()
controller.node_type = NODE_TYPE.REGION_AND_RACK_CONTROLLER
controller.save()
services = Service.objects.filter(node=controller)
self.assertThat(
{service.name for service in services},
Equals(REGION_SERVICES | RACK_SERVICES))
def test_get_maas_user_agent_with_uuid(self):
region = factory.make_RegionController()
self.useFixture(MAASIDFixture(region.system_id))
RegionController.objects.get_or_create_uuid()
user_agent = get_maas_user_agent()
composed_user_agent = "%s/%s" % (get_maas_version_user_agent(),
Config.objects.get_config('uuid'))
self.assertEquals(user_agent, composed_user_agent)
def test_get(self):
user = factory.make_User()
handler = ZoneHandler(user, {})
zone = factory.make_Zone()
for _ in range(3):
factory.make_Node(zone=zone)
for _ in range(3):
factory.make_Device(zone=zone)
for _ in range(3):
factory.make_RackController(zone=zone)
for _ in range(3):
factory.make_RegionController(zone=zone)
result = handler.get({"id": zone.id})
self.assertEqual(self.dehydrate_zone(zone), result)
self.assertEquals(3, result['machines_count'])
self.assertEquals(3, result['devices_count'])
self.assertEquals(6, result['controllers_count'])
def test_mark_dead_for_region_controller(self):
controller = factory.make_RegionController()
Service.objects.create_services_for(controller)
Service.objects.mark_dead(controller, dead_region=True)
for service in Service.objects.filter(node=controller):
self.expectThat(
(service.status, service.status_info),
Equals((DEAD_STATUSES[service.name], "")))
def test__delete_current_entry_deletes_and_logs_if_entry_deleted(self):
region = factory.make_RegionController()
hostname = factory.make_hostname()
ip = factory.make_ip_address()
factory.make_RDNS(ip, hostname, region)
RDNS.objects.delete_current_entry(ip, region)
self.assertThat(
self.maaslog.output,
DocTestMatches("Deleted reverse DNS entry...resolved to..."))
def make_region_with_address(space):
region = factory.make_RegionController()
iface = factory.make_Interface(node=region)
cidr4 = factory.make_ipv4_network(24)
subnet4 = factory.make_Subnet(space=space, cidr=cidr4)
cidr6 = factory.make_ipv6_network(64)
subnet6 = factory.make_Subnet(space=space, cidr=cidr6)
sip4 = factory.make_StaticIPAddress(interface=iface, subnet=subnet4)
sip6 = factory.make_StaticIPAddress(interface=iface, subnet=subnet6)
return region, sip4, sip6
def test_set_current_entry_updates_updated_time(self):
region = factory.make_RegionController()
hostname = factory.make_hostname()
ip = factory.make_ip_address()
yesterday = datetime.now() - timedelta(days=1)
factory.make_RDNS(ip, hostname, region, updated=yesterday)
# Nothing changed, so expect that only the last updated time changed.
RDNS.objects.set_current_entry(ip, [hostname], region)
result = RDNS.objects.first()
self.assertThat(result.updated, GreaterThan(yesterday))
def test_mark_dead_for_region_rack_controller_region_and_rack_dead(self):
controller = factory.make_RegionController()
controller.node_type = NODE_TYPE.REGION_AND_RACK_CONTROLLER
controller.save()
Service.objects.create_services_for(controller)
Service.objects.mark_dead(controller, dead_region=True, dead_rack=True)
for service in Service.objects.filter(node=controller):
self.expectThat(
(service.status, service.status_info),
Equals((DEAD_STATUSES[service.name], "")))
def test_rpc_info_from_running_ipc_master(self):
# Run the IPC master, IPC worker, and RPC service so the endpoints
# are updated in the database.
region = factory.make_RegionController()
self.useFixture(MAASIDFixture(region.system_id))
region.owner = factory.make_admin()
region.save()
# `workers` is only included so ipc-master will not actually get the
# workers service because this test runs in all-in-one mode.
self.useFixture(
RegionEventLoopFixture(
"ipc-master", "ipc-worker", "rpc", "workers"
)
)
eventloop.start(master=True, all_in_one=True).wait(5)
self.addCleanup(lambda: eventloop.reset().wait(5))
getServiceNamed = eventloop.services.getServiceNamed
ipcMaster = getServiceNamed("ipc-master")
@wait_for(5)
@inlineCallbacks
def wait_for_startup():
# Wait for the service to complete startup.
yield ipcMaster.starting
yield getServiceNamed("ipc-worker").starting
yield getServiceNamed("rpc").starting
# Force an update, because it's very hard to track when the
# first iteration of the ipc-master service has completed.
yield ipcMaster.update()
wait_for_startup()
response = self.client.get(reverse("rpc-info"))
self.assertEqual("application/json", response["Content-Type"])
info = json.loads(response.content.decode("unicode_escape"))
self.assertThat(info, KeysEqual("eventloops"))
self.assertThat(
info["eventloops"],
MatchesDict(
{
# Each entry in the endpoints dict is a mapping from an
# event loop to a list of (host, port) tuples. Each tuple is
# a potential endpoint for connecting into that event loop.
eventloop.loop.name: MatchesSetwise(
*(
MatchesListwise((Equals(addr), is_valid_port))
for addr, _ in ipcMaster._getListenAddresses(5240)
)
)
}
),
)
def make_old_processes():
old_time = now() - timedelta(seconds=90)
region = RegionController.objects.get_running_controller()
other_region = factory.make_RegionController()
old_region_process = RegionControllerProcess.objects.create(
region=region, pid=random.randint(1, 1000), created=old_time,
updated=old_time)
old_other_region_process = RegionControllerProcess.objects.create(
region=other_region, pid=random.randint(1000, 2000),
created=old_time, updated=old_time)
return old_region_process, old_other_region_process
def test__alternates_do_not_contain_duplicate_for_maas_url_ip(self):
# See bug #1753493. (This tests to ensure we don't provide the same
# IP address from maas_url twice.) Also ensures that the IP address
# from maas_url comes first.
factory.make_Subnet(cidr="192.168.0.0/24")
maas_url = "http://192.168.0.2/MAAS"
rack = factory.make_RackController(url=maas_url)
r1 = factory.make_RegionController()
factory.make_Interface(node=r1, ip="192.168.0.1")
r2 = factory.make_RegionController()
factory.make_Interface(node=r2, ip="192.168.0.2")
# Make the "current" region controller r1.
self.patch(server_address, "get_maas_id").return_value = r1.system_id
region_ips = get_maas_facing_server_addresses(rack,
include_alternates=True)
self.assertThat(
region_ips,
Equals([IPAddress("192.168.0.2"),
IPAddress("192.168.0.1")]),
)
def test_list_switches_includes_link_type_controller(self):
owner = factory.make_admin()
handler = SwitchHandler(owner, {}, None)
controller1 = factory.make_RackController(owner=owner)
controller2 = factory.make_RegionController(owner=owner)
controller3 = factory.make_RegionRackController(owner=owner)
factory.make_Switch(node=controller1)
factory.make_Switch(node=controller2)
factory.make_Switch(node=controller3)
self.assertItemsEqual(
['controller', 'controller', 'controller'],
[result['link_type'] for result in handler.list({})])
def test_get_maas_stats(self):
# Make one component of everything
factory.make_RegionRackController()
factory.make_RegionController()
factory.make_RackController()
factory.make_Machine()
factory.make_Device()
stats = get_maas_stats()
compare = {
"controllers": {
"regionracks": 1,
"regions": 1,
"racks": 1,
},
"nodes": {
"machines": 1,
"devices": 1,
},
}
self.assertEquals(stats, json.dumps(compare))
def test__set_current_entry_creates_new_with_log(self):
region = factory.make_RegionController()
hostname = factory.make_hostname()
ip = factory.make_ip_address()
RDNS.objects.set_current_entry(ip, [hostname], region)
result = RDNS.objects.first()
self.assertThat(result.ip, Equals(ip))
self.assertThat(result.hostname, Equals(hostname))
self.assertThat(result.hostnames, Equals([hostname]))
self.assertThat(
self.maaslog.output,
DocTestMatches("New reverse DNS entry...resolves to..."))
def test_create_services_removes_services(self):
controller = factory.make_RegionController()
Service.objects.create_services_for(controller)
services = Service.objects.filter(node=controller)
self.assertThat({service.name
for service in services}, Equals(REGION_SERVICES))
controller.node_type = NODE_TYPE.MACHINE
controller.save()
Service.objects.create_services_for(controller)
services = Service.objects.filter(node=controller)
self.assertThat({service.name for service in services}, HasLength(0))
