def test_wait_for_introspection_partial_success(self):
mock_inspector = mock.Mock()
self.node_uuids = [
'NODE1',
'NODE2',
]
mock_inspector.get_status.side_effect = [{
'finished': True,
'error': None
}, {
'finished': True,
'error': "Failed"
}]
result = utils.wait_for_node_introspection(mock_inspector,
self.node_uuids,
loops=4,
sleep=0.01)
self.assertEqual(list(result), [('NODE1', {
'error': None,
'finished': True
}), ('NODE2', {
'error': "Failed",
'finished': True
})])
def test_wait_for_introspection_success(self):
mock_inspector = mock.Mock()
self.node_uuids = [
'NODE1',
'NODE2',
]
mock_inspector.get_status.return_value = {
'finished': True,
'error': None
}
result = utils.wait_for_node_introspection(mock_inspector,
self.node_uuids,
loops=4,
sleep=0.01)
self.assertEqual(list(result), [('NODE1', {
'error': None,
'finished': True
}), ('NODE2', {
'error': None,
'finished': True
})])
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
client = self.app.client_manager.baremetal
inspector_client = self.app.client_manager.baremetal_introspection
node_uuids = []
print("Setting nodes for introspection to manageable...")
self.log.debug("Moving available/enroll nodes to manageable state.")
available_nodes = utils.nodes_in_states(client,
("available", "enroll"))
for uuid in utils.set_nodes_state(client, available_nodes, 'manage',
'manageable'):
self.log.debug("Node {0} has been set to manageable.".format(uuid))
manageable_nodes = utils.nodes_in_states(client, ("manageable",))
for node in manageable_nodes:
node_uuids.append(node.uuid)
print("Starting introspection of node: {0}".format(node.uuid))
inspector_client.introspect(node.uuid)
# NOTE(dtantsur): PXE firmware on virtual machines misbehaves when
# a lot of nodes start DHCPing simultaneously: it ignores NACK from
# DHCP server, tries to get the same address, then times out. Work
# around it by using sleep, anyway introspection takes much longer.
time.sleep(5)
print("Waiting for introspection to finish...")
errors = []
successful_node_uuids = set()
for uuid, status in utils.wait_for_node_introspection(
inspector_client, node_uuids):
if status['error'] is None:
print("Introspection for UUID {0} finished successfully."
.format(uuid))
successful_node_uuids.add(uuid)
else:
print("Introspection for UUID {0} finished with error: {1}"
.format(uuid, status['error']))
errors.append("%s: %s" % (uuid, status['error']))
print("Setting manageable nodes to available...")
self.log.debug("Moving manageable nodes to available state.")
successful_nodes = [n for n in manageable_nodes
if n.uuid in successful_node_uuids]
for uuid in utils.set_nodes_state(
client, successful_nodes, 'provide',
'available', skipped_states=("available", "active")):
print("Node {0} has been set to available.".format(uuid))
if errors:
raise exceptions.IntrospectionError(
"Introspection completed with errors:\n%s" % '\n'.join(errors))
else:
print("Introspection completed.")
def test_wait_for_introspection_timeout(self):
mock_inspector = mock.Mock()
self.node_uuids = ["NODE1", "NODE2"]
mock_inspector.get_status.return_value = {"finished": False, "error": None}
result = utils.wait_for_node_introspection(mock_inspector, "TOKEN", "URL", self.node_uuids, loops=4, sleep=0.01)
self.assertEqual(list(result), [])
def test_wait_for_introspection_partial_success(self):
mock_inspector = mock.Mock()
self.node_uuids = ["NODE1", "NODE2"]
mock_inspector.get_status.side_effect = [
{"finished": True, "error": None},
{"finished": True, "error": "Failed"},
]
result = utils.wait_for_node_introspection(mock_inspector, "TOKEN", "URL", self.node_uuids, loops=4, sleep=0.01)
self.assertEqual(
list(result),
[("NODE1", {"error": None, "finished": True}), ("NODE2", {"error": "Failed", "finished": True})],
)
def _run_introspection(self, nodes):
inspector_client = self.app.client_manager.baremetal_introspection
node_uuids = []
for node in nodes:
print("Starting introspection on node {0}".format(node.uuid))
inspector_client.introspect(node.uuid)
node_uuids.append(node.uuid)
print("Waiting for introspection to finish")
for uuid, status in utils.wait_for_node_introspection(
inspector_client, node_uuids):
if status['error'] is None:
print("Introspection for node {0} finished successfully."
.format(uuid))
else:
print("Introspection for node {0} finished with error: {1}"
.format(uuid, status['error']))
def test_wait_for_introspection_timeout(self):
mock_inspector = mock.Mock()
self.node_uuids = [
'NODE1',
'NODE2',
]
mock_inspector.get_status.return_value = {
'finished': False,
'error': None
}
result = utils.wait_for_node_introspection(mock_inspector,
self.node_uuids,
loops=4, sleep=0.01)
self.assertEqual(list(result), [])
def _run_introspection(self, nodes):
inspector_client = self.app.client_manager.baremetal_introspection
node_uuids = []
for node in nodes:
print("Starting introspection on node {0}".format(node.uuid))
inspector_client.introspect(node.uuid)
node_uuids.append(node.uuid)
print("Waiting for introspection to finish")
for uuid, status in utils.wait_for_node_introspection(
inspector_client, node_uuids):
if status['error'] is None:
print(
"Introspection for node {0} finished successfully.".format(
uuid))
else:
print("Introspection for node {0} finished with error: {1}".
format(uuid, status['error']))
def test_wait_for_introspection_success(self):
mock_inspector = mock.Mock()
self.node_uuids = [
'NODE1',
'NODE2',
]
mock_inspector.get_status.return_value = {
'finished': True,
'error': None
}
result = utils.wait_for_node_introspection(mock_inspector, "TOKEN",
"URL", self.node_uuids,
loops=4, sleep=0.01)
self.assertEqual(list(result), [
('NODE1', {'error': None, 'finished': True}),
('NODE2', {'error': None, 'finished': True})
])
def test_wait_for_introspection_timeout(self):
mock_inspector = mock.Mock()
self.node_uuids = [
'NODE1',
'NODE2',
]
mock_inspector.get_status.return_value = {
'finished': False,
'error': None
}
result = utils.wait_for_node_introspection(mock_inspector,
"TOKEN",
"URL",
self.node_uuids,
loops=4,
sleep=0.01)
self.assertEqual(list(result), [])
def test_wait_for_introspection_partial_success(self):
mock_inspector = mock.Mock()
self.node_uuids = [
'NODE1',
'NODE2',
]
mock_inspector.get_status.side_effect = [{
'finished': True,
'error': None
}, {
'finished': True,
'error': "Failed"
}]
result = utils.wait_for_node_introspection(mock_inspector,
self.node_uuids,
loops=4, sleep=0.01)
self.assertEqual(list(result), [
('NODE1', {'error': None, 'finished': True}),
('NODE2', {'error': "Failed", 'finished': True})
])
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
client = self.app.client_manager.tripleoclient.baremetal()
auth_token = self.app.client_manager.auth_ref.auth_token
node_uuids = []
print("Setting available nodes to manageable...")
self.log.debug("Moving available nodes to manageable state.")
available_nodes = [node for node in client.node.list()
if node.provision_state == "available"]
for uuid in utils.set_nodes_state(client, available_nodes, 'manage',
'manageable'):
self.log.debug("Node {0} has been set to manageable.".format(uuid))
for node in client.node.list():
if node.provision_state != "manageable":
continue
node_uuids.append(node.uuid)
print("Starting introspection of node: {0}".format(node.uuid))
inspector_client.introspect(
node.uuid,
base_url=parsed_args.inspector_url,
auth_token=auth_token)
# NOTE(dtantsur): PXE firmware on virtual machines misbehaves when
# a lot of nodes start DHCPing simultaneously: it ignores NACK from
# DHCP server, tries to get the same address, then times out. Work
# around it by using sleep, anyway introspection takes much longer.
time.sleep(5)
print("Waiting for introspection to finish...")
has_errors = False
for uuid, status in utils.wait_for_node_introspection(
inspector_client, auth_token, parsed_args.inspector_url,
node_uuids):
if status['error'] is None:
print("Introspection for UUID {0} finished successfully."
.format(uuid))
else:
print("Introspection for UUID {0} finished with error: {1}"
.format(uuid, status['error']))
has_errors = True
clients = self.app.client_manager
baremetal_client = clients.tripleoclient.baremetal()
print("Setting manageable nodes to available...")
self.log.debug("Moving manageable nodes to available state.")
available_nodes = [node for node in client.node.list()
if node.provision_state == "manageable"]
for uuid in utils.set_nodes_state(
baremetal_client, baremetal_client.node.list(), 'provide',
'available', skipped_states=("available", "active")):
print("Node {0} has been set to available.".format(uuid))
if has_errors:
print("Introspection completed with errors.")
else:
print("Introspection completed.")
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
client = self.app.client_manager.baremetal
inspector_client = self.app.client_manager.baremetal_introspection
node_uuids = []
print("Setting nodes for introspection to manageable...")
self.log.debug("Moving available/enroll nodes to manageable state.")
available_nodes = utils.nodes_in_states(client,
("available", "enroll"))
for uuid in utils.set_nodes_state(client, available_nodes, 'manage',
'manageable'):
self.log.debug("Node {0} has been set to manageable.".format(uuid))
manageable_nodes = utils.nodes_in_states(client, ("manageable", ))
for node in manageable_nodes:
node_uuids.append(node.uuid)
print("Starting introspection of node: {0}".format(node.uuid))
inspector_client.introspect(node.uuid)
# NOTE(dtantsur): PXE firmware on virtual machines misbehaves when
# a lot of nodes start DHCPing simultaneously: it ignores NACK from
# DHCP server, tries to get the same address, then times out. Work
# around it by using sleep, anyway introspection takes much longer.
time.sleep(5)
print("Waiting for introspection to finish...")
errors = []
successful_node_uuids = set()
for uuid, status in utils.wait_for_node_introspection(
inspector_client, node_uuids):
if status['error'] is None:
print(
"Introspection for UUID {0} finished successfully.".format(
uuid))
successful_node_uuids.add(uuid)
else:
print("Introspection for UUID {0} finished with error: {1}".
format(uuid, status['error']))
errors.append("%s: %s" % (uuid, status['error']))
print("Setting manageable nodes to available...")
self.log.debug("Moving manageable nodes to available state.")
successful_nodes = [
n for n in manageable_nodes if n.uuid in successful_node_uuids
]
for uuid in utils.set_nodes_state(client,
successful_nodes,
'provide',
'available',
skipped_states=("available",
"active")):
print("Node {0} has been set to available.".format(uuid))
if errors:
raise exceptions.IntrospectionError(
"Introspection completed with errors:\n%s" % '\n'.join(errors))
else:
print("Introspection completed.")
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
client = self.app.client_manager.tripleoclient.baremetal
auth_token = self.app.client_manager.auth_ref.auth_token
node_uuids = []
print("Setting available nodes to manageable...")
self.log.debug("Moving available nodes to manageable state.")
available_nodes = [
node
for node in client.node.list(maintenance=False, associated=False)
if node.provision_state == "available"
]
for uuid in utils.set_nodes_state(client, available_nodes, 'manage',
'manageable'):
self.log.debug("Node {0} has been set to manageable.".format(uuid))
for node in client.node.list(maintenance=False, associated=False):
if node.provision_state != "manageable":
continue
node_uuids.append(node.uuid)
print("Starting introspection of node: {0}".format(node.uuid))
inspector_client.introspect(node.uuid,
base_url=parsed_args.inspector_url,
auth_token=auth_token)
# NOTE(dtantsur): PXE firmware on virtual machines misbehaves when
# a lot of nodes start DHCPing simultaneously: it ignores NACK from
# DHCP server, tries to get the same address, then times out. Work
# around it by using sleep, anyway introspection takes much longer.
time.sleep(5)
print("Waiting for introspection to finish...")
has_errors = False
for uuid, status in utils.wait_for_node_introspection(
inspector_client, auth_token, parsed_args.inspector_url,
node_uuids):
if status['error'] is None:
print(
"Introspection for UUID {0} finished successfully.".format(
uuid))
else:
print("Introspection for UUID {0} finished with error: {1}".
format(uuid, status['error']))
has_errors = True
print("Setting manageable nodes to available...")
self.log.debug("Moving manageable nodes to available state.")
available_nodes = [
node
for node in client.node.list(maintenance=False, associated=False)
if node.provision_state == "manageable"
]
for uuid in utils.set_nodes_state(client,
available_nodes,
'provide',
'available',
skipped_states=("available",
"active")):
print("Node {0} has been set to available.".format(uuid))
if has_errors:
print("Introspection completed with errors.")
else:
print("Introspection completed.")
