def execute(self, nodes_to_deployment):
TaskHelper.update_slave_nodes_fqdn(nodes_to_deployment)
logger.debug('Nodes to deploy: {0}'.format(
' '.join([n.fqdn for n in nodes_to_deployment])))
task_deployment = Task(name='deployment', cluster=self.cluster)
db().add(task_deployment)
db().commit()
deployment_message = self._call_silently(
task_deployment,
tasks.DeploymentTask,
nodes_to_deployment,
method_name='message')
db().refresh(task_deployment)
task_deployment.cache = deployment_message
for node in nodes_to_deployment:
node.status = 'deploying'
node.progress = 0
db().commit()
rpc.cast('naily', deployment_message)
return task_deployment
def test_verify_networks_resp_empty_nodes_default_error(self):
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
task = Task(
name="super",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
'nodes': []
}
}
self.db.add(task)
self.db.commit()
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': []}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "error")
error_msg = 'At least two nodes are required to be in ' \
'the environment for network verification.'
self.assertEqual(task.message, error_msg)
def test_verify_networks_resp_empty_nodes_default_error(self):
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
task = Task(
name="super",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
'nodes': []
}
}
self.db.add(task)
self.db.commit()
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': []}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "error")
error_msg = 'At least two nodes are required to be in ' \
'the environment for network verification.'
self.assertEqual(task.message, error_msg)
def test_verify_networks_resp_without_vlans_only_erred(self):
"""Verify that network verification without vlans fails
when not all sended info received
"""
self.env.create(cluster_kwargs={},
nodes_kwargs=[{
"api": False
}, {
"api": False
}])
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': [0]}]
nets_resp = [{'iface': 'eth0', 'vlans': []}]
task = Task(name="super", cluster_id=cluster_db.id)
task.cache = {
"args": {
'nodes': [{
'uid': node1.id,
'networks': nets_sent
}, {
'uid': node2.id,
'networks': nets_sent
}]
}
}
self.db.add(task)
self.db.commit()
kwargs = {
'task_uuid':
task.uuid,
'status':
'ready',
'nodes': [{
'uid': node1.id,
'networks': nets_resp
}, {
'uid': node2.id,
'networks': nets_resp
}]
}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "error")
error_nodes = [{
'uid': node1.id,
'interface': 'eth0',
'name': node1.name,
'mac': node1.interfaces[0].mac,
'absent_vlans': nets_sent[0]['vlans']
}, {
'uid': node2.id,
'interface': 'eth0',
'name': node2.name,
'mac': node2.interfaces[0].mac,
'absent_vlans': nets_sent[0]['vlans']
}]
self.assertEqual(task.result, error_nodes)
def test_verify_networks_resp_empty_nodes_default_error(self):
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
task = Task(
name="super",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent}]
}
}
self.db.add(task)
self.db.commit()
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': []}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "error")
error_msg = 'Please add more nodes to the environment ' \
'before performing network verification.'
self.assertEqual(task.message, error_msg)
def test_verify_networks_resp_partially_without_vlans(self):
"""Verify that network verification partially without vlans passes
"""
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': [0]},
{'iface': 'eth1', 'vlans': range(100, 104)}]
task = Task(
name="super",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent}]
}
}
self.db.add(task)
self.db.commit()
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent}]}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "ready")
def test_verify_networks_resp_empty_nodes_custom_error(self):
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
task = Task(
name="super",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent}]
}
}
self.db.add(task)
self.db.commit()
error_msg = 'Custom error message.'
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': [],
'error': error_msg}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "error")
self.assertEqual(task.message, error_msg)
def test_verify_networks_resp_partially_without_vlans(self):
"""Verify that network verification partially without vlans passes
"""
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': [0]},
{'iface': 'eth1', 'vlans': range(100, 104)}]
task = Task(
name="super",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent}]
}
}
self.db.add(task)
self.db.commit()
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent}]}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "ready")
def test_verify_networks_resp(self):
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets = [{'iface': 'eth0', 'vlans': range(100, 105)}]
task = Task(
name="verify_networks",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
"nodes": [{'uid': node1.id, 'networks': nets},
{'uid': node2.id, 'networks': nets}]
}
}
self.db.add(task)
self.db.commit()
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': [{'uid': node1.id, 'networks': nets},
{'uid': node2.id, 'networks': nets}]}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "ready")
self.assertEqual(task.message, None)
def test_verify_networks_resp_incomplete_network_data_error(self):
# One node has single interface
meta = self.env.default_metadata()
mac = '02:07:43:78:4F:58'
self.env.set_interfaces_in_meta(
meta, [{'name': 'eth0', 'mac': mac}])
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False, 'name': 'node1'},
{"api": False, 'name': 'node2', 'meta': meta},
{"api": False, 'name': 'node3'}
]
)
cluster_db = self.env.clusters[0]
node1, node2, node3 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)},
{'iface': 'eth1', 'vlans': [106]},
{'iface': 'eth2', 'vlans': [107]}]
task = Task(
name="super",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent},
{'uid': node3.id, 'networks': nets_sent}]
}
}
self.db.add(task)
self.db.commit()
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': []},
{'uid': node3.id, 'networks': nets_sent}]}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "error")
self.assertEqual(task.message, '')
error_nodes = [{'uid': node2.id, 'interface': 'eth0',
'name': node2.name, 'mac': node2.interfaces[0].mac,
'absent_vlans': nets_sent[0]['vlans']},
{'uid': node2.id, 'interface': 'eth1',
'name': node2.name, 'mac': 'unknown',
'absent_vlans': nets_sent[1]['vlans']},
{'uid': node2.id, 'interface': 'eth2',
'name': node2.name, 'mac': 'unknown',
'absent_vlans': nets_sent[2]['vlans']}
]
self.assertEqual(task.result, error_nodes)
def test_verify_networks_resp_error(self):
self.env.create(cluster_kwargs={},
nodes_kwargs=[{
"api": False
}, {
"api": False
}])
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
nets_resp = [{'iface': 'eth0', 'vlans': range(100, 104)}]
task = Task(name="super", cluster_id=cluster_db.id)
task.cache = {
"args": {
'nodes': [{
'uid': node1.id,
'networks': nets_sent
}, {
'uid': node2.id,
'networks': nets_sent
}]
}
}
self.db.add(task)
self.db.commit()
kwargs = {
'task_uuid':
task.uuid,
'status':
'ready',
'nodes': [{
'uid': node1.id,
'networks': nets_resp
}, {
'uid': node2.id,
'networks': nets_resp
}]
}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "error")
error_nodes = []
for node in self.env.nodes:
error_nodes.append({
'uid': node.id,
'interface': 'eth0',
'name': node.name,
'absent_vlans': [104],
'mac': node.interfaces[0].mac
})
self.assertEqual(task.message, None)
self.assertEqual(task.result, error_nodes)
def test_verify_networks_resp_forgotten_node_error(self):
self.env.create(cluster_kwargs={},
nodes_kwargs=[{
"api": False,
'name': 'node1'
}, {
"api": False,
'name': 'node2'
}, {
"api": False,
'name': 'node3'
}])
cluster_db = self.env.clusters[0]
node1, node2, node3 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
task = Task(name="super", cluster_id=cluster_db.id)
task.cache = {
"args": {
'nodes': [{
'uid': node1.id,
'networks': nets_sent
}, {
'uid': node2.id,
'networks': nets_sent
}, {
'uid': node3.id,
'networks': nets_sent
}]
}
}
self.db.add(task)
self.db.commit()
kwargs = {
'task_uuid':
task.uuid,
'status':
'ready',
'nodes': [{
'uid': node1.id,
'networks': nets_sent
}, {
'uid': node2.id,
'networks': nets_sent
}]
}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "error")
self.assertRegexpMatches(task.message, node3.name)
self.assertEqual(task.result, [])
def test_verify_networks_resp_error_with_removed_node(self):
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
nets_resp = [{'iface': 'eth0', 'vlans': range(100, 104)}]
task = Task(
name="super",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent}]
}
}
self.db.add(task)
self.db.commit()
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': [{'uid': node1.id, 'networks': nets_resp},
{'uid': node2.id, 'networks': nets_resp}]}
self.db.delete(node2)
self.db.commit()
self.receiver.verify_networks_resp(**kwargs)
resp = self.app.get(
reverse('TaskHandler', kwargs={'task_id': task.id}),
headers=self.default_headers
)
self.assertEquals(resp.status, 200)
task = json.loads(resp.body)
self.assertEqual(task['status'], "error")
error_nodes = [{'uid': node1.id, 'interface': 'eth0',
'name': node1.name, 'absent_vlans': [104],
'mac': node1.mac},
{'uid': node2.id, 'interface': 'eth0',
'absent_vlans': [104]}]
self.assertEqual(task.get('message'), None)
self.assertEqual(task['result'], error_nodes)
def test_verify_networks_with_dhcp_subtask_erred(self):
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
task = Task(
name="verify_networks",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent}]
}
}
self.db.add(task)
self.db.commit()
dhcp_subtask = Task(
name='check_dhcp',
cluster_id=cluster_db.id,
parent_id=task.id,
status='error',
message='DHCP ERROR'
)
self.db.add(dhcp_subtask)
self.db.commit()
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': []}]}
self.receiver.verify_networks_resp(**kwargs)
self.assertEqual(task.status, "error")
self.assertEqual(task.message, u'DHCP ERROR')
self.assertEqual(task.result, [{
u'absent_vlans': [100, 101, 102, 103, 104],
u'interface': 'eth0',
u'mac': node2.interfaces[0].mac,
u'name': None,
u'uid': node2.id}])
def test_verify_networks_resp_without_vlans_only_erred(self):
"""Verify that network verification without vlans fails
when not all sended info received
"""
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': [0]}]
nets_resp = [{'iface': 'eth0', 'vlans': []}]
task = Task(
name="super",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent}]
}
}
self.db.add(task)
self.db.commit()
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': [{'uid': node1.id, 'networks': nets_resp},
{'uid': node2.id, 'networks': nets_resp}]}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "error")
error_nodes = [{'uid': node1.id, 'interface': 'eth0',
'name': node1.name, 'mac': node1.interfaces[0].mac,
'absent_vlans': nets_sent[0]['vlans']},
{'uid': node2.id, 'interface': 'eth0',
'name': node2.name, 'mac': node2.interfaces[0].mac,
'absent_vlans': nets_sent[0]['vlans']}]
self.assertEqual(task.result, error_nodes)
def test_verify_networks_resp_incomplete_network_data_on_first_node(self):
"""Test verifies that when network data is incomplete on first node
task would not fail and be erred as expected
"""
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False, 'name': 'node1'},
{"api": False, 'name': 'node2'},
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
task = Task(
name="super",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent}]
}
}
self.db.add(task)
self.db.commit()
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': [{'uid': node1.id, 'networks': []},
{'uid': node2.id, 'networks': nets_sent}]}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "error")
self.assertEqual(task.message, '')
error_nodes = [{'uid': node1.id, 'interface': 'eth0',
'name': node1.name, 'mac': node1.interfaces[0].mac,
'absent_vlans': nets_sent[0]['vlans']}]
self.assertEqual(task.result, error_nodes)
def test_verify_networks_resp_incomplete_network_data_on_first_node(self):
"""Test verifies that when network data is incomplete on first node
task would not fail and be erred as expected
"""
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False, 'name': 'node1'},
{"api": False, 'name': 'node2'},
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
task = Task(
name="super",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent}]
}
}
self.db.add(task)
self.db.commit()
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': [{'uid': node1.id, 'networks': []},
{'uid': node2.id, 'networks': nets_sent}]}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "error")
self.assertEqual(task.message, None)
error_nodes = [{'uid': node1.id, 'interface': 'eth0',
'name': node1.name, 'mac': node1.interfaces[0].mac,
'absent_vlans': nets_sent[0]['vlans']}]
self.assertEqual(task.result, error_nodes)
def test_verify_networks_with_dhcp_subtask(self):
"""Test verifies that when dhcp subtask is ready and
verify_networks errored - verify_networks will be in error
"""
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
task = Task(
name="verify_networks",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent}]
}
}
self.db.add(task)
self.db.commit()
dhcp_subtask = Task(
name='check_dhcp',
cluster_id=cluster_db.id,
parent_id=task.id,
status='ready'
)
self.db.add(dhcp_subtask)
self.db.commit()
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': []}]}
self.receiver.verify_networks_resp(**kwargs)
self.assertEqual(task.status, "error")
def test_verify_networks_resp_error(self):
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
nets_resp = [{'iface': 'eth0', 'vlans': range(100, 104)}]
task = Task(
name="super",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent}]
}
}
self.db.add(task)
self.db.commit()
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': [{'uid': node1.id, 'networks': nets_resp},
{'uid': node2.id, 'networks': nets_resp}]}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "error")
error_nodes = []
for node in self.env.nodes:
error_nodes.append({'uid': node.id, 'interface': 'eth0',
'name': node.name, 'absent_vlans': [104],
'mac': node.mac})
self.assertEqual(task.message, None)
self.assertEqual(task.result, error_nodes)
def execute(self, nodes_to_provision):
"""Run provisioning task on specified nodes
Constraints: currently this task cannot deploy RedHat.
For redhat here should be added additional
tasks e.i. check credentials, check licenses,
redhat downloading.
Status of this task you can track here:
https://blueprints.launchpad.net/fuel/+spec
/nailgun-separate-provisioning-for-redhat
"""
TaskHelper.update_slave_nodes_fqdn(nodes_to_provision)
logger.debug('Nodes to provision: {0}'.format(
' '.join([n.fqdn for n in nodes_to_provision])))
task_provision = Task(name='provision', cluster=self.cluster)
db().add(task_provision)
db().commit()
provision_message = self._call_silently(
task_provision,
tasks.ProvisionTask,
nodes_to_provision,
method_name='message'
)
db().refresh(task_provision)
task_provision.cache = provision_message
for node in nodes_to_provision:
node.pending_addition = False
node.status = 'provisioning'
node.progress = 0
db().commit()
rpc.cast('naily', provision_message)
return task_provision
def test_verify_networks_resp_forgotten_node_error(self):
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False, 'name': 'node1'},
{"api": False, 'name': 'node2'},
{"api": False, 'name': 'node3'}
]
)
cluster_db = self.env.clusters[0]
node1, node2, node3 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
task = Task(
name="super",
cluster_id=cluster_db.id
)
task.cache = {
"args": {
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent},
{'uid': node3.id, 'networks': nets_sent}]
}
}
self.db.add(task)
self.db.commit()
kwargs = {'task_uuid': task.uuid,
'status': 'ready',
'nodes': [{'uid': node1.id, 'networks': nets_sent},
{'uid': node2.id, 'networks': nets_sent}]}
self.receiver.verify_networks_resp(**kwargs)
self.db.refresh(task)
self.assertEqual(task.status, "error")
self.assertRegexpMatches(task.message, node3.name)
self.assertEqual(task.result, [])
