def test_fixes_custom_osystem_release_titles(self):
factory.make_RackController()
self.useFixture(RunningClusterRPCFixture())
releases = [factory.make_name("release") for _ in range(3)]
os_releases = [{
"name": release,
"title": release
} for release in releases]
for release in releases:
factory.make_BootResource(
rtype=BOOT_RESOURCE_TYPE.UPLOADED,
name=release,
architecture=make_usable_architecture(self),
extra={"title": release.upper()})
clients = getAllClients()
for index, client in enumerate(clients):
callRemote = self.patch(client._conn, "callRemote")
example = {
"osystems": [{
"name": "custom",
"releases": os_releases
}]
}
callRemote.return_value = succeed(example)
releases_with_titles = [{
"name": release,
"title": release.upper()
} for release in releases]
self.assertItemsEqual([{
"name": "custom",
"releases": releases_with_titles
}], gen_all_known_operating_systems())
def list_all_usable_osystems():
"""Return all operating systems that can be used for nodes."""
osystems = [
osystem for osystem in gen_all_known_operating_systems()
if len(osystem['releases']) > 0 and osystem['name'] != 'bootloader'
]
return sorted(osystems, key=itemgetter('title'))
def test_yields_oses_known_to_multiple_clusters(self):
factory.make_RackController()
factory.make_RackController()
self.useFixture(RunningClusterRPCFixture())
osystems = gen_all_known_operating_systems()
self.assertIsInstance(osystems, Iterator)
osystems = list(osystems)
self.assertThat(osystems, Not(HasLength(0)))
self.assertThat(osystems, AllMatch(IsInstance(dict)))
def test_yields_oses_known_to_a_cluster(self):
# The operating systems known to a single node are returned.
factory.make_RackController()
self.useFixture(RunningClusterRPCFixture())
osystems = gen_all_known_operating_systems()
self.assertIsInstance(osystems, Iterator)
osystems = list(osystems)
self.assertThat(osystems, Not(HasLength(0)))
self.assertThat(osystems, AllMatch(IsInstance(dict)))
def license_keys(request):
osystems = list(gen_all_known_operating_systems())
license_keys = LicenseKey.objects.all()
for license_key in license_keys:
set_license_key_titles(license_key, osystems)
return render(request, 'maasserver/settings_license_keys.html', {
'license_keys': license_keys,
})
def license_keys(request):
osystems = list(gen_all_known_operating_systems())
license_keys = LicenseKey.objects.all()
for license_key in license_keys:
set_license_key_titles(license_key, osystems)
return render(
request,
"maasserver/settings_license_keys.html",
{
"license_keys": license_keys,
"page_name": "settings"
},
)
def test_only_yields_os_once(self):
# Duplicate OSes that exactly match are suppressed. Typically
# every cluster will have several (or all) OSes in common.
factory.make_RackController()
factory.make_RackController()
self.useFixture(RunningClusterRPCFixture())
counter = Counter(osystem["name"]
for osystem in gen_all_known_operating_systems())
def get_count(item):
name, count = item
return count
self.assertThat(counter.items(),
AllMatch(AfterPreprocessing(get_count, Equals(1))))
def test_os_data_is_passed_through_unmolested(self):
factory.make_RackController()
self.useFixture(RunningClusterRPCFixture())
example = {
"osystems": [{
"name": factory.make_name("name"),
"foo": factory.make_name("foo"),
"bar": factory.make_name("bar"),
}]
}
for client in getAllClients():
callRemote = self.patch(client._conn, "callRemote")
callRemote.return_value = succeed(example)
self.assertItemsEqual(example["osystems"],
gen_all_known_operating_systems())
def clean(self):
"""Validate the model.
Checks that the name is in a valid format, for its type.
"""
if self.rtype == BOOT_RESOURCE_TYPE.UPLOADED:
if '/' in self.name:
# Avoid circular dependency
from maasserver.clusterrpc.osystems import (
gen_all_known_operating_systems,
)
osystem = self.name.split('/')[0]
if osystem not in {
i['name'] for i in gen_all_known_operating_systems()}:
raise ValidationError(
"%s boot resource cannot contain a '/' in it's name "
"unless it starts with a supported operating system."
% (self.display_rtype))
elif self.rtype in RTYPE_REQUIRING_OS_SERIES_NAME:
if '/' not in self.name:
raise ValidationError(
"%s boot resource must contain a '/' in it's name." % (
self.display_rtype))
def test_ignores_failures_when_talking_to_clusters(self):
factory.make_RackController()
factory.make_RackController()
factory.make_RackController()
self.useFixture(RunningClusterRPCFixture())
clients = getAllClients()
for index, client in enumerate(clients):
callRemote = self.patch(client._conn, "callRemote")
if index == 0:
# The first client found returns dummy OS information which
# includes the rack controllers's system_id (client.ident).
example = {"osystems": [{"name": client.ident}]}
callRemote.return_value = succeed(example)
else:
# All clients but the first raise an exception.
callRemote.side_effect = ZeroDivisionError()
# The only OS information to get through is that from the first. The
# failures arising from communicating with the other clusters have all
# been suppressed.
self.assertItemsEqual([{
"name": clients[0].ident
}], gen_all_known_operating_systems())
def settings(request):
user_list = UserProfile.objects.all_users().order_by('username')
# Process Third Party Drivers form.
third_party_drivers_form, response = process_form(
request, ThirdPartyDriversForm, reverse('settings'),
'third_party_drivers', "Configuration updated.")
if response is not None:
return response
# Process disk erasing on release form.
storage_settings_form, response = process_form(request,
StorageSettingsForm,
reverse('settings'),
'storage_settings',
"Configuration updated.")
if response is not None:
return response
# Process the MAAS form.
maas_form, response = process_form(request, MAASForm, reverse('settings'),
'maas', "Configuration updated.")
if response is not None:
return response
# Process the network form.
proxy_form, response = process_form(request, ProxyForm,
reverse('settings'), 'proxy',
"Configuration updated.")
if response is not None:
return response
# Process the DNS form.
dns_form, response = process_form(request, DNSForm, reverse('settings'),
'dns', "Configuration updated.")
if response is not None:
return response
# Process the NTP form.
ntp_form, response = process_form(request, NTPForm, reverse('settings'),
'ntp', "Configuration updated.")
if response is not None:
return response
# Process the network discovery form.
network_discovery_form, response = process_form(request,
NetworkDiscoveryForm,
reverse('settings'),
'network_discovery',
"Configuration updated.")
if response is not None:
return response
# Process the Commissioning form.
commissioning_form, response = process_form(request, CommissioningForm,
reverse('settings'),
'commissioning',
"Configuration updated.")
if response is not None:
return response
# Process the Deploy form.
deploy_form, response = process_form(request, DeployForm,
reverse('settings'), 'deploy',
"Configuration updated.")
if response is not None:
return response
# Process the Ubuntu form.
ubuntu_form, response = process_form(request, UbuntuForm,
reverse('settings'), 'ubuntu',
"Configuration updated.")
if response is not None:
return response
# Process the Windows form.
windows_form, response = process_form(request, WindowsForm,
reverse('settings'), 'windows',
"Configuration updated.")
if response is not None:
return response
# Process the Global Kernel Opts form.
kernelopts_form, response = process_form(request, GlobalKernelOptsForm,
reverse('settings'), 'kernelopts',
"Configuration updated.")
if response is not None:
return response
# Commissioning scripts.
commissioning_scripts = Script.objects.filter(
script_type=SCRIPT_TYPE.COMMISSIONING)
# Test scripts.
test_scripts = Script.objects.filter(script_type=SCRIPT_TYPE.TESTING,
default=False)
# License keys w/ titles for osystem and distro_series
osystems = list(gen_all_known_operating_systems())
show_license_keys = has_osystems_supporting_license_keys(osystems)
license_keys = LicenseKey.objects.all()
for license_key in license_keys:
set_license_key_titles(license_key, osystems)
return render(
request, 'maasserver/settings.html', {
'user_list': user_list,
'commissioning_scripts': commissioning_scripts,
'test_scripts': test_scripts,
'show_license_keys': show_license_keys,
'license_keys': license_keys,
'maas_form': maas_form,
'proxy_form': proxy_form,
'dns_form': dns_form,
'ntp_form': ntp_form,
'network_discovery_form': network_discovery_form,
'third_party_drivers_form': third_party_drivers_form,
'storage_settings_form': storage_settings_form,
'commissioning_form': commissioning_form,
'deploy_form': deploy_form,
'ubuntu_form': ubuntu_form,
'windows_form': windows_form,
'kernelopts_form': kernelopts_form,
'external_auth_enabled': bool(request.external_auth_info),
})
