def __init__(self, name, has_instance_uuid=None, has_uuid=None):
self.name = name
self.guestId = random.choice(["otherLinux64Guest", "otherLinuxGuest"])
if has_instance_uuid is None:
has_instance_uuid = random.choice([True, False])
if has_instance_uuid:
self.instanceUuid = factory.make_UUID()
if has_uuid is None:
has_uuid = random.choice([True, False])
if has_uuid:
self.uuid = factory.make_UUID()
def test_query_nodes_calls_query_all_nodes(self):
service = self.make_monitor_service()
service.max_nodes_at_once = sentinel.max_nodes_at_once
example_power_parameters = {
"system_id": factory.make_UUID(),
"hostname": factory.make_hostname(),
"power_state": factory.make_name("power_state"),
"power_type": factory.make_name("power_type"),
"context": {},
}
rpc_fixture = self.useFixture(MockClusterToRegionRPCFixture())
proto_region, io = rpc_fixture.makeEventLoop(
region.ListNodePowerParameters)
proto_region.ListNodePowerParameters.side_effect = [
succeed({"nodes": [example_power_parameters]}),
succeed({"nodes": []}),
]
query_all_nodes = self.patch(npms, "query_all_nodes")
d = service.query_nodes(getRegionClient())
io.flush()
self.assertEqual(None, extract_result(d))
self.assertThat(
query_all_nodes,
MockCalledOnceWith(
[example_power_parameters],
max_concurrency=sentinel.max_nodes_at_once,
clock=service.clock,
),
)
def test_returns_result(self):
uuid = factory.make_UUID()
api = make_api()
fake_result = make_fake_result("configResolveClass", "found")
self.patch(api, "config_resolve_class").return_value = fake_result
result = get_servers(api, uuid)
self.assertEqual("found", result[0].tag)
def test_calls_create_node_rpc(self):
protocol, connecting = self.prepare_region_rpc()
self.addCleanup((yield connecting))
protocol.CreateNode.return_value = defer.succeed(
{"system_id": factory.make_name("system-id")})
uuid = 'node-' + factory.make_UUID()
macs = sorted(factory.make_mac_address() for _ in range(3))
arch = factory.make_name('architecture')
hostname = factory.make_hostname()
domain = factory.make_name('domain')
power_type = factory.make_name('power_type')
power_parameters = {
'power_address': factory.make_ipv4_address(),
'power_user': factory.make_name('power_user'),
'power_pass': factory.make_name('power_pass'),
'power_control': None,
'system_id': uuid
}
yield create_node(
macs, arch, power_type, power_parameters, domain=domain,
hostname=hostname)
self.assertThat(
protocol.CreateNode, MockCalledOnceWith(
protocol, architecture=arch, power_type=power_type,
power_parameters=json.dumps(power_parameters),
mac_addresses=macs, domain=domain,
hostname=hostname))
def test_logs_error_on_duplicate_macs(self):
protocol, connecting = self.prepare_region_rpc()
self.addCleanup((yield connecting))
system_id = factory.make_name("system-id")
maaslog = self.patch(provisioningserver.rpc.utils, 'maaslog')
uuid = 'node-' + factory.make_UUID()
macs = sorted(factory.make_mac_address() for _ in range(3))
arch = factory.make_name('architecture')
power_type = factory.make_name('power_type')
power_parameters = {
'power_address': factory.make_ipv4_address(),
'power_user': factory.make_name('power_user'),
'power_pass': factory.make_name('power_pass'),
'power_control': None,
'system_id': uuid
}
protocol.CreateNode.side_effect = [
defer.succeed({"system_id": system_id}),
defer.fail(NodeAlreadyExists("Node already exists.")),
]
yield create_node(
macs, arch, power_type, power_parameters)
yield create_node(
macs, arch, power_type, power_parameters)
self.assertThat(
maaslog.error, MockCalledOnceWith(
"A node with one of the mac addresses in %s already "
"exists.", macs))
def test_passes_on_no_duplicate_macs(self):
protocol, connecting = self.prepare_region_rpc()
self.addCleanup((yield connecting))
system_id = factory.make_name("system-id")
protocol.CreateNode.return_value = defer.succeed(
{"system_id": system_id})
uuid = 'node-' + factory.make_UUID()
arch = factory.make_name('architecture')
power_type = factory.make_name('power_type')
power_parameters = {
'power_address': factory.make_ipv4_address(),
'power_user': factory.make_name('power_user'),
'power_pass': factory.make_name('power_pass'),
'power_control': None,
'system_id': uuid
}
# Create a list of MACs with one random duplicate.
macs = sorted(factory.make_mac_address() for _ in range(3))
macs_with_duplicate = macs + [choice(macs)]
yield create_node(
macs_with_duplicate, arch, power_type, power_parameters)
self.assertThat(
protocol.CreateNode, MockCalledOnceWith(
protocol, architecture=arch, power_type=power_type,
power_parameters=json.dumps(power_parameters),
mac_addresses=macs, domain=None, hostname=None))
def test_set_boot_order_storage_volume(self):
# zhmcclient_mock doesn't support storage groups.
serial = factory.make_UUID()
mock_storage_group = Mock()
mock_storage_group.storage_volumes.find.return_value.uri = serial
mock_partition = Mock()
mock_partition.list_attached_storage_groups.return_value = [
mock_storage_group,
]
mock_get_partition = self.patch(self.hmcz, "_get_partition")
mock_get_partition.return_value = mock_partition
yield self.hmcz.set_boot_order(
None,
self.make_context(),
[{
"id": random.randint(0, 100),
"name": factory.make_name("name"),
"id_path": factory.make_name("id_path"),
"model": factory.make_name("model"),
"serial": serial,
}] + [{
factory.make_name("key"): factory.make_name("value")
for _ in range(5)
} for _ in range(5)],
)
mock_partition.update_properties.assert_called_once_with({
"boot-device":
"storage-volume",
"boot-storage-volume":
serial,
})
def test_no_results_with_no_server_macs(self):
servers = [{'uuid': factory.make_UUID()}]
api = make_api()
self.patch(ucsm, 'get_servers').return_value = servers
self.patch(ucsm, 'get_macs').return_value = []
self.patch(ucsm, 'probe_lan_boot_options').return_value = ['option']
server_list = probe_servers(api)
self.assertEqual([], server_list)
def test_uses_uuid(self):
uuid = factory.make_UUID()
api = make_api()
mock = self.patch(api, "config_resolve_class")
get_servers(api, uuid)
filters = mock.call_args[0][1]
attrib = {"class": "computeItem", "property": "uuid", "value": uuid}
self.assertEqual(attrib, filters[0].attrib)
def test_no_results_with_no_server_macs(self):
servers = [{"uuid": factory.make_UUID()}]
api = make_api()
self.patch(ucsm, "get_servers").return_value = servers
self.patch(ucsm, "get_macs").return_value = []
self.patch(ucsm, "probe_lan_boot_options").return_value = ["option"]
server_list = probe_servers(api)
self.assertEqual([], server_list)
def test_uses_uuid(self):
uuid = factory.make_UUID()
api = make_api()
mock = self.patch(api, 'config_resolve_class')
get_servers(api, uuid)
filters = mock.call_args[0][1]
attrib = {'class': 'computeItem', 'property': 'uuid', 'value': uuid}
self.assertEqual(attrib, filters[0].attrib)
def test_returns_results(self):
servers = [{'uuid': factory.make_UUID()}]
mac = 'mac'
api = make_api()
self.patch(ucsm, 'get_servers').return_value = servers
self.patch(ucsm, 'get_macs').return_value = [mac]
self.patch(ucsm, 'probe_lan_boot_options').return_value = ['option']
server_list = probe_servers(api)
self.assertEqual([(servers[0], [mac])], server_list)
def test_returns_results(self):
servers = [{"uuid": factory.make_UUID()}]
mac = "mac"
api = make_api()
self.patch(ucsm, "get_servers").return_value = servers
self.patch(ucsm, "get_macs").return_value = [mac]
self.patch(ucsm, "probe_lan_boot_options").return_value = ["option"]
server_list = probe_servers(api)
self.assertEqual([(servers[0], [mac])], server_list)
def test_re_config_file_matches_pxelinux_cfg_with_hardware_uuid(self):
hardware_uuid = factory.make_UUID().encode()
match = re_config_file.match(b'pxelinux.cfg/%s' % hardware_uuid)
self.assertIsNotNone(match)
self.assertDictEqual(
{
'mac': None,
'hardware_uuid': hardware_uuid,
'arch': None,
'subarch': None,
}, match.groupdict())
def configure_hivex(self):
mock_hivex = mock.MagicMock()
self.patch(windows_module, 'load_hivex').return_value = mock_hivex
mock_hivex.node_name.side_effect = ['Objects',
Bcd.GUID_WINDOWS_BOOTMGR,
Bcd.BOOT_MGR_DISPLAY_ORDER]
mock_hivex.node_children.side_effect = [
[factory.make_name('objects')], [factory.make_name('object')],
['value0', factory.make_UUID()],
[factory.make_name('element')]]
mock_hivex.node_values.return_value = [factory.make_name('val')]
def test_power_state_error_on_unknown_state(self):
url = factory.make_name('url')
username = factory.make_name('username')
password = factory.make_name('password')
uuid = factory.make_UUID()
api = Mock()
self.patch(ucsm, 'UCSM_XML_API').return_value = api
get_servers_mock = self.patch(ucsm, 'get_servers')
get_servers_mock.return_value = [make_server()]
self.assertRaises(UCSM_XML_API_Error, power_state_ucsm, url, username,
password, uuid)
def test_power_state_get_on(self):
url = factory.make_name("url")
username = factory.make_name("username")
password = factory.make_name("password")
uuid = factory.make_UUID()
api = Mock()
self.patch(ucsm, "UCSM_XML_API").return_value = api
get_servers_mock = self.patch(ucsm, "get_servers")
get_servers_mock.return_value = [make_server("on")]
power_state = power_state_ucsm(url, username, password, uuid)
self.expectThat(get_servers_mock, MockCalledOnceWith(api, uuid))
self.expectThat(power_state, Equals("on"))
def test_re_config_file_matches_pxelinux_cfg_with_hardware_uuid(self):
hardware_uuid = factory.make_UUID().encode()
match = re_config_file.match(b"pxelinux.cfg/%s" % hardware_uuid)
self.assertIsNotNone(match)
self.assertDictEqual(
{
"mac": None,
"hardware_uuid": hardware_uuid,
"arch": None,
"subarch": None,
},
match.groupdict(),
)
def test_power_state_get_on(self):
url = factory.make_name('url')
username = factory.make_name('username')
password = factory.make_name('password')
uuid = factory.make_UUID()
api = Mock()
self.patch(ucsm, 'UCSM_XML_API').return_value = api
get_servers_mock = self.patch(ucsm, 'get_servers')
get_servers_mock.return_value = [make_server("on")]
power_state = power_state_ucsm(url, username, password, uuid)
self.expectThat(get_servers_mock, MockCalledOnceWith(api, uuid))
self.expectThat(power_state, Equals('on'))
def make_parameters(self):
system_id = factory.make_name("system_id")
url = factory.make_name("power_address")
username = factory.make_name("power_user")
password = factory.make_name("power_pass")
uuid = factory.make_UUID()
context = {
"system_id": system_id,
"power_address": url,
"power_user": username,
"power_pass": password,
"uuid": uuid,
}
return system_id, url, username, password, uuid, context
def make_parameters(self):
system_id = factory.make_name('system_id')
url = factory.make_name('power_address')
username = factory.make_name('power_user')
password = factory.make_name('power_pass')
uuid = factory.make_UUID()
context = {
'system_id': system_id,
'power_address': url,
'power_user': username,
'power_pass': password,
'uuid': uuid,
}
return system_id, url, username, password, uuid, context
def test__get_boot_sources_calls_get_boot_sources_v2_before_v1(self):
clock = Clock()
client_call = Mock()
client_call.side_effect = [
defer.succeed(dict(sources=sentinel.sources)),
]
client_call.localIdent = factory.make_UUID()
service = ImageDownloadService(sentinel.rpc, sentinel.tftp_root, clock)
sources = yield service._get_boot_sources(client_call)
self.assertEqual(sources.get('sources'), sentinel.sources)
self.assertThat(
client_call,
MockCalledOnceWith(GetBootSourcesV2, uuid=client_call.localIdent))
def test__get_boot_sources_calls_get_boot_sources_v1_on_v2_missing(self):
clock = Clock()
client_call = Mock()
client_call.side_effect = [
defer.fail(UnhandledCommand()),
defer.succeed(dict(sources=[])),
]
client_call.localIdent = factory.make_UUID()
service = ImageDownloadService(sentinel.rpc, sentinel.tftp_root, clock)
yield service._get_boot_sources(client_call)
self.assertThat(
client_call,
MockCallsMatch(call(GetBootSourcesV2, uuid=client_call.localIdent),
call(GetBootSources, uuid=client_call.localIdent)))
def test_returns_system_id_of_new_node(self):
protocol, connecting = self.prepare_region_rpc()
self.addCleanup((yield connecting))
system_id = factory.make_name("system-id")
protocol.CreateNode.return_value = defer.succeed(
{"system_id": system_id})
get_cluster_uuid = self.patch(
provisioningserver.utils, 'get_cluster_uuid')
get_cluster_uuid.return_value = 'cluster-' + factory.make_UUID()
uuid = 'node-' + factory.make_UUID()
macs = sorted(factory.make_mac_address() for _ in range(3))
arch = factory.make_name('architecture')
power_type = factory.make_name('power_type')
power_parameters = {
'power_address': factory.make_ipv4_address(),
'power_user': factory.make_name('power_user'),
'power_pass': factory.make_name('power_pass'),
'power_control': None,
'system_id': uuid
}
new_system_id = yield create_node(
macs, arch, power_type, power_parameters)
self.assertEqual(system_id, new_system_id)
def configure_hivex(self):
mock_hivex = mock.MagicMock()
self.patch(windows_module, "load_hivex").return_value = mock_hivex
mock_hivex.node_name.side_effect = [
"Objects",
Bcd.GUID_WINDOWS_BOOTMGR,
Bcd.BOOT_MGR_DISPLAY_ORDER,
]
mock_hivex.node_children.side_effect = [
[factory.make_name("objects")],
[factory.make_name("object")],
["value0", factory.make_UUID()],
[factory.make_name("element")],
]
mock_hivex.node_values.return_value = [factory.make_name("val")]
def test_try_query_nodes_logs_other_errors(self):
service = self.make_monitor_service()
self.patch(npms, "getRegionClient").return_value = sentinel.client
sentinel.client.localIdent = factory.make_UUID()
query_nodes = self.patch(service, "query_nodes")
query_nodes.return_value = fail(
ZeroDivisionError("Such a shame I can't divide by zero"))
with FakeLogger("maas") as maaslog, TwistedLoggerFixture():
d = service.try_query_nodes()
self.assertEqual(None, extract_result(d))
self.assertDocTestMatches(
"Failed to query nodes' power status: "
"Such a shame I can't divide by zero",
maaslog.output)
def test_power_control_ucsm(self):
uuid = factory.make_UUID()
api = Mock()
self.patch(ucsm, 'UCSM_XML_API').return_value = api
get_servers_mock = self.patch(ucsm, 'get_servers')
server = make_server()
state = 'admin-down'
power_control = Element('lsPower', {'state': state})
get_servers_mock.return_value = [server]
get_server_power_control_mock = self.patch(ucsm,
'get_server_power_control')
get_server_power_control_mock.return_value = power_control
set_server_power_control_mock = self.patch(ucsm,
'set_server_power_control')
power_control_ucsm('url', 'username', 'password', uuid, 'off')
self.assertThat(get_servers_mock, MockCalledOnceWith(api, uuid))
self.assertThat(set_server_power_control_mock,
MockCalledOnceWith(api, power_control, state))
def test_power_control_ucsm(self):
uuid = factory.make_UUID()
api = Mock()
self.patch(ucsm, "UCSM_XML_API").return_value = api
get_servers_mock = self.patch(ucsm, "get_servers")
server = make_server()
state = "admin-down"
power_control = Element("lsPower", {"state": state})
get_servers_mock.return_value = [server]
get_server_power_control_mock = self.patch(ucsm,
"get_server_power_control")
get_server_power_control_mock.return_value = power_control
set_server_power_control_mock = self.patch(ucsm,
"set_server_power_control")
power_control_ucsm("url", "username", "password", uuid, "off")
self.assertThat(get_servers_mock, MockCalledOnceWith(api, uuid))
self.assertThat(
set_server_power_control_mock,
MockCalledOnceWith(api, power_control, state),
)
def test_class_id(self):
uuid = factory.make_UUID()
api = make_api()
mock = self.patch(api, "config_resolve_class")
get_servers(api, uuid)
self.assertThat(mock, MockCalledOnceWith("computeItem", ANY))
def test_make_UUID(self):
uuid = factory.make_UUID()
self.assertIsInstance(uuid, str)
self.assertEqual(36, len(uuid))
