def make_pod(self, cpu=0, mem=0, cpu_over_commit=1, mem_over_commit=1): # Make one pod zone = factory.make_Zone() pool = factory.make_ResourcePool() ip = factory.make_ipv4_address() power_parameters = { "power_address": "qemu+ssh://%s/system" % ip, "power_pass": "******", } return factory.make_Pod( pod_type="virsh", zone=zone, pool=pool, cores=cpu, memory=mem, cpu_over_commit_ratio=cpu_over_commit, memory_over_commit_ratio=mem_over_commit, parameters=power_parameters, )
def make_pod_info(self): # Use virsh pod type as the required fields are specific to the # type of pod being created. pod_type = "virsh" pod_ip_adddress = factory.make_ipv4_address() pod_power_address = "qemu+ssh://user@%s/system" % pod_ip_adddress pod_password = factory.make_name("password") pod_tags = [factory.make_name("tag") for _ in range(3)] pod_cpu_over_commit_ratio = random.randint(0, 10) pod_memory_over_commit_ratio = random.randint(0, 10) return { "type": pod_type, "power_address": pod_power_address, "power_pass": pod_password, "ip_address": pod_ip_adddress, "tags": pod_tags, "cpu_over_commit_ratio": pod_cpu_over_commit_ratio, "memory_over_commit_ratio": pod_memory_over_commit_ratio, }
def make_pod_info(self): # Use virsh pod type as the required fields are specific to the # type of pod being created. pod_type = 'virsh' pod_ip_adddress = factory.make_ipv4_address() pod_power_address = 'qemu+ssh://user@%s/system' % pod_ip_adddress pod_password = factory.make_name('password') pod_tags = [factory.make_name('tag') for _ in range(3)] pod_cpu_over_commit_ratio = random.randint(0, 10) pod_memory_over_commit_ratio = random.randint(0, 10) return { 'type': pod_type, 'power_address': pod_power_address, 'power_pass': pod_password, 'ip_address': pod_ip_adddress, 'tags': pod_tags, 'cpu_over_commit_ratio': pod_cpu_over_commit_ratio, 'memory_over_commit_ratio': pod_memory_over_commit_ratio }
def test_create_interface_creates_with_external_ip_assignment(self): user = factory.make_User() handler = DeviceHandler(user, {}) device = factory.make_Device(owner=user) mac = factory.make_mac_address() ip_address = factory.make_ipv4_address() updated_device = handler.create_interface({ "system_id": device.system_id, "mac_address": mac, "ip_assignment": DEVICE_IP_ASSIGNMENT_TYPE.EXTERNAL, "ip_address": ip_address, }) self.expectThat(updated_device["primary_mac"], Equals(mac)) self.expectThat( updated_device["ip_assignment"], Equals(DEVICE_IP_ASSIGNMENT_TYPE.EXTERNAL)) self.expectThat( StaticIPAddress.objects.filter(ip=ip_address).count(), Equals(1), "StaticIPAddress was not created.")
def test_input_url_allows_ipv4_url(self): script = factory.make_Script(parameters={"url": {"type": "url"}}) input = "%s://%s:%d/%s" % ( self.pick_scheme(), factory.make_ipv4_address(), random.randint(0, 65535), factory.make_name(), ) form = ParametersForm(data={"url": input}, script=script, node=factory.make_Node()) self.assertTrue(form.is_valid(), form.errors) self.assertDictEqual( {"url": { "type": "url", "value": input }}, form.cleaned_data["input"][0], )
def test__returns_correct_url(self): import maasserver.compose_preseed as cp_module # Disable boot source cache signals. self.addCleanup(bootsources.signals.enable) bootsources.signals.disable() # Force the server host to be our test data. self.patch(cp_module, "get_maas_facing_server_host").return_value = ( self.rack if self.rack else self.default_region_ip) # Now setup the configuration and arguments, and see what we get back. node = factory.make_Node(interface=True, status=NODE_STATUS.COMMISSIONING) if self.boot_cluster_ip is not None: node.boot_cluster_ip = self.boot_cluster_ip node.save() Config.objects.set_config("enable_http_proxy", self.enable) Config.objects.set_config("http_proxy", self.http_proxy) Config.objects.set_config("use_peer_proxy", self.use_peer_proxy) Config.objects.set_config("use_rack_proxy", self.use_rack_proxy) if self.maas_proxy_port: Config.objects.set_config("maas_proxy_port", self.maas_proxy_port) request = make_HttpRequest(http_host=self.default_region_ip) if self.use_rack_proxy: subnet = None if self.cidr: vlan = factory.make_VLAN() if self.dhcp_on: rack = factory.make_RackController() vlan.dhcp_on = True vlan.primary_rack = rack vlan.save() subnet = factory.make_Subnet(cidr=self.cidr, vlan=vlan) if self.subnet_dns: subnet.dns_servers = [self.subnet_dns] else: subnet.dns_servers = [] subnet.save() request.META["REMOTE_ADDR"] = factory.pick_ip_in_Subnet(subnet) else: request.META["REMOTE_ADDR"] = factory.make_ipv4_address() actual = get_apt_proxy(request, node.get_boot_rack_controller(), node) self.assertEqual(self.result, actual)
def test_create_audit_event_creates_audit_event_with_description(self): node = factory.make_Node() request = HttpRequest() request.user = node.owner request.META = { 'HTTP_USER_AGENT': factory.make_name('user_agent'), 'HTTP_HOST': factory.make_ipv4_address(), } endpoint = factory.pick_choice(ENDPOINT_CHOICES) description = factory.make_name('description') create_audit_event(EVENT_TYPES.NODE_PXE_REQUEST, endpoint, request, system_id=node.system_id, description=description) event = Event.objects.get(node=node, user=node.owner) self.assertIsNotNone(event) self.assertIsNotNone(EventType.objects.get(level=AUDIT)) self.assertEquals(request.META['HTTP_USER_AGENT'], event.user_agent) self.assertEquals(description, event.description)
def test_Release_passes_secure_erase_and_quick_erase(self): user = factory.make_User() params = dict( power_address=factory.make_ipv4_address(), power_user=factory.make_string(), power_pass=factory.make_string()) node = factory.make_Node( interface=True, status=self.actionable_status, power_type='ipmi', power_state=POWER_STATE.OFF, owner=user, power_parameters=params) node_release_or_erase = self.patch_autospec(node, 'release_or_erase') with post_commit_hooks: Release(node, user).execute( erase=True, secure_erase=True, quick_erase=True) self.assertThat( node_release_or_erase, MockCalledOnceWith( user, erase=True, secure_erase=True, quick_erase=True))
def test_compose_preseed_uses_maas_syslog_port(self): syslog_port = factory.pick_port() Config.objects.set_config("maas_syslog_port", syslog_port) rack_controller = factory.make_RackController(url="") node = factory.make_Node(interface=True, status=NODE_STATUS.COMMISSIONING) nic = node.get_boot_interface() nic.vlan.dhcp_on = True nic.vlan.primary_rack = rack_controller nic.vlan.save() ip_address = factory.make_ipv4_address() node.boot_cluster_ip = ip_address node.save() request = make_HttpRequest() preseed = yaml.safe_load( compose_preseed(request, PRESEED_TYPE.COMMISSIONING, node)) self.assertEqual( "%s:%d" % (ip_address, syslog_port), preseed["rsyslog"]["remotes"]["maas"], )
def test_dns_config_has_NS_record(self): self.patch(settings, "DNS_CONNECT", True) ip = factory.make_ipv4_address() with RegionConfiguration.open_for_update() as config: config.maas_url = "http://%s/" % ip domain = factory.make_Domain() node, static = self.create_node_with_static_ip(domain=domain) dns_update_all_zones() # Creating the domain triggered writing the zone file and updating the # DNS. self.dns_wait_soa(domain.name) # Get the NS record for the zone 'domain.name'. ns_record = dig_call(port=self.bind.config.port, commands=[domain.name, "NS", "+short"]) self.assertGreater(len(ns_record), 0, "No NS record for domain.name.") # Resolve that hostname. self.dns_wait_soa(ns_record) ip_of_ns_record = dig_call(port=self.bind.config.port, commands=[ns_record, "+short"]) self.assertEqual(ip, ip_of_ns_record)
def test__doesnt_raises_other_errors(self): uuid = factory.make_name("uuid") # Cause a random exception self.patch(leases_module, "update_lease").side_effect = (factory.make_exception()) yield eventloop.start() try: yield call_responder( Region(), UpdateLease, { "cluster_uuid": uuid, "action": "expiry", "mac": factory.make_mac_address(), "ip_family": "ipv4", "ip": factory.make_ipv4_address(), "timestamp": int(time.time()), }) finally: yield eventloop.reset()
def test_create_creates_device_with_external_ip_assignment(self): user = factory.make_User() handler = DeviceHandler(user, {}) mac = factory.make_mac_address() hostname = factory.make_name("hostname") ip_address = factory.make_ipv4_address() created_device = handler.create({ "hostname": hostname, "primary_mac": mac, "interfaces": [{ "mac": mac, "ip_assignment": DEVICE_IP_ASSIGNMENT_TYPE.EXTERNAL, "ip_address": ip_address, }], }) self.expectThat( created_device["ip_assignment"], Equals(DEVICE_IP_ASSIGNMENT_TYPE.EXTERNAL)) self.expectThat(created_device["ip_address"], Equals(ip_address)) self.expectThat( StaticIPAddress.objects.filter(ip=ip_address).count(), Equals(1), "StaticIPAddress was not created.")
def test_Release_enters_disk_erasing(self): user = factory.make_User() params = dict( power_address=factory.make_ipv4_address(), power_user=factory.make_string(), power_pass=factory.make_string()) node = factory.make_Node( interface=True, status=self.actionable_status, power_type='ipmi', power_state=POWER_STATE.OFF, owner=user, power_parameters=params) old_status = node.status node_start = self.patch_autospec(node, '_start') node_start.return_value = None with post_commit_hooks: Release(node, user).execute(erase=True) self.expectThat(node.status, Equals(NODE_STATUS.DISK_ERASING)) self.assertThat( node_start, MockCalledOnceWith( user, user_data=ANY, old_status=old_status, allow_power_cycle=True))
def test__raises_no_errors_without_iscsi_prefix(self): host = factory.make_ipv4_address() target_name = factory.make_name('target') validate_iscsi_target('%s::::%s' % (host, target_name))
def test_gets_client_ipv4_for_REMOTE_ADDR(self): ip_address = factory.make_ipv4_address() request = HttpRequest() request.META = {"REMOTE_ADDR": ip_address} self.assertEqual(ip_address, get_remote_ip(request))
def test_gets_client_ipv4_for_HTTP_X_FORWARDED_FOR(self): ip_address = factory.make_ipv4_address() request = HttpRequest() request.META = {"HTTP_X_FORWARDED_FOR": ip_address} self.assertEqual(ip_address, get_remote_ip(request))
def test_get_maas_facing_server_host_returns_ip_if_ip_configured(self): ip = factory.make_ipv4_address() self.set_maas_url(ip) self.assertEqual(ip, server_address.get_maas_facing_server_host())
def test__raises_error_when_invalid(self): host = factory.make_ipv4_address() self.assertRaises( ValidationError, validate_iscsi_target, '%s::::' % host)
def test__integrates_with_get_maas_facing_server_host(self): ip = factory.make_ipv4_address() maas_url = 'http://%s' % ip rack = factory.make_RackController(url=maas_url) self.assertEqual(str(ip), server_address.get_maas_facing_server_host(rack))
def test_separators_dont_conflict_with_ipv4_address(self): self.assertIsNone( re.search(SubnetListFormField.separators, factory.make_ipv4_address()))
def make_addresses(self): """Return a set of IP addresses, mixing IPv4 and IPv6.""" return { factory.make_ipv4_address(), factory.make_ipv6_address(), }
def test_raises_no_errors_with_iscsi_prefix(self): host = factory.make_ipv4_address() target_name = factory.make_name("target") validate_iscsi_target("iscsi:%s::::%s" % (host, target_name))