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