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))