def test_redeploy_with_critial_roles(self):
cluster = self.create_env([{
'roles': ['controller'],
'status': 'error'
}, {
'roles': ['controller'],
'status': 'provisioned'
}, {
'roles': ['controller'],
'status': 'provisioned'
}, {
'roles': ['compute', 'cinder'],
'status': 'provisioned'
}, {
'roles': ['compute'],
'status': 'provisioned'
}, {
'roles': ['cinder'],
'status': 'provisioned'
}])
nodes = TaskHelper.nodes_to_deploy(cluster)
self.assertEqual(len(nodes), 6)
controllers = self.filter_by_role(nodes, 'controller')
self.assertEqual(len(controllers), 3)
cinders = self.filter_by_role(nodes, 'cinder')
self.assertEqual(len(cinders), 2)
computes = self.filter_by_role(nodes, 'compute')
self.assertEqual(len(computes), 2)
def test_deploy_grow_controllers(self):
cluster = self.create_env(
nodes_kwargs=[
{"roles": ["controller"]},
{"roles": ["controller"], "pending_addition": True},
{"roles": ["controller"], "pending_addition": True},
]
)
# We have to build 2 new controllers
n_nodes = TaskHelper.nodes_to_provision(cluster)
self.assertEqual(len(n_nodes), 2)
# All controllers must re-deploy (run puppet)
r_nodes = TaskHelper.nodes_to_deploy(cluster)
self.assertEqual(len(r_nodes), 3)
supertask = self.env.launch_deployment()
self.assertEqual(supertask.name, "deploy")
self.env.wait_ready(supertask)
self.assertEqual(supertask.status, "ready")
controllers = self.filter_by_role(cluster.nodes, "controller")
self.assertEqual(len(controllers), 3)
def message(cls, task):
logger.debug("DeploymentTask.message(task=%s)" % task.uuid)
task.cluster.prepare_for_deployment()
nodes = TaskHelper.nodes_to_deploy(task.cluster)
nodes_ids = [n.id for n in nodes]
for n in db().query(Node).filter_by(
cluster=task.cluster).order_by(Node.id):
# However, we must not pass nodes which are set to be deleted.
if n.pending_deletion:
continue
if n.id in nodes_ids: # It's node which we need to redeploy
n.pending_addition = False
if n.pending_roles:
n.roles += n.pending_roles
n.pending_roles = []
if n.status in ('deploying'):
n.status = 'provisioned'
n.progress = 0
db().add(n)
db().commit()
# here we replace provisioning data if user redefined them
serialized_cluster = task.cluster.replaced_deployment_info or \
deployment_serializers.serialize(task.cluster)
return {
'method': 'deploy',
'respond_to': 'deploy_resp',
'args': {
'task_uuid': task.uuid,
'deployment_info': serialized_cluster}}
def test_redeploy_all_controller_and_compute_cinder(self):
cluster = self.create_env([{
'roles': ['controller'],
'status': 'error'
}, {
'roles': ['controller']
}, {
'roles': ['controller', 'cinder']
}, {
'roles': ['compute', 'cinder']
}, {
'roles': ['compute'],
'status': 'error'
}, {
'roles': ['cinder'],
'status': 'error'
}])
nodes = TaskHelper.nodes_to_deploy(cluster)
self.assertEquals(len(nodes), 5)
controllers = self.filter_by_role(nodes, 'controller')
self.assertEquals(len(controllers), 3)
cinders = self.filter_by_role(nodes, 'cinder')
self.assertEquals(len(cinders), 2)
computes = self.filter_by_role(nodes, 'compute')
self.assertEquals(len(computes), 1)
def test_deploy_grow_controllers(self):
cluster = self.create_env(nodes_kwargs=[{
'roles': ['controller']
}, {
'roles': ['controller'],
'pending_addition': True
}, {
'roles': ['controller'],
'pending_addition': True
}])
# We have to build 2 new controllers
n_nodes = TaskHelper.nodes_to_provision(cluster)
self.assertEqual(len(n_nodes), 2)
# All controllers must re-deploy (run puppet)
r_nodes = TaskHelper.nodes_to_deploy(cluster)
self.assertEqual(len(r_nodes), 3)
supertask = self.env.launch_deployment()
self.assertEqual(supertask.name, 'deploy')
self.env.wait_ready(supertask)
self.assertEqual(supertask.status, 'ready')
controllers = self.filter_by_role(cluster.nodes, 'controller')
self.assertEqual(len(controllers), 3)
def test_redeploy_with_stopped_nodes(self):
cluster = self.create_env([{
'roles': ['controller'],
'status': 'error'
}, {
'roles': ['controller'],
'status': 'stopped'
}, {
'roles': ['controller'],
'status': 'stopped'
}, {
'roles': ['compute', 'cinder'],
'status': 'stopped'
}, {
'roles': ['compute'],
'status': 'error',
'error_type': 'stop_deployment'
}, {
'roles': ['cinder'],
'status': 'error',
'error_type': 'deploy'
}])
nodes = TaskHelper.nodes_to_deploy(cluster)
self.assertEqual(len(nodes), 6)
controllers = self.filter_by_role(nodes, 'controller')
self.assertEqual(len(controllers), 3)
cinders = self.filter_by_role(nodes, 'cinder')
self.assertEqual(len(cinders), 2)
computes = self.filter_by_role(nodes, 'compute')
self.assertEqual(len(computes), 2)
def message(cls, task):
logger.debug("DeploymentTask.message(task=%s)" % task.uuid)
task.cluster.prepare_for_deployment()
nodes = TaskHelper.nodes_to_deploy(task.cluster)
nodes_ids = [n.id for n in nodes]
for n in db().query(Node).filter_by(cluster=task.cluster).order_by(
Node.id):
# However, we must not pass nodes which are set to be deleted.
if n.pending_deletion:
continue
if n.id in nodes_ids: # It's node which we need to redeploy
n.pending_addition = False
if n.pending_roles:
n.roles += n.pending_roles
n.pending_roles = []
if n.status in ('deploying'):
n.status = 'provisioned'
n.progress = 0
db().add(n)
db().commit()
# here we replace provisioning data if user redefined them
serialized_cluster = task.cluster.replaced_deployment_info or \
deployment_serializers.serialize(task.cluster)
return {
'method': 'deploy',
'respond_to': 'deploy_resp',
'args': {
'task_uuid': task.uuid,
'deployment_info': serialized_cluster
}
}
def test_nodes_to_deploy_if_lcm(self):
cluster = self.env.create(nodes_kwargs=[
{
'status': consts.NODE_STATUSES.ready
},
{
'status': consts.NODE_STATUSES.discover
},
{
'status': consts.NODE_STATUSES.provisioning
},
{
'status': consts.NODE_STATUSES.provisioned
},
{
'status': consts.NODE_STATUSES.deploying
},
{
'status': consts.NODE_STATUSES.error,
'error_type': consts.NODE_ERRORS.deploy
},
{
'status': consts.NODE_STATUSES.error,
'error_type': consts.NODE_ERRORS.provision
},
{
'status': consts.NODE_STATUSES.stopped
},
{
'status': consts.NODE_STATUSES.removing
},
{
'status': consts.NODE_STATUSES.ready,
'pending_deletion': True
},
],
release_kwargs={
'version': 'mitaka-9.0',
'operating_system':
consts.RELEASE_OS.ubuntu
})
nodes_to_deploy = TaskHelper.nodes_to_deploy(cluster)
self.assertEqual(5, len(nodes_to_deploy))
expected_status = [
consts.NODE_STATUSES.provisioned, consts.NODE_STATUSES.stopped,
consts.NODE_STATUSES.ready, consts.NODE_STATUSES.error,
consts.NODE_STATUSES.deploying
]
for node in nodes_to_deploy:
self.assertIn(node.status, expected_status)
self.assertIn(node.error_type, [None, consts.NODE_ERRORS.deploy])
self.assertFalse(node.pending_deletion)
def test_redeploy_all_controller_if_single_controller_failed(self):
cluster = self.create_env([
{'roles': ['controller'], 'status': 'error'},
{'roles': ['controller']},
{'roles': ['controller', 'cinder']},
{'roles': ['compute', 'cinder']},
{'roles': ['compute']},
{'roles': ['cinder']}])
nodes = TaskHelper.nodes_to_deploy(cluster)
self.assertEquals(len(nodes), 3)
controllers = self.filter_by_role(nodes, 'controller')
self.assertEquals(len(controllers), 3)
def prepare_for_deployment(self):
from nailgun.network.manager import NetworkManager
from nailgun.task.helpers import TaskHelper
nodes = set(TaskHelper.nodes_to_deploy(self) +
TaskHelper.nodes_in_provisioning(self))
TaskHelper.update_slave_nodes_fqdn(nodes)
nodes_ids = sorted([n.id for n in nodes])
netmanager = NetworkManager()
if nodes_ids:
netmanager.assign_ips(nodes_ids, 'management')
netmanager.assign_ips(nodes_ids, 'public')
netmanager.assign_ips(nodes_ids, 'storage')
def prepare_for_deployment(self):
from nailgun.network.manager import NetworkManager
from nailgun.task.helpers import TaskHelper
nodes = set(TaskHelper.nodes_to_deploy(self) +
TaskHelper.nodes_in_provisioning(self))
TaskHelper.update_slave_nodes_fqdn(nodes)
nodes_ids = sorted([n.id for n in nodes])
netmanager = NetworkManager()
if nodes_ids:
netmanager.assign_ips(nodes_ids, 'management')
netmanager.assign_ips(nodes_ids, 'public')
netmanager.assign_ips(nodes_ids, 'storage')
def test_redeploy_only_compute_cinder(self):
cluster = self.create_env([
{'roles': ['controller']},
{'roles': ['controller']},
{'roles': ['controller', 'cinder']},
{'roles': ['compute', 'cinder']},
{'roles': ['compute'], 'status': 'error'},
{'roles': ['cinder'], 'status': 'error'}])
nodes = TaskHelper.nodes_to_deploy(cluster)
self.assertEquals(len(nodes), 2)
cinders = self.filter_by_role(nodes, 'cinder')
self.assertEquals(len(cinders), 1)
computes = self.filter_by_role(nodes, 'compute')
self.assertEquals(len(computes), 1)
def prepare_for_deployment(self):
from nailgun.network.manager import NetworkManager
from nailgun.task.helpers import TaskHelper
nodes = sorted(
set(TaskHelper.nodes_to_deploy(self) + TaskHelper.nodes_in_provisioning(self)), key=lambda node: node.id
)
TaskHelper.update_slave_nodes_fqdn(nodes)
nodes_ids = [n.id for n in nodes]
netmanager = NetworkManager()
if nodes_ids:
netmanager.assign_ips(nodes_ids, "management")
netmanager.assign_ips(nodes_ids, "public")
netmanager.assign_ips(nodes_ids, "storage")
for node in nodes:
netmanager.assign_admin_ips(node.id, len(node.meta.get("interfaces", [])))
def test_redeploy_with_critial_roles(self):
cluster = self.create_env([
{'roles': ['controller'], 'status': 'error'},
{'roles': ['controller'], 'status': 'provisioned'},
{'roles': ['controller'], 'status': 'provisioned'},
{'roles': ['compute', 'cinder'], 'status': 'provisioned'},
{'roles': ['compute'], 'status': 'provisioned'},
{'roles': ['cinder'], 'status': 'provisioned'}])
nodes = TaskHelper.nodes_to_deploy(cluster)
self.assertEqual(len(nodes), 6)
controllers = self.filter_by_role(nodes, 'controller')
self.assertEqual(len(controllers), 3)
cinders = self.filter_by_role(nodes, 'cinder')
self.assertEqual(len(cinders), 2)
computes = self.filter_by_role(nodes, 'compute')
self.assertEqual(len(computes), 2)
def _check_nodes_are_online(cls, task):
offline_nodes = db().query(Node).\
filter(Node.cluster == task.cluster).\
filter_by(online=False).\
filter_by(pending_deletion=False)
offline_nodes_not_ready = [n for n in offline_nodes
if n.status != consts.NODE_STATUSES.ready]
nodes_to_deploy = TaskHelper.nodes_to_deploy(task.cluster)
offline_nodes_to_redeploy = [
n for n in offline_nodes
if n.status == consts.NODE_STATUSES.ready and n in nodes_to_deploy]
if offline_nodes_not_ready or offline_nodes_to_redeploy:
node_names = ','.join(
map(lambda n: n.full_name,
offline_nodes_not_ready + offline_nodes_to_redeploy))
raise errors.NodeOffline(
u'Nodes "{0}" are offline.'
' Remove them from environment '
'and try again.'.format(node_names))
def prepare_for_deployment(self):
from nailgun.network.manager import NetworkManager
from nailgun.task.helpers import TaskHelper
nodes = sorted(set(
TaskHelper.nodes_to_deploy(self) +
TaskHelper.nodes_in_provisioning(self)),
key=lambda node: node.id)
TaskHelper.update_slave_nodes_fqdn(nodes)
nodes_ids = [n.id for n in nodes]
netmanager = NetworkManager()
if nodes_ids:
netmanager.assign_ips(nodes_ids, 'management')
netmanager.assign_ips(nodes_ids, 'public')
netmanager.assign_ips(nodes_ids, 'storage')
for node in nodes:
netmanager.assign_admin_ips(
node.id, len(node.meta.get('interfaces', [])))
def _check_nodes_are_online(cls, task):
offline_nodes = db().query(Node).\
filter(Node.cluster == task.cluster).\
filter_by(online=False).\
filter_by(pending_deletion=False)
offline_nodes_not_ready = [n for n in offline_nodes
if n.status != consts.NODE_STATUSES.ready]
nodes_to_deploy = TaskHelper.nodes_to_deploy(task.cluster)
offline_nodes_to_redeploy = [
n for n in offline_nodes
if n.status == consts.NODE_STATUSES.ready and n in nodes_to_deploy]
if offline_nodes_not_ready or offline_nodes_to_redeploy:
node_names = ','.join(
map(lambda n: n.full_name,
offline_nodes_not_ready + offline_nodes_to_redeploy))
raise errors.NodeOffline(
u'Nodes "{0}" are offline.'
' Remove them from environment '
'and try again.'.format(node_names))
def test_deploy_grow_controllers(self):
cluster = self.create_env(
nodes_kwargs=[
{'roles': ['controller']},
{'roles': ['controller'], 'pending_addition': True},
{'roles': ['controller'], 'pending_addition': True}])
# We have to build 2 new controllers
n_nodes = TaskHelper.nodes_to_provision(cluster)
self.assertEqual(len(n_nodes), 2)
# All controllers must re-deploy
r_nodes = TaskHelper.nodes_to_deploy(cluster)
self.assertEqual(len(r_nodes), 3)
supertask = self.env.launch_deployment()
self.assertEqual(supertask.name, consts.TASK_NAMES.deploy)
self.assertNotEqual(supertask.status, consts.TASK_STATUSES.error)
controllers = self.filter_by_role(cluster.nodes, 'controller')
self.assertEqual(len(controllers), 3)
def test_redeploy_with_stopped_nodes(self):
cluster = self.create_env([
{'roles': ['controller'], 'status': 'error'},
{'roles': ['controller'], 'status': 'stopped'},
{'roles': ['controller'], 'status': 'stopped'},
{'roles': ['compute', 'cinder'], 'status': 'stopped'},
{'roles': ['compute'], 'status': 'error',
'error_type': 'stop_deployment'},
{'roles': ['cinder'], 'status': 'error',
'error_type': 'deploy'}])
nodes = TaskHelper.nodes_to_deploy(cluster)
self.assertEqual(len(nodes), 6)
controllers = self.filter_by_role(nodes, 'controller')
self.assertEqual(len(controllers), 3)
cinders = self.filter_by_role(nodes, 'cinder')
self.assertEqual(len(cinders), 2)
computes = self.filter_by_role(nodes, 'compute')
self.assertEqual(len(computes), 2)
def message(cls, task):
logger.debug("DeploymentTask.message(task=%s)" % task.uuid)
task.cluster.prepare_for_deployment()
nodes = TaskHelper.nodes_to_deploy(task.cluster)
nodes_ids = [n.id for n in nodes]
for n in db().query(Node).filter_by(cluster=task.cluster).order_by(Node.id):
# However, we must not pass nodes which are set to be deleted.
if n.pending_deletion:
continue
if n.id in nodes_ids:
if n.pending_roles:
n.roles += n.pending_roles
n.pending_roles = []
# If reciever for some reasons didn't update
# node's status to provisioned when deployment
# started, we should do it in nailgun
if n.status in ("deploying"):
n.status = "provisioned"
n.progress = 0
db().add(n)
db().commit()
# here we replace provisioning data if user redefined them
serialized_cluster = task.cluster.replaced_deployment_info or deployment_serializers.serialize(task.cluster)
# After searilization set pending_addition to False
for node in db().query(Node).filter(Node.id.in_(nodes_ids)):
node.pending_addition = False
db().commit()
return {
"method": "deploy",
"respond_to": "deploy_resp",
"args": {"task_uuid": task.uuid, "deployment_info": serialized_cluster},
}
def test_deploy_grow_controllers(self):
cluster = self.create_env(
nodes_kwargs=[
{'roles': ['controller']},
{'roles': ['controller'], 'pending_addition': True},
{'roles': ['controller'], 'pending_addition': True}])
# We have to build 2 new controllers
n_nodes = TaskHelper.nodes_to_provision(cluster)
self.assertEquals(len(n_nodes), 2)
# All controllers must re-deploy (run puppet)
r_nodes = TaskHelper.nodes_to_deploy(cluster)
self.assertEquals(len(r_nodes), 3)
supertask = self.env.launch_deployment()
self.assertEquals(supertask.name, 'deploy')
self.env.wait_ready(supertask)
self.assertEquals(supertask.status, 'ready')
controllers = self.filter_by_role(cluster.nodes, 'controller')
self.assertEquals(len(controllers), 3)
def message(cls, task):
logger.debug("DeploymentTask.message(task=%s)" % task.uuid)
task.cluster.prepare_for_deployment()
nodes = TaskHelper.nodes_to_deploy(task.cluster)
nodes_ids = [n.id for n in nodes]
for n in db().query(Node).filter_by(
cluster=task.cluster).order_by(Node.id):
# However, we must not pass nodes which are set to be deleted.
if n.pending_deletion:
continue
if n.id in nodes_ids: # It's node which we need to redeploy
n.pending_addition = False
if n.pending_roles:
n.roles += n.pending_roles
n.pending_roles = []
if n.status in ('deploying'):
n.status = 'provisioned'
n.progress = 0
db().add(n)
db().commit()
message = {
'method': 'deploy',
'respond_to': 'deploy_resp',
'args': {
'task_uuid': task.uuid,
# if task.cluster.facts not empty dict, it will be used
# instead of computing cluster facts through serialize
'deployment_info': task.cluster.facts
or serialize(task.cluster)
}
}
return message
def test_nodes_to_deploy_if_lcm(self):
cluster = self.env.create(
nodes_kwargs=[
{'status': consts.NODE_STATUSES.ready},
{'status': consts.NODE_STATUSES.discover},
{'status': consts.NODE_STATUSES.provisioning},
{'status': consts.NODE_STATUSES.provisioned},
{'status': consts.NODE_STATUSES.deploying},
{'status': consts.NODE_STATUSES.error,
'error_type': consts.NODE_ERRORS.deploy},
{'status': consts.NODE_STATUSES.error,
'error_type': consts.NODE_ERRORS.provision},
{'status': consts.NODE_STATUSES.stopped},
{'status': consts.NODE_STATUSES.removing},
{'status': consts.NODE_STATUSES.ready,
'pending_deletion': True},
],
release_kwargs={
'version': 'mitaka-9.0',
'operating_system': consts.RELEASE_OS.ubuntu
}
)
nodes_to_deploy = TaskHelper.nodes_to_deploy(cluster)
self.assertEqual(5, len(nodes_to_deploy))
expected_status = [
consts.NODE_STATUSES.provisioned,
consts.NODE_STATUSES.stopped,
consts.NODE_STATUSES.ready,
consts.NODE_STATUSES.error,
consts.NODE_STATUSES.deploying
]
for node in nodes_to_deploy:
self.assertIn(node.status, expected_status)
self.assertIn(node.error_type, [None, consts.NODE_ERRORS.deploy])
self.assertFalse(node.pending_deletion)
def message(cls, task):
logger.debug("DeploymentTask.message(task=%s)" % task.uuid)
task_uuid = task.uuid
cluster_id = task.cluster.id
netmanager = NetworkManager()
nodes = TaskHelper.nodes_to_deploy(task.cluster)
logger.info("Associated FQDNs to nodes: %s" %
', '.join([n.fqdn for n in nodes]))
nodes_ids = [n.id for n in nodes]
if nodes_ids:
logger.info("Assigning IP addresses to nodes..")
netmanager.assign_ips(nodes_ids, "management")
netmanager.assign_ips(nodes_ids, "public")
netmanager.assign_ips(nodes_ids, "storage")
nodes_with_attrs = []
for n in nodes:
n.pending_addition = False
if n.status in ('ready', 'deploying'):
n.status = 'provisioned'
n.progress = 0
orm().add(n)
orm().commit()
nodes_with_attrs.append(cls.__format_node_for_naily(n))
cluster_attrs = task.cluster.attributes.merged_attrs_values()
cluster_attrs['controller_nodes'] = cls.__controller_nodes(cluster_id)
nets_db = orm().query(Network).join(NetworkGroup).\
filter(NetworkGroup.cluster_id == cluster_id).all()
ng_db = orm().query(NetworkGroup).filter_by(
cluster_id=cluster_id).all()
for net in ng_db:
net_name = net.name + '_network_range'
if net.name == 'floating':
cluster_attrs[net_name] = \
cls.__get_ip_addresses_in_ranges(net)
elif net.name == 'public':
# We shouldn't pass public_network_range attribute
continue
else:
cluster_attrs[net_name] = net.cidr
cluster_attrs['network_manager'] = task.cluster.net_manager
fixed_net = orm().query(NetworkGroup).filter_by(
cluster_id=cluster_id).filter_by(name='fixed').first()
# network_size is required for all managers, otherwise
# puppet will use default (255)
cluster_attrs['network_size'] = fixed_net.network_size
if cluster_attrs['network_manager'] == 'VlanManager':
cluster_attrs['num_networks'] = fixed_net.amount
cluster_attrs['vlan_start'] = fixed_net.vlan_start
cls.__add_vlan_interfaces(nodes_with_attrs)
if task.cluster.mode == 'ha':
logger.info("HA mode chosen, creating VIP addresses for it..")
cluster_attrs['management_vip'] = netmanager.assign_vip(
cluster_id, "management")
cluster_attrs['public_vip'] = netmanager.assign_vip(
cluster_id, "public")
cluster_attrs['deployment_mode'] = task.cluster.mode
cluster_attrs['deployment_id'] = cluster_id
message = {
'method': 'deploy',
'respond_to': 'deploy_resp',
'args': {
'task_uuid': task.uuid,
'nodes': nodes_with_attrs,
'attributes': cluster_attrs
}
}
return message
def test_related_pending_deletion_nodes_not_present(self):
cluster = self.cluster
controllers = [n for n in cluster.nodes if 'controller' in n.all_roles]
nodes_to_deploy = TaskHelper.nodes_to_deploy(cluster)
self.assertItemsEqual(controllers, nodes_to_deploy)
def message(cls, task):
logger.debug("DeploymentTask.message(task=%s)" % task.uuid)
task_uuid = task.uuid
cluster_id = task.cluster.id
netmanager = NetworkManager()
nodes = TaskHelper.nodes_to_deploy(task.cluster)
logger.info("Associated FQDNs to nodes: %s" %
', '.join([n.fqdn for n in nodes]))
nodes_ids = [n.id for n in nodes]
if nodes_ids:
logger.info("Assigning IP addresses to nodes..")
netmanager.assign_ips(nodes_ids, "management")
netmanager.assign_ips(nodes_ids, "public")
netmanager.assign_ips(nodes_ids, "storage")
nodes_with_attrs = []
# FIXME(mihgen): We need to pass all other nodes, so astute
# can know about all the env, not only about added nodes.
for n in db().query(Node).filter_by(cluster=task.cluster).order_by(
Node.id):
# However, we must not pass nodes which are set to be deleted.
if n.pending_deletion:
continue
if n.id in nodes_ids: # It's node which we need to redeploy
n.pending_addition = False
if n.status in ('deploying'):
n.status = 'provisioned'
n.progress = 0
db().add(n)
db().commit()
nodes_with_attrs.append(cls.__format_node_for_naily(n))
cluster_attrs = task.cluster.attributes.merged_attrs_values()
cluster_attrs['master_ip'] = settings.MASTER_IP
cluster_attrs['controller_nodes'] = cls.__controller_nodes(cluster_id)
nets_db = db().query(Network).join(NetworkGroup).\
filter(NetworkGroup.cluster_id == cluster_id).all()
ng_db = db().query(NetworkGroup).filter_by(cluster_id=cluster_id).all()
for net in ng_db:
net_name = net.name + '_network_range'
if net.name == 'floating':
cluster_attrs[net_name] = \
cls.__get_ip_ranges_first_last(net)
elif net.name == 'public':
# We shouldn't pass public_network_range attribute
continue
else:
cluster_attrs[net_name] = net.cidr
net_params = {}
net_params['network_manager'] = task.cluster.net_manager
fixed_net = db().query(NetworkGroup).filter_by(
cluster_id=cluster_id).filter_by(name='fixed').first()
# network_size is required for all managers, otherwise
# puppet will use default (255)
net_params['network_size'] = fixed_net.network_size
if net_params['network_manager'] == 'VlanManager':
net_params['num_networks'] = fixed_net.amount
net_params['vlan_start'] = fixed_net.vlan_start
cls.__add_vlan_interfaces(nodes_with_attrs)
cluster_attrs['novanetwork_parameters'] = net_params
if task.cluster.mode == 'ha':
logger.info("HA mode chosen, creating VIP addresses for it..")
cluster_attrs['management_vip'] = netmanager.assign_vip(
cluster_id, "management")
cluster_attrs['public_vip'] = netmanager.assign_vip(
cluster_id, "public")
cluster_attrs['deployment_mode'] = task.cluster.mode
cluster_attrs['deployment_id'] = cluster_id
message = {
'method': 'deploy',
'respond_to': 'deploy_resp',
'args': {
'task_uuid': task.uuid,
'nodes': nodes_with_attrs,
'attributes': cluster_attrs
}
}
return message
def get_default_nodes(self, cluster):
TaskHelper.nodes_to_deploy(cluster)
def get_default_nodes(self, cluster):
if objects.Release.is_lcm_supported(cluster.release):
return objects.Cluster.get_nodes_not_for_deletion(cluster).all()
return TaskHelper.nodes_to_deploy(cluster)
def test_related_pending_deletion_nodes_not_present_with_force(self):
cluster = self.env.clusters[0]
controllers = [n for n in cluster.nodes if 'controller' in n.all_roles]
nodes_to_deploy = TaskHelper.nodes_to_deploy(cluster, force=True)
self.assertItemsEqual(controllers, nodes_to_deploy)
def get_nodes_to_deployment(cls, cluster):
"""Nodes which need to deploy."""
return sorted(TaskHelper.nodes_to_deploy(cluster),
key=lambda node: node.id)
def message(cls, task):
logger.debug("DeploymentTask.message(task=%s)" % task.uuid)
task_uuid = task.uuid
cluster_id = task.cluster.id
netmanager = NetworkManager()
nodes = TaskHelper.nodes_to_deploy(task.cluster)
logger.info("Associated FQDNs to nodes: %s" %
', '.join([n.fqdn for n in nodes]))
nodes_ids = [n.id for n in nodes]
if nodes_ids:
logger.info("Assigning IP addresses to nodes..")
netmanager.assign_ips(nodes_ids, "management")
netmanager.assign_ips(nodes_ids, "public")
netmanager.assign_ips(nodes_ids, "storage")
nodes_with_attrs = []
for n in nodes:
n.pending_addition = False
if n.status in ('ready', 'deploying'):
n.status = 'provisioned'
n.progress = 0
orm().add(n)
orm().commit()
nodes_with_attrs.append(cls.__format_node_for_naily(n))
cluster_attrs = task.cluster.attributes.merged_attrs_values()
cluster_attrs['controller_nodes'] = cls.__controller_nodes(cluster_id)
nets_db = orm().query(Network).join(NetworkGroup).\
filter(NetworkGroup.cluster_id == cluster_id).all()
ng_db = orm().query(NetworkGroup).filter_by(
cluster_id=cluster_id).all()
for net in ng_db:
cluster_attrs[net.name + '_network_range'] = net.cidr
cluster_attrs['network_manager'] = task.cluster.net_manager
if cluster_attrs['network_manager'] == 'VlanManager':
fixed_net = orm().query(NetworkGroup).filter_by(
cluster_id=cluster_id).filter_by(name='fixed').first()
cluster_attrs['network_size'] = fixed_net.network_size
cluster_attrs['num_networks'] = fixed_net.amount
cluster_attrs['vlan_start'] = fixed_net.vlan_start
cls.__add_vlan_interfaces(nodes_with_attrs)
if task.cluster.mode == 'ha':
logger.info("HA mode chosen, creating VIP addresses for it..")
cluster_attrs['management_vip'] = netmanager.assign_vip(
cluster_id, "management")
cluster_attrs['public_vip'] = netmanager.assign_vip(
cluster_id, "public")
cluster_attrs['deployment_mode'] = task.cluster.mode
cluster_attrs['deployment_id'] = cluster_id
message = {
'method': 'deploy',
'respond_to': 'deploy_resp',
'args': {
'task_uuid': task.uuid,
'nodes': nodes_with_attrs,
'attributes': cluster_attrs
}
}
return message
def message(cls, task):
logger.debug("DeploymentTask.message(task=%s)" % task.uuid)
task_uuid = task.uuid
cluster_id = task.cluster.id
netmanager = NetworkManager()
nodes = TaskHelper.nodes_to_deploy(task.cluster)
logger.info("Associated FQDNs to nodes: %s" %
', '.join([n.fqdn for n in nodes]))
nodes_ids = [n.id for n in nodes]
if nodes_ids:
logger.info("Assigning IP addresses to nodes..")
netmanager.assign_ips(nodes_ids, "management")
netmanager.assign_ips(nodes_ids, "public")
netmanager.assign_ips(nodes_ids, "storage")
nodes_with_attrs = []
# FIXME(mihgen): We need to pass all other nodes, so astute
# can know about all the env, not only about added nodes.
for n in db().query(Node).filter_by(
cluster=task.cluster
).order_by(Node.id):
# However, we must not pass nodes which are set to be deleted.
if n.pending_deletion:
continue
if n.id in nodes_ids: # It's node which we need to redeploy
n.pending_addition = False
if n.status in ('deploying'):
n.status = 'provisioned'
n.progress = 0
db().add(n)
db().commit()
nodes_with_attrs.append(cls.__format_node_for_naily(n))
cluster_attrs = task.cluster.attributes.merged_attrs_values()
cluster_attrs['master_ip'] = settings.MASTER_IP
cluster_attrs['controller_nodes'] = cls.__controller_nodes(cluster_id)
nets_db = db().query(Network).join(NetworkGroup).\
filter(NetworkGroup.cluster_id == cluster_id).all()
ng_db = db().query(NetworkGroup).filter_by(
cluster_id=cluster_id).all()
for net in ng_db:
net_name = net.name + '_network_range'
if net.name == 'floating':
cluster_attrs[net_name] = \
cls.__get_ip_ranges_first_last(net)
elif net.name == 'public':
# We shouldn't pass public_network_range attribute
continue
else:
cluster_attrs[net_name] = net.cidr
net_params = {}
net_params['network_manager'] = task.cluster.net_manager
fixed_net = db().query(NetworkGroup).filter_by(
cluster_id=cluster_id).filter_by(name='fixed').first()
# network_size is required for all managers, otherwise
# puppet will use default (255)
net_params['network_size'] = fixed_net.network_size
if net_params['network_manager'] == 'VlanManager':
net_params['num_networks'] = fixed_net.amount
net_params['vlan_start'] = fixed_net.vlan_start
cls.__add_vlan_interfaces(nodes_with_attrs)
cluster_attrs['novanetwork_parameters'] = net_params
if task.cluster.mode == 'ha':
logger.info("HA mode chosen, creating VIP addresses for it..")
cluster_attrs['management_vip'] = netmanager.assign_vip(
cluster_id, "management")
cluster_attrs['public_vip'] = netmanager.assign_vip(
cluster_id, "public")
cluster_attrs['deployment_mode'] = task.cluster.mode
cluster_attrs['deployment_id'] = cluster_id
message = {
'method': 'deploy',
'respond_to': 'deploy_resp',
'args': {
'task_uuid': task.uuid,
'nodes': nodes_with_attrs,
'attributes': cluster_attrs
}
}
return message
def get_default_nodes(self, cluster):
if objects.Release.is_lcm_supported(cluster.release):
return objects.Cluster.get_nodes_not_for_deletion(cluster).all()
return TaskHelper.nodes_to_deploy(cluster)
def get_nodes_to_deployment(cls, cluster):
"""Nodes which need to deploy."""
return sorted(TaskHelper.nodes_to_deploy(cluster),
key=lambda node: node.id)
