def test_astute_message_creation(self, mmake_astute_message, mrpc):
# 'discover' node is not deployed yet -- it will be removed
# immediately
n_discover = self.add_node(consts.NODE_STATUSES.discover)
# 'ready' node is deployed -- astute will take care of it
self.add_node(consts.NODE_STATUSES.ready)
# 'offline' node will also be passed to astute
self.add_node(consts.NODE_STATUSES.ready, online=False)
nodes = DeletionTask.get_task_nodes_for_cluster(self.cluster_db)
astute_nodes = [
node for node in nodes['nodes_to_delete']
if node['id'] != n_discover.id
]
self.assertEqual(len(nodes['nodes_to_delete']), 3)
self.assertEqual(len(nodes['nodes_to_restore']), 0)
task = models.Task(name=consts.TASK_NAMES.cluster_deletion,
cluster=self.cluster_db)
db().add(task)
db().commit()
DeletionTask.execute(task, nodes=nodes)
self.assertEqual(mmake_astute_message.call_count, 1)
message = mmake_astute_message.call_args[0][3]
self.assertIn('nodes', message)
self.assertItemsEqual(message['nodes'], astute_nodes)
self.assertEqual(mrpc.cast.call_count, 1)
def test_undeployed_node_called(
self,
mremove_undeployed_nodes_from_db,
mmake_astute_message,
mrpc):
self.add_node(consts.NODE_STATUSES.discover)
nodes = DeletionTask.get_task_nodes_for_cluster(self.cluster_db)
self.assertEqual(len(nodes['nodes_to_delete']), 1)
self.assertEqual(len(nodes['nodes_to_restore']), 0)
task = models.Task(
name=consts.TASK_NAMES.cluster_deletion,
cluster=self.cluster_db
)
db().add(task)
db().commit()
mremove_undeployed_nodes_from_db.return_value = []
DeletionTask.execute(task, nodes=nodes)
mremove_undeployed_nodes_from_db.assert_called_once_with(
nodes['nodes_to_delete'])
self.assertEqual(mmake_astute_message.call_count, 1)
self.assertEqual(mrpc.cast.call_count, 1)
def test_does_not_fail_if_there_is_deleted_task(self):
task = models.Task(name=consts.TASK_NAMES.deployment,
deleted_at=datetime.datetime.now(),
cluster_id=self.cluster.id)
db.add(task)
db.flush()
self.assertNotRaises(errors.TaskAlreadyRunning,
self.task_manager.check_running_task)
def test_deploy_disabled_dpdk_check_ok_without_numa_meta(self, _):
node = self.env.nodes[0]
node.meta.pop('numa_topology', {})
task = models.Task(name=consts.TASK_NAMES.deployment,
cluster=self.cluster)
self.assertNotRaises(errors.InvalidData,
CheckBeforeDeploymentTask.execute, task)
def test_fails_if_there_is_task(self):
task = models.Task(name=consts.TASK_NAMES.deployment,
cluster_id=self.cluster.id,
status=consts.TASK_STATUSES.pending)
db.add(task)
db.flush()
self.assertRaises(errors.TaskAlreadyRunning,
self.task_manager.check_running_task)
def test_no_node_no_cry(self):
cluster = self.env.create_cluster(api=True)
cluster_id = cluster['id']
manager_ = manager.ApplyChangesTaskManager(cluster_id)
task = models.Task(name='provision', cluster_id=cluster_id)
self.db.add(task)
self.db.commit()
rpc.receiver.NailgunReceiver.deploy_resp(nodes=[
{'uid': 666, 'id': 666, 'status': 'discover'}
], task_uuid=task.uuid)
self.assertRaises(errors.WrongNodeStatus, manager_.execute)
def test_skip_private_net_for_the_only_node_wo_dpdk(self):
self.env.create_node(cluster_id=self.cluster.id,
pending_addition=True,
roles=['compute'])
self.assertEqual(len(self.env.nodes), 2)
dpdk_iface = None
network_config = []
private_ifaces = {}
for node in self.env.nodes:
nic_1 = node.interfaces[0]
nic_2 = node.interfaces[1]
default_vlans = {
consts.NETWORKS.public: [100],
consts.NETWORKS.storage: [101],
consts.NETWORKS.management: [102],
consts.NETWORKS.fuelweb_admin: [103],
consts.NETWORKS.private: [1234, 1235]
}
if not dpdk_iface:
dpdk_iface = nic_2
nets_1 = nic_1.assigned_networks_list
nets_2 = nic_2.assigned_networks_list
for i, net in enumerate(nets_1):
if net['name'] == consts.NETWORKS.private:
nets_2.append(nets_1.pop(i))
break
objects.NIC.assign_networks(nic_1, nets_1)
objects.NIC.assign_networks(nic_2, nets_2)
node.status = consts.NODE_STATUSES.ready
for iface in node.interfaces:
for ng in iface.assigned_networks_list:
network_config.append({'name': ng.name,
'vlans': default_vlans[ng.name]})
if ng.name == consts.NETWORKS.private:
private_ifaces[node.name] = iface.name
dpdk_iface.attributes['dpdk']['enabled']['value'] = True
task = models.Task(
name=consts.TASK_NAMES.check_networks,
cluster=self.cluster
)
verify_task = VerifyNetworksTask(task, network_config)
message = verify_task.get_message_body()
for node in message['nodes']:
self.assertNotIn(private_ifaces[node['name']],
(n['iface'] for n in node['networks']))
def test_does_not_fail_if_there_is_deleted_task(self):
for task_name in DeploymentCheckMixin.deployment_tasks:
task = models.Task(name=task_name,
deleted_at=datetime.datetime.now(),
cluster_id=self.cluster.id)
db.add(task)
db.flush()
self.addCleanup(db.query(models.Task).delete)
self.assertNotRaises(
errors.DeploymentAlreadyStarted,
DeploymentCheckMixin.check_no_running_deployment, self.cluster)
def test_fails_if_there_is_task(self):
for task_name in DeploymentCheckMixin.deployment_tasks:
task = models.Task(name=task_name, cluster_id=self.cluster.id)
db.add(task)
db.flush()
self.assertRaisesWithMessage(
errors.DeploymentAlreadyStarted,
'Cannot perform the actions because there are '
'running tasks {0}'.format([task]),
DeploymentCheckMixin.check_no_running_deployment, self.cluster)
db.query(models.Task).delete()
def POST(self, cluster_id):
cluster = self.get_object_or_404(objects.Cluster, cluster_id)
data = self.checked_data()
node_id = data["node_id"]
node = self.get_object_or_404(objects.Node, node_id)
netgroups_mapping = self.get_netgroups_map(node.cluster, cluster)
orig_roles = node.roles
objects.Node.update_roles(node, []) # flush
objects.Node.update_pending_roles(node, []) # flush
node.replaced_deployment_info = []
node.deployment_info = []
node.kernel_params = None
node.cluster_id = cluster.id
node.group_id = None
objects.Node.assign_group(node) # flush
objects.Node.update_pending_roles(node, orig_roles) # flush
for ip in node.ip_addrs:
ip.network = netgroups_mapping[ip.network]
nic_assignments = db.query(models.NetworkNICAssignment).\
join(models.NodeNICInterface).\
filter(models.NodeNICInterface.node_id == node.id).\
all()
for nic_assignment in nic_assignments:
nic_assignment.network_id = \
netgroups_mapping[nic_assignment.network_id]
bond_assignments = db.query(models.NetworkBondAssignment).\
join(models.NodeBondInterface).\
filter(models.NodeBondInterface.node_id == node.id).\
all()
for bond_assignment in bond_assignments:
bond_assignment.network_id = \
netgroups_mapping[bond_assignment.network_id]
objects.Node.add_pending_change(node,
consts.CLUSTER_CHANGES.interfaces)
node.pending_addition = True
node.pending_deletion = False
task = models.Task(name=consts.TASK_NAMES.node_deletion,
cluster=cluster)
db.commit()
self.delete_node_by_astute(task, node)
def test_execute_with_zabbix_node(self, mock_zabbix_manager,
mmake_astute_message, mrpc):
self.add_node(consts.NODE_STATUSES.ready)
nodes = DeletionTask.get_task_nodes_for_cluster(self.cluster_db)
self.assertEqual(len(nodes['nodes_to_delete']), 1)
task = models.Task(name=consts.TASK_NAMES.cluster_deletion,
cluster=self.cluster_db)
db().add(task)
db().commit()
DeletionTask.execute(task, nodes=nodes)
self.assertEqual(mock_zabbix_manager.get_zabbix_node.called, False)
