def test_getConfiguration_returns_configuration_object(self):
is_region, is_rack = factory.pick_bool(), factory.pick_bool()
servers, peers = self.make_servers_and_peers()
rpc_service, protocol = yield prepareRegion(
self,
is_region=is_region,
is_rack=is_rack,
servers=servers,
peers=peers,
)
service, ntp = self.make_RackNTP_ExternalService(rpc_service, reactor)
config = yield service._getConfiguration()
observed = ntp._getConfiguration(
config.controller_type, config.time_configuration
)
self.assertThat(observed, IsInstance(external._NTPConfiguration))
self.assertThat(
observed,
MatchesStructure.byEquality(
references=servers,
peers=peers,
is_region=is_region,
is_rack=is_rack,
),
)
def test_getConfiguration_returns_configuration_object(self):
port = factory.pick_port()
is_region, is_rack = factory.pick_bool(), factory.pick_bool()
rpc_service, protocol = yield prepareRegion(
self, is_region=is_region, is_rack=is_rack, syslog_port=port
)
forwarders = self.extract_regions(rpc_service)
service, syslog = self.make_RackSyslog_ExternalService(
rpc_service, reactor
)
yield service.startService()
self.addCleanup((yield service.stopService))
config = yield service._getConfiguration()
observed = syslog._getConfiguration(
config.controller_type,
config.syslog_configuration,
config.connections,
)
self.assertThat(observed, IsInstance(external._SyslogConfiguration))
self.assertThat(
observed,
MatchesStructure.byEquality(
port=port,
forwarders=forwarders,
is_region=is_region,
is_rack=is_rack,
),
)
def test_getConfiguration_returns_configuration_object(self):
is_region, is_rack = factory.pick_bool(), factory.pick_bool()
trusted_networks = self.make_trusted_networks()
rpc_service, protocol = yield prepareRegion(
self,
is_region=is_region,
is_rack=is_rack,
trusted_networks=trusted_networks,
)
region_ips = self.extract_regions(rpc_service)
service, dns = self.make_RackDNS_ExternalService(rpc_service, reactor)
yield service.startService()
self.addCleanup((yield service.stopService))
config = yield service._getConfiguration()
observed = dns._getConfiguration(
config.controller_type,
config.dns_configuration,
config.connections,
)
self.assertThat(observed, IsInstance(external._DNSConfiguration))
self.assertThat(
observed,
MatchesStructure.byEquality(
upstream_dns=region_ips,
trusted_networks=trusted_networks,
is_region=is_region,
is_rack=is_rack,
),
)
def test__getConfiguration_returns_configuration_object(self):
is_region, is_rack = factory.pick_bool(), factory.pick_bool()
allowed_cidrs = self.make_cidrs()
proxy_enabled = factory.pick_bool()
proxy_prefer_v4_proxy = factory.pick_bool()
proxy_port = random.randint(1000, 8000)
rpc_service, protocol = yield prepareRegion(
self,
is_region=is_region,
is_rack=is_rack,
proxy_enabled=proxy_enabled,
proxy_allowed_cidrs=allowed_cidrs,
proxy_port=proxy_port,
proxy_prefer_v4_proxy=proxy_prefer_v4_proxy)
region_ips = self.extract_regions(rpc_service)
service, proxy = self.make_RackProxy_ExternalService(
rpc_service, reactor)
yield service.startService()
self.addCleanup((yield service.stopService))
config = yield service._getConfiguration()
observed = proxy._getConfiguration(config.controller_type,
config.proxy_configuration,
config.connections)
self.assertThat(observed, IsInstance(external._ProxyConfiguration))
self.assertThat(
observed,
MatchesStructure.byEquality(enabled=proxy_enabled,
port=proxy_port,
allowed_cidrs=allowed_cidrs,
prefer_v4_proxy=proxy_prefer_v4_proxy,
upstream_proxies=region_ips,
is_region=is_region,
is_rack=is_rack))
def test_allows_trailing_and_starting_double_colon(self):
# we get random network addresses above, but lets play with a few that
# we know need to work.
addrs = ['::1', '::f', 'fe80::', 'fe80::1', 'fe80:37::3:1']
for addr in addrs:
# lower case
url = factory.make_simple_http_url(netloc="[%s]" % addr,
port=factory.pick_bool())
self.assertEqual(url, self.validator.to_python(url),
"url: %s" % url)
# upper case
url = factory.make_simple_http_url(netloc="[%s]" % addr.upper(),
port=factory.pick_bool())
self.assertEqual(url, self.validator.to_python(url),
"url: %s" % url)
def test_get_schema(self):
fake_name = factory.make_name("name")
fake_description = factory.make_name("description")
fake_setting = factory.make_name("setting")
fake_chassis = factory.pick_bool()
fake_settings = [
make_setting_field(fake_setting, fake_setting.title())
]
fake_driver = make_power_driver_base(
name=fake_name,
description=fake_description,
chassis=fake_chassis,
settings=fake_settings,
)
self.assertEqual(
{
"driver_type": "power",
"name": fake_name,
"description": fake_description,
"chassis": fake_chassis,
"can_probe": False,
"fields": fake_settings,
"queryable": fake_driver.queryable,
"missing_packages": fake_driver.detect_missing_packages(),
},
fake_driver.get_schema(),
)
def test_debug_enabled_cached(self):
debug = factory.pick_bool()
self.useFixture(ClusterConfigurationFixture(debug=debug))
# Prime cache
debug_enabled()
mock_open = self.patch(config_module.ClusterConfiguration, "open")
self.assertEqual(debug, debug_enabled())
mock_open.assert_not_called()
def test__getConfiguration_returns_configuration_object(self):
is_region, is_rack = factory.pick_bool(), factory.pick_bool()
servers, peers = self.make_servers_and_peers()
rpc_service, protocol = yield prepareRegion(self,
is_region=is_region,
is_rack=is_rack,
servers=servers,
peers=peers)
service = ntp.RackNetworkTimeProtocolService(rpc_service, reactor)
observed = yield service._getConfiguration()
self.assertThat(observed, IsInstance(ntp._Configuration))
self.assertThat(
observed,
MatchesStructure.byEquality(references=servers,
peers=peers,
is_region=is_region,
is_rack=is_rack))
def test__creates_omshell_with_correct_arguments(self):
omshell = self.patch(dhcp, "Omshell")
server = Mock()
server.ipv6 = factory.pick_bool()
dhcp._update_hosts(server, [], [], [])
self.assertThat(omshell, MockCallsMatch(
call(
ipv6=server.ipv6, server_address="127.0.0.1",
shared_key=server.omapi_key),
))
def test_compose_template_namespace_include_debug(self):
debug = factory.pick_bool()
boot.debug_enabled.cache_clear()
self.addClassCleanup(boot.debug_enabled.cache_clear)
self.useFixture(ClusterConfigurationFixture(debug=debug))
kernel_params = make_kernel_parameters()
method = FakeBootMethod()
template_namespace = method.compose_template_namespace(kernel_params)
self.assertEqual(debug, template_namespace["debug"])
def make_context():
"""Make and return a context for IPMI Power Driver."""
ret = {
"power_address": factory.make_name("power_address"),
"power_user": factory.make_name("power_user"),
"power_pass": factory.make_name("power_pass"),
"power_driver": factory.make_name("power_driver"),
"power_off_mode": factory.make_name("power_off_mode"),
"ipmipower": "ipmipower",
"ipmi_chassis_config": "ipmi-chassis-config",
}
# These options were added in MAAS 2.9. Add them optionally
# to test users coming from older versions.
if factory.pick_bool():
ret["k_g"] = factory.make_name("k_g")
if factory.pick_bool():
ret["cipher_suite_id"] = random.choice(IPMI_CIPHER_SUITE_ID_CHOICES)[0]
if factory.pick_bool():
ret["privilege_level"] = random.choice(IPMI_PRIVILEGE_LEVEL_CHOICES)[0]
return ret
def test_tryUpdate_updates_proxy_server(self):
self.useFixture(MAASRootFixture())
allowed_cidrs = self.make_cidrs()
proxy_prefer_v4_proxy = factory.pick_bool()
proxy_port = random.randint(1000, 8000)
rpc_service, _ = yield prepareRegion(
self,
proxy_allowed_cidrs=allowed_cidrs,
proxy_port=proxy_port,
proxy_prefer_v4_proxy=proxy_prefer_v4_proxy,
)
region_ips = self.extract_regions(rpc_service)
service, _ = self.make_RackProxy_ExternalService(rpc_service, reactor)
write_config = self.patch_autospec(
external.proxy_config, "write_config"
)
service_monitor = self.patch_autospec(external, "service_monitor")
yield service.startService()
self.addCleanup((yield service.stopService))
yield service._orig_tryUpdate()
expected_peers = sorted(
["http://%s:%s" % (ip, proxy_port) for ip in region_ips]
)
self.assertThat(
write_config,
MockCalledOnceWith(
allowed_cidrs,
peer_proxies=expected_peers,
prefer_v4_proxy=proxy_prefer_v4_proxy,
maas_proxy_port=proxy_port,
),
)
self.assertThat(
service_monitor.reloadService, MockCalledOnceWith("proxy_rack")
)
# If the configuration has not changed then a second call to
# `_tryUpdate` does not result in another call to `_configure`.
yield service._orig_tryUpdate()
self.assertThat(
write_config,
MockCalledOnceWith(
allowed_cidrs,
peer_proxies=expected_peers,
prefer_v4_proxy=proxy_prefer_v4_proxy,
maas_proxy_port=proxy_port,
),
)
self.assertThat(
service_monitor.reloadService, MockCalledOnceWith("proxy_rack")
)
def test__getConfiguration_returns_configuration_object(self):
is_region, is_rack = factory.pick_bool(), factory.pick_bool()
trusted_networks = self.make_trusted_networks()
rpc_service, protocol = yield prepareRegion(
self,
is_region=is_region,
is_rack=is_rack,
trusted_networks=trusted_networks)
region_ips = self.extract_regions(rpc_service)
service = self.make_startable_RackDNSService(rpc_service, reactor)
yield service.startService()
self.addCleanup((yield service.stopService))
observed = yield service._getConfiguration()
self.assertThat(observed, IsInstance(dns._Configuration))
self.assertThat(
observed,
MatchesStructure.byEquality(upstream_dns=region_ips,
trusted_networks=trusted_networks,
is_region=is_region,
is_rack=is_rack))
def test_requires_brackets_on_ipv6_address(self):
name = "[%s]" % factory.make_ipv6_address()
url = factory.make_simple_http_url(netloc=name,
port=factory.pick_bool())
self.assertEqual(url, self.validator.to_python(url), "url: %s" % url)
# rejects bare ipv6 address
name = "%s" % factory.make_ipv6_address()
url = factory.make_simple_http_url(netloc=name)
with ExpectedException(formencode.Invalid, 'That is not a valid URL'):
self.assertEqual(url, self.validator.to_python(url),
"url: %s" % url)
def test_machine_fromdict(self):
hostname = factory.make_name("hostname")
cores = random.randint(1, 8)
cpu_speed = random.randint(1000, 2000)
memory = random.randint(4096, 8192)
interfaces = [dict() for _ in range(3)]
block_devices = [
dict(
size=random.randint(512, 1024),
tags=[factory.make_name("tag") for _ in range(3)],
) for _ in range(3)
]
pinned_cores = random.sample(range(10), 3)
hugepages_backed = factory.pick_bool()
machine_data = dict(
hostname=hostname,
architecture="amd64/generic",
cores=cores,
cpu_speed=cpu_speed,
pinned_cores=pinned_cores,
hugepages_backed=hugepages_backed,
memory=memory,
interfaces=interfaces,
block_devices=block_devices,
)
machine = RequestedMachine.fromdict(machine_data)
self.assertThat(machine, IsInstance(RequestedMachine))
self.assertThat(
machine,
MatchesStructure(
hostname=Equals(hostname),
architecture=Equals("amd64/generic"),
cores=Equals(cores),
cpu_speed=Equals(cpu_speed),
memory=Equals(memory),
pinned_cores=Equals(pinned_cores),
hugepages_backed=Equals(hugepages_backed),
interfaces=MatchesListwise([
IsInstance(RequestedMachineInterface)
for interface in interfaces
]),
block_devices=MatchesListwise([
MatchesAll(
IsInstance(RequestedMachineBlockDevice),
MatchesStructure(
size=Equals(block_device["size"]),
tags=Equals(block_device["tags"]),
),
) for block_device in block_devices
]),
),
)
def test__performs_operations(self):
omshell = Mock()
self.patch(dhcp, "Omshell").return_value = omshell
remove_host = make_host()
add_host = make_host()
modify_host = make_host()
server = Mock()
server.ipv6 = factory.pick_bool()
dhcp._update_hosts(server, [remove_host], [add_host], [modify_host])
self.assertThat(omshell.remove,
MockCallsMatch(call(remove_host["mac"]), ))
self.assertThat(
omshell.create,
MockCallsMatch(call(add_host["ip"], add_host["mac"]), ))
self.assertThat(
omshell.modify,
MockCallsMatch(call(modify_host["ip"], modify_host["mac"]), ))
def make_fake_service(expected_state=None, status_info=None):
fake_name = factory.make_name("name")
fake_service_name = factory.make_name("service")
if expected_state is None:
if factory.pick_bool():
expected_state = SERVICE_STATE.ON
else:
expected_state = SERVICE_STATE.OFF
class FakeService(Service):
name = fake_name
service_name = fake_service_name
snap_service_name = fake_service_name
def getExpectedState(self):
return succeed((expected_state, status_info))
return FakeService()
def test_disabled_boot_architecture(self):
if factory.pick_bool():
ipv6 = True
ip = factory.make_ipv6_address()
else:
ipv6 = False
ip = factory.make_ipv4_address()
disabled_arches = random.sample(
[
boot_method for _, boot_method in BootMethodRegistry
if boot_method.arch_octet or boot_method.user_class
],
3,
)
output = config.compose_conditional_bootloader(
ipv6, ip, [bm.name for bm in disabled_arches])
for disabled_arch in disabled_arches:
if disabled_arch.arch_octet:
self.assertNotIn(disabled_arch.arch_octet, output)
else:
self.assertNotIn(disabled_arch.user_class, output)
def test_accepts_all_args(self):
all_test_arguments = cluster_config_command.all_arguments
default_arg_values = {
'--region-url': None,
'--uuid': None,
'--init': False,
'--tftp-port': None,
'--tftp-root': None,
'--debug': None,
}
failures = {}
# Try all cardinalities of combinations of arguments
for r in range(len(all_test_arguments) + 1):
for test_arg_names in combinations(all_test_arguments, r):
test_values = {
'--region-url': factory.make_simple_http_url(),
'--uuid': str(uuid.uuid4()),
'--init': '',
'--tftp-port': str(factory.pick_port()),
'--tftp-root': factory.make_string(),
'--debug': str(factory.pick_bool()),
}
# Build a query dictionary for the given combination of args
args_under_test = []
for param_name in test_arg_names:
args_under_test.append(param_name)
if param_name != '--init':
args_under_test.append(test_values[param_name])
parser = ArgumentParser()
cluster_config_command.add_arguments(parser)
# If both init and uuid are passed, argparse will generate
# a nice ArgumentError exception, which unfortunately,
# gets caught and sent to exit.
if '--init' in test_arg_names and '--uuid' in test_arg_names:
expected_exception = ExpectedException(SystemExit, '2')
with expected_exception, patch('sys.stderr'):
parser.parse_known_args(args_under_test)
else:
# Otherwise, parsed args with defaults as usual
observed_args = vars(parser.parse_args(args_under_test))
expected_args = {}
for param_name in all_test_arguments:
parsed_param_name = param_name[2:].replace('-', '_')
if param_name not in test_arg_names:
expected_args[parsed_param_name] = \
default_arg_values[param_name]
else:
expected_args[parsed_param_name] = \
observed_args[parsed_param_name]
if expected_args != observed_args:
failures[str(test_arg_names)] = {
'expected_args': expected_args,
'observed_args': observed_args,
}
error_message = io.StringIO()
error_message.write("One or more key / value argument list(s)"
"passed in the query string (expected_args)"
"to the API do not match the values in "
"the returned query string. This "
"means that some arguments were "
"dropped / added / changed by the "
"the function, which is incorrect "
"behavior. The list of incorrect "
"arguments is as follows: \n")
pp = pprint.PrettyPrinter(depth=3, stream=error_message)
pp.pprint(failures)
self.assertDictEqual({}, failures, error_message.getvalue())
def make_script(
scripts_dir=None, with_added_attribs=True, name=None,
script_version_id=None, timeout_seconds=None, parallel=None,
hardware_type=None, with_output=True):
if name is None:
name = factory.make_name('name')
if script_version_id is None:
script_version_id = random.randint(1, 1000)
if timeout_seconds is None:
timeout_seconds = random.randint(1, 1000)
if parallel is None:
parallel = random.randint(0, 2)
if hardware_type is None:
hardware_type = random.randint(0, 4)
global SCRIPT_RESULT_ID
script_result_id = SCRIPT_RESULT_ID
SCRIPT_RESULT_ID += 1
ret = {
'name': name,
'path': '%s/%s' % (random.choice(['commissioning', 'testing']), name),
'script_result_id': script_result_id,
'script_version_id': script_version_id,
'timeout_seconds': timeout_seconds,
'parallel': parallel,
'hardware_type': hardware_type,
'args': {},
'has_started': factory.pick_bool(),
}
ret['msg_name'] = '%s (id: %s, script_version_id: %s)' % (
name, script_result_id, script_version_id)
if with_added_attribs:
if scripts_dir is None:
scripts_dir = factory.make_name('scripts_dir')
out_dir = os.path.join(
scripts_dir, 'out', '%s.%s' % (name, script_result_id))
ret['combined_name'] = name
ret['combined_path'] = os.path.join(out_dir, ret['combined_name'])
ret['combined'] = factory.make_string()
ret['stdout_name'] = '%s.out' % name
ret['stdout_path'] = os.path.join(out_dir, ret['stdout_name'])
ret['stdout'] = factory.make_string()
ret['stderr_name'] = '%s.err' % name
ret['stderr_path'] = os.path.join(out_dir, ret['stderr_name'])
ret['stderr'] = factory.make_string()
ret['result_name'] = '%s.yaml' % name
ret['result_path'] = os.path.join(out_dir, ret['result_name'])
ret['result'] = factory.make_string()
ret['download_path'] = os.path.join(scripts_dir, 'downloads', name)
if os.path.exists(scripts_dir):
os.makedirs(out_dir, exist_ok=True)
os.makedirs(ret['download_path'], exist_ok=True)
script_path = os.path.join(scripts_dir, ret['path'])
os.makedirs(os.path.dirname(script_path), exist_ok=True)
with open(os.path.join(scripts_dir, ret['path']), 'w') as f:
f.write('#!/bin/bash')
st = os.stat(script_path)
os.chmod(script_path, st.st_mode | stat.S_IEXEC)
if with_output:
open(ret['combined_path'], 'w').write(ret['combined'])
open(ret['stdout_path'], 'w').write(ret['stdout'])
open(ret['stderr_path'], 'w').write(ret['stderr'])
open(ret['result_path'], 'w').write(ret['result'])
return ret
def test_config_set_debug_sets_debug(self):
expected = factory.pick_bool()
cluster_config_command.run(self.make_args(debug=expected))
with ClusterConfiguration.open() as config:
observed = config.debug
self.assertEqual(str(expected).lower(), observed)
def test_debug_enabled(self):
debug = factory.pick_bool()
self.useFixture(ClusterConfigurationFixture(debug=debug))
self.assertEqual(debug, debug_enabled())
def test_machine_asdict(self):
hostname = factory.make_name("hostname")
cores = random.randint(1, 8)
cpu_speed = random.randint(1000, 2000)
memory = random.randint(4096, 8192)
interfaces = [RequestedMachineInterface() for _ in range(3)]
known_host_interfaces = [KnownHostInterface() for _ in range(3)]
block_devices = [
RequestedMachineBlockDevice(
size=random.randint(512, 1024),
tags=[factory.make_name("tag") for _ in range(3)],
) for _ in range(3)
]
pinned_cores = random.sample(range(10), 3)
hugepages_backed = factory.pick_bool()
machine = RequestedMachine(
hostname=hostname,
architecture="amd64/generic",
cores=cores,
cpu_speed=cpu_speed,
pinned_cores=pinned_cores,
hugepages_backed=hugepages_backed,
memory=memory,
interfaces=interfaces,
known_host_interfaces=known_host_interfaces,
block_devices=block_devices,
)
self.assertThat(
machine.asdict(),
MatchesDict({
"hostname":
Equals(hostname),
"architecture":
Equals("amd64/generic"),
"cores":
Equals(cores),
"cpu_speed":
Equals(cpu_speed),
"memory":
Equals(memory),
"pinned_cores":
Equals(pinned_cores),
"hugepages_backed":
Equals(hugepages_backed),
"interfaces":
MatchesListwise([
MatchesDict({
"ifname":
Is(None),
"requested_ips":
Equals([]),
"ip_mode":
Is(None),
"attach_name":
Equals(interface.attach_name),
"attach_type":
Equals(interface.attach_type),
"attach_vlan":
Is(None),
"attach_options":
Equals(interface.attach_options),
}) for interface in interfaces
]),
"known_host_interfaces":
MatchesListwise([
MatchesDict({
"ifname":
Equals(known_host_interface.ifname),
"attach_name":
Equals(known_host_interface.attach_name),
"attach_type":
Equals(known_host_interface.attach_type),
"attach_vlan":
Is(None),
"dhcp_enabled":
Equals(False),
}) for known_host_interface in known_host_interfaces
]),
"block_devices":
MatchesListwise([
MatchesDict({
"size": Equals(block_device.size),
"tags": Equals(block_device.tags),
}) for block_device in block_devices
]),
}),
)
def test_creates_client_with_correct_arguments(self):
omapi_cli = self.patch(dhcp, "OmapiClient")
server = Mock()
server.ipv6 = factory.pick_bool()
dhcp._update_hosts(server, [], [], [])
omapi_cli.assert_called_once_with(server.omapi_key, server.ipv6)
def test_allows_ipv4_addresses_in_ipv6_format(self):
name = "[::ffff:%s]" % factory.make_ipv4_address()
url = factory.make_simple_http_url(netloc=name,
port=factory.pick_bool())
self.assertEqual(url, self.validator.to_python(url), "url: %s" % url)
def test_pick_bool_returns_bool(self):
self.assertIsInstance(factory.pick_bool(), bool)