def test_list_all_usable_releases(self):
custom_os = factory.make_BootResource(
rtype=BOOT_RESOURCE_TYPE.UPLOADED,
extra={"title": factory.make_name("title")},
)
factory.make_default_ubuntu_release_bootable()
# Bootloader to be ignored.
factory.make_BootResource(
rtype=BOOT_RESOURCE_TYPE.SYNCED, bootloader_type="uefi"
)
self.assertDictEqual(
{
"custom": [
{
"name": custom_os.name,
"title": custom_os.extra["title"],
"can_commission": False,
"requires_license_key": False,
}
],
"ubuntu": [
{
"name": "bionic",
"title": 'Ubuntu 18.04 LTS "Bionic Beaver"',
"can_commission": True,
"requires_license_key": False,
}
],
},
dict(list_all_usable_releases()),
)
def test_list_all_usable_osystems(self):
custom_os = factory.make_BootResource(
rtype=BOOT_RESOURCE_TYPE.UPLOADED,
extra={'title': factory.make_name('title')})
factory.make_default_ubuntu_release_bootable()
# Bootloader to be ignored.
factory.make_BootResource(
rtype=BOOT_RESOURCE_TYPE.SYNCED, bootloader_type='uefi')
self.assertItemsEqual([
{
'name': 'custom',
'title': 'Custom',
'default_commissioning_release': None,
'default_release': '',
'releases': [{
'name': custom_os.name,
'title': custom_os.extra['title'],
'can_commission': False,
'requires_license_key': False,
}],
},
{
'name': 'ubuntu',
'title': 'Ubuntu',
'default_commissioning_release': 'bionic',
'default_release': 'bionic',
'releases': [{
'name': 'bionic',
'title': 'Ubuntu 18.04 LTS "Bionic Beaver"',
'can_commission': True,
'requires_license_key': False,
}],
}], list_all_usable_osystems())
def make_osystem_with_releases(testcase, osystem_name=None, releases=None):
"""Generate an arbitrary operating system.
:param osystem_name: The operating system name. Useful in cases where
we need to test that not supplying an os works correctly.
:param releases: The list of releases name. Useful in cases where
we need to test that not supplying a release works correctly.
"""
if osystem_name is None:
osystem_name = factory.make_name('os')
if releases is None:
releases = [factory.make_name('release') for _ in range(3)]
rpc_releases = [make_rpc_release(release) for release in releases]
if osystem_name not in OperatingSystemRegistry:
OperatingSystemRegistry.register_item(osystem_name, CustomOS())
testcase.addCleanup(OperatingSystemRegistry.unregister_item,
osystem_name)
# Make sure the commissioning Ubuntu release and all created releases
# are available to all architectures.
architectures = [
node.architecture for node in Node.objects.distinct('architecture')
]
if len(architectures) == 0:
architectures.append('%s/generic' % factory.make_name('arch'))
for arch in architectures:
factory.make_default_ubuntu_release_bootable(arch.split('/')[0])
for release in releases:
factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.UPLOADED,
name=('%s/%s' % (osystem_name, release)),
architecture=arch)
return make_rpc_osystem(osystem_name, releases=rpc_releases)
def test__uses_present_boot_image(self):
rack_controller = factory.make_RackController()
local_ip = factory.make_ip_address()
remote_ip = factory.make_ip_address()
factory.make_default_ubuntu_release_bootable('amd64')
observed_config = get_config(
rack_controller.system_id, local_ip, remote_ip)
self.assertEqual("amd64", observed_config["arch"])
def test__has_enlistment_preseed_url_for_default(self):
rack_controller = factory.make_RackController()
local_ip = factory.make_ip_address()
remote_ip = factory.make_ip_address()
factory.make_default_ubuntu_release_bootable()
observed_config = get_config(
rack_controller.system_id, local_ip, remote_ip)
self.assertEqual(
compose_enlistment_preseed_url(),
observed_config["preseed_url"])
def test__returns_success_for_detailed_but_unknown_node(self):
rack_controller = factory.make_RackController()
local_ip = factory.make_ip_address()
remote_ip = factory.make_ip_address()
architecture = make_usable_architecture(self)
arch = architecture.split('/')[0]
factory.make_default_ubuntu_release_bootable(arch)
mac = factory.make_mac_address(delimiter='-')
# Should not raise BootConfigNoResponse.
get_config(
rack_controller.system_id, local_ip, remote_ip,
arch=arch, subarch='generic', mac=mac)
def test__has_enlistment_preseed_url_with_local_ip_subnet_with_dns(self):
rack_controller = factory.make_RackController()
subnet = factory.make_Subnet()
local_ip = factory.pick_ip_in_Subnet(subnet)
remote_ip = factory.make_ip_address()
factory.make_default_ubuntu_release_bootable()
observed_config = get_config(
rack_controller.system_id, local_ip, remote_ip)
self.assertEqual(
compose_enlistment_preseed_url(
base_url='http://%s:5248/' % local_ip),
observed_config["preseed_url"])
def test__has_enlistment_preseed_url_with_region_ip(self):
rack_controller = factory.make_RackController()
local_ip = factory.make_ip_address()
remote_ip = factory.make_ip_address()
factory.make_default_ubuntu_release_bootable()
Config.objects.set_config('use_rack_proxy', False)
observed_config = get_config(
rack_controller.system_id, local_ip, remote_ip)
self.assertEqual(
compose_enlistment_preseed_url(
default_region_ip=get_source_address(remote_ip)),
observed_config["preseed_url"])
def test__enlistment_checks_default_min_hwe_kernel(self):
rack_controller = factory.make_RackController()
local_ip = factory.make_ip_address()
remote_ip = factory.make_ip_address()
arch = 'armhf'
Config.objects.set_config('default_min_hwe_kernel', 'hwe-x')
self.patch(boot_module, 'get_boot_filenames').return_value = (
None, None, None)
factory.make_default_ubuntu_release_bootable(arch)
observed_config = get_config(
rack_controller.system_id, local_ip, remote_ip, arch=arch)
self.assertEqual('hwe-18.04', observed_config['subarch'])
def test__enlistment_return_generic_when_none(self):
rack_controller = factory.make_RackController()
local_ip = factory.make_ip_address()
remote_ip = factory.make_ip_address()
arch = 'armhf'
self.patch(boot_module, 'get_boot_filenames').return_value = (
None, None, None)
self.patch(boot_module, 'validate_hwe_kernel').return_value = None
factory.make_default_ubuntu_release_bootable(arch)
observed_config = get_config(
rack_controller.system_id, local_ip, remote_ip, arch=arch)
self.assertEqual('generic', observed_config['subarch'])
def test__commissioning_node_uses_min_hwe_kernel(self):
rack_controller = factory.make_RackController()
local_ip = factory.make_ip_address()
remote_ip = factory.make_ip_address()
node = factory.make_Node_with_Interface_on_Subnet(
status=NODE_STATUS.COMMISSIONING,
min_hwe_kernel="hwe-18.04")
arch = node.split_arch()[0]
factory.make_default_ubuntu_release_bootable(arch)
mac = node.get_boot_interface().mac_address
observed_config = get_config(
rack_controller.system_id, local_ip, remote_ip, mac=mac,
query_count=23)
self.assertEqual("hwe-18.04", observed_config["subarch"])
def patch_usable_osystems(testcase, osystems=None, allow_empty=True):
"""Set a fixed list of usable operating systems.
A usable operating system is one for which boot images are available.
:param testcase: A `TestCase` whose `patch` this function can use.
:param osystems: Optional list of operating systems. If omitted,
defaults to a list (which may be empty) of random operating systems.
"""
start = 0
if allow_empty is False:
start = 1
if osystems is None:
osystems = [
make_osystem_with_releases(testcase)
for _ in range(randint(start, 2))
]
os_releases = []
for osystem in osystems:
for release in osystem['releases']:
os_releases.append({
'osystem': osystem['name'],
'release': release['name'],
'purpose': 'xinstall',
})
# Make sure the Commissioning release is always available.
ubuntu = factory.make_default_ubuntu_release_bootable()
os_releases.append({
'osystem': ubuntu.name.split('/')[0],
'release': ubuntu.name.split('/')[1],
'purpose': 'xinstall',
})
testcase.patch(
boot_images,
'get_common_available_boot_images').return_value = os_releases
def test_list_all_usable_osystems(self):
custom_os = factory.make_BootResource(
rtype=BOOT_RESOURCE_TYPE.UPLOADED,
extra={"title": factory.make_name("title")},
)
factory.make_default_ubuntu_release_bootable()
# Bootloader to be ignored.
factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.SYNCED,
bootloader_type="uefi")
self.assertItemsEqual(
[
{
"name":
"custom",
"title":
"Custom",
"default_commissioning_release":
None,
"default_release":
"",
"releases": [{
"name": custom_os.name,
"title": custom_os.extra["title"],
"can_commission": False,
"requires_license_key": False,
}],
},
{
"name":
"ubuntu",
"title":
"Ubuntu",
"default_commissioning_release":
"focal",
"default_release":
"focal",
"releases": [{
"name": "focal",
"title": 'Ubuntu 20.04 LTS "Focal Fossa"',
"can_commission": True,
"requires_license_key": False,
}],
},
],
list_all_usable_osystems(),
)
def make_arch(
with_subarch=True, arch_name=None, subarch_name=None, extra=None
):
"""Generate an arbitrary architecture name.
:param with_subarch: Should the architecture include a slash and a
sub-architecture name? Defaults to `True`.
"""
if arch_name is None:
arch_name = factory.make_name("arch")
factory.make_default_ubuntu_release_bootable(arch_name, extra=extra)
if with_subarch:
if subarch_name is None:
subarch_name = factory.make_name("sub")
return "%s/%s" % (arch_name, subarch_name)
else:
return arch_name
def test__has_enlistment_preseed_url_internal_domain(self):
rack_controller = factory.make_RackController()
vlan = factory.make_VLAN(dhcp_on=True, primary_rack=rack_controller)
subnet = factory.make_Subnet(vlan=vlan)
subnet.dns_servers = []
subnet.save()
local_ip = factory.pick_ip_in_Subnet(subnet)
remote_ip = factory.make_ip_address()
factory.make_default_ubuntu_release_bootable()
observed_config = get_config(
rack_controller.system_id, local_ip, remote_ip)
self.assertEqual(
compose_enlistment_preseed_url(
base_url='http://%s.%s:5248/' % (
get_resource_name_for_subnet(subnet),
Config.objects.get_config('maas_internal_domain'))),
observed_config["preseed_url"])
def test__returns_global_kernel_params_for_enlisting_node(self):
# An 'enlisting' node means it looks like a node with details but we
# don't know about it yet. It should still receive the global
# kernel options.
rack_controller = factory.make_RackController()
local_ip = factory.make_ip_address()
remote_ip = factory.make_ip_address()
value = factory.make_string()
Config.objects.set_config("kernel_opts", value)
architecture = make_usable_architecture(self)
arch = architecture.split('/')[0]
factory.make_default_ubuntu_release_bootable(arch)
mac = factory.make_mac_address(delimiter='-')
observed_config = get_config(
rack_controller.system_id, local_ip, remote_ip,
arch=arch, subarch='generic', mac=mac)
self.assertEqual(value, observed_config['extra_opts'])
def make_osystem_with_releases(testcase, osystem_name=None, releases=None):
"""Generate an arbitrary operating system.
:param osystem_name: The operating system name. Useful in cases where
we need to test that not supplying an os works correctly.
:param releases: The list of releases name. Useful in cases where
we need to test that not supplying a release works correctly.
"""
if osystem_name is None:
osystem_name = factory.make_name('os')
if releases is None:
releases = [factory.make_name('release') for _ in range(3)]
rpc_releases = [make_rpc_release(release) for release in releases]
# If this is being used to test commissioning make sure the default
# Ubuntu release is bootable for every known architecture.
for node in Node.objects.all():
factory.make_default_ubuntu_release_bootable(node.split_arch()[0])
return make_rpc_osystem(osystem_name, releases=rpc_releases)
def setUp(self):
super().setUp()
self.patch(Node, 'get_effective_power_info').return_value = (
PowerInfo(False, False, False, None, None))
ubuntu = factory.make_default_ubuntu_release_bootable()
osystem, release = ubuntu.name.split('/')
self.patch(
boot_images, 'get_common_available_boot_images').return_value = [{
'osystem': osystem,
'release': release,
'purpose': 'xinstall',
}]
def setUp(self):
super().setUp()
self.patch(Node, "get_effective_power_info").return_value = PowerInfo(
False, False, False, None, None
)
ubuntu = factory.make_default_ubuntu_release_bootable()
osystem, release = ubuntu.name.split("/")
self.patch(
boot_images, "get_common_available_boot_images"
).return_value = [
{"osystem": osystem, "release": release, "purpose": "xinstall"}
]
def test_allows_no_boot_dtb(self):
release = factory.make_default_ubuntu_release_bootable()
arch, subarch = release.architecture.split('/')
osystem, series = release.name.split('/')
boot_resource_set = release.get_latest_complete_set()
kernel, initrd, boot_dbt = get_boot_filenames(arch, subarch, osystem,
series)
self.assertEquals(
boot_resource_set.files.get(
filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_KERNEL).filename, kernel)
self.assertEquals(
boot_resource_set.files.get(
filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_INITRD).filename, initrd)
self.assertIsNone(boot_dbt)
def test__commissioning_node_uses_min_hwe_kernel(self):
rack_controller = factory.make_RackController()
local_ip = factory.make_ip_address()
remote_ip = factory.make_ip_address()
node = factory.make_Node_with_Interface_on_Subnet(
status=NODE_STATUS.COMMISSIONING,
min_hwe_kernel="hwe-16.10")
arch = node.split_arch()[0]
ubuntu = factory.make_default_ubuntu_release_bootable(arch)
factory.make_usable_boot_resource(
name=ubuntu.name, architecture="%s/hwe-16.10" % arch,
kflavor='generic', rtype=BOOT_RESOURCE_TYPE.SYNCED)
mac = node.get_boot_interface().mac_address
observed_config = get_config(
rack_controller.system_id, local_ip, remote_ip, mac=mac)
self.assertEqual("hwe-16.10", observed_config["subarch"])
def test_settings_commissioning_POST(self):
self.client.login(user=factory.make_admin())
ubuntu = factory.make_default_ubuntu_release_bootable()
new_commissioning = ubuntu.name.split('/')[1]
response = self.client.post(
reverse('settings_general'),
get_prefixed_form_data(prefix='commissioning',
data={
'commissioning_distro_series':
(new_commissioning),
}))
self.assertEqual(http.client.FOUND, response.status_code)
self.assertEqual(
(new_commissioning, ),
(Config.objects.get_config('commissioning_distro_series'), ))
def test_get_filenames_finds_subarch_when_generic(self):
release = factory.make_default_ubuntu_release_bootable()
arch = release.architecture.split('/')[0]
osystem, series = release.name.split('/')
boot_resource_set = release.get_latest_complete_set()
factory.make_boot_resource_file_with_content(
boot_resource_set, filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_DTB)
kernel, initrd, boot_dbt = get_boot_filenames(arch, 'generic', osystem,
series)
self.assertEquals(
boot_resource_set.files.get(
filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_KERNEL).filename, kernel)
self.assertEquals(
boot_resource_set.files.get(
filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_INITRD).filename, initrd)
self.assertEquals(
boot_resource_set.files.get(
filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_DTB).filename, boot_dbt)
