def update(cls, cluster, network_configuration):
from nailgun.network.manager import NetworkManager
network_manager = NetworkManager()
if 'net_manager' in network_configuration:
setattr(cluster, 'net_manager',
network_configuration['net_manager'])
if 'networks' in network_configuration:
for ng in network_configuration['networks']:
ng_db = orm().query(NetworkGroup).get(ng['id'])
for key, value in ng.iteritems():
if key == "ip_ranges":
# deleting old ip ranges
map(
orm().delete,
orm().query(IPAddrRange).filter_by(
network_group_id=ng['id']))
for r in value:
new_ip_range = IPAddrRange(
first=r[0],
last=r[1],
network_group_id=ng['id'])
orm().add(new_ip_range)
orm().commit()
else:
setattr(ng_db, key, value)
network_manager.create_networks(ng_db)
ng_db.cluster.add_pending_changes('networks')
def get_default(self, node):
nics = []
network_manager = NetworkManager()
for nic in node.interfaces:
nic_dict = {
"id": nic.id,
"name": nic.name,
"mac": nic.mac,
"max_speed": nic.max_speed,
"current_speed": nic.current_speed
}
assigned_ng_ids = network_manager.get_default_nic_networkgroups(
node.id,
nic.id
)
for ng_id in assigned_ng_ids:
ng = db().query(NetworkGroup).get(ng_id)
nic_dict.setdefault("assigned_networks", []).append(
{"id": ng_id, "name": ng.name}
)
allowed_ng_ids = network_manager.get_allowed_nic_networkgroups(
node.id,
nic.id
)
for ng_id in allowed_ng_ids:
ng = db().query(NetworkGroup).get(ng_id)
nic_dict.setdefault("allowed_networks", []).append(
{"id": ng_id, "name": ng.name}
)
nics.append(nic_dict)
return nics
def update(cls, cluster, network_configuration):
from nailgun.network.manager import NetworkManager
network_manager = NetworkManager()
if 'net_manager' in network_configuration:
setattr(
cluster,
'net_manager',
network_configuration['net_manager'])
if 'networks' in network_configuration:
for ng in network_configuration['networks']:
ng_db = db().query(NetworkGroup).get(ng['id'])
for key, value in ng.iteritems():
if key == "ip_ranges":
cls.__set_ip_ranges(ng['id'], value)
else:
if key == 'cidr' and \
not ng['name'] in ('public', 'floating'):
network_manager.update_ranges_from_cidr(
ng_db, value)
setattr(ng_db, key, value)
network_manager.create_networks(ng_db)
ng_db.cluster.add_pending_changes('networks')
def run(self):
super(FakeDeletionThread, self).run()
receiver = NailgunReceiver
kwargs = {
'task_uuid': self.task_uuid,
'nodes': self.data['args']['nodes'],
'status': 'ready'
}
nodes_to_restore = self.data['args'].get('nodes_to_restore', [])
resp_method = getattr(receiver, self.respond_to)
resp_method(**kwargs)
for node_data in nodes_to_restore:
node = Node(**node_data)
# Offline node just deleted from db
# and could not recreated with status
# discover
if not node.online:
continue
node.status = 'discover'
db().add(node)
db().commit()
node.attributes = NodeAttributes(node_id=node.id)
node.attributes.volumes = node.volume_manager.gen_volumes_info()
NetworkManager.update_interfaces_info(node)
db().commit()
ram = round(node.meta.get('ram') or 0, 1)
cores = node.meta.get('cores') or 'unknown'
notifier.notify("discover",
"New node with %s CPU core(s) "
"and %s GB memory is discovered" %
(cores, ram), node_id=node.id)
def PUT(self, cluster_id):
cluster = self.get_object_or_404(Cluster, cluster_id)
data = self.checked_data()
network_manager = NetworkManager()
for key, value in data.iteritems():
if key == "nodes":
# Todo: sepatate nodes for deletion and addition by set().
new_nodes = db().query(Node).filter(Node.id.in_(value))
nodes_to_remove = [
n for n in cluster.nodes if n not in new_nodes
]
nodes_to_add = [n for n in new_nodes if n not in cluster.nodes]
for node in nodes_to_add:
if not node.online:
raise web.badrequest(
"Can not add offline node to cluster")
map(cluster.nodes.remove, nodes_to_remove)
map(cluster.nodes.append, nodes_to_add)
for node in nodes_to_remove:
network_manager.clear_assigned_networks(node.id)
network_manager.clear_all_allowed_networks(node.id)
for node in nodes_to_add:
network_manager.allow_network_assignment_to_all_interfaces(
node.id)
network_manager.assign_networks_to_main_interface(node.id)
else:
setattr(cluster, key, value)
db().commit()
return self.render(cluster)
def PUT(self, node_id):
""":returns: JSONized Node object.
:http: * 200 (OK)
* 400 (invalid node data specified)
* 404 (node not found in db)
"""
node = self.get_object_or_404(Node, node_id)
if not node.attributes:
node.attributes = NodeAttributes(node_id=node.id)
data = self.checked_data(self.validator.validate_update)
network_manager = NetworkManager()
old_cluster_id = node.cluster_id
if data.get("pending_roles") == [] and node.cluster:
node.cluster.clear_pending_changes(node_id=node.id)
if "cluster_id" in data:
if data["cluster_id"] is None and node.cluster:
node.cluster.clear_pending_changes(node_id=node.id)
node.roles = node.pending_roles = []
node.cluster_id = data["cluster_id"]
if node.cluster_id != old_cluster_id:
if old_cluster_id:
network_manager.clear_assigned_networks(node)
network_manager.clear_all_allowed_networks(node.id)
if node.cluster_id:
network_manager.assign_networks_by_default(node)
network_manager.allow_network_assignment_to_all_interfaces(
node)
regenerate_volumes = any(
('roles' in data
and set(data['roles']) != set(node.roles), 'pending_roles' in data
and set(data['pending_roles']) != set(node.pending_roles),
node.cluster_id != old_cluster_id))
for key, value in data.iteritems():
# we don't allow to update id explicitly
# and updated cluster_id before all other fields
if key in ("id", "cluster_id"):
continue
setattr(node, key, value)
if not node.status in ('provisioning',
'deploying') and regenerate_volumes:
try:
node.attributes.volumes = \
node.volume_manager.gen_volumes_info()
except Exception as exc:
msg = (u"Failed to generate volumes "
"info for node '{0}': '{1}'").format(
node.name or data.get("mac") or data.get("id"),
str(exc) or "see logs for details")
logger.warning(traceback.format_exc())
notifier.notify("error", msg, node_id=node.id)
db().commit()
return self.render(node)
def prepare_for_provisioning(cls, nodes):
"""Prepare environment for provisioning,
update fqdns, assign admin IPs
"""
cls.update_slave_nodes_fqdn(nodes)
for node in nodes:
NetworkManager.assign_admin_ips(node.id)
def get_default(self, node):
nics = []
network_manager = NetworkManager()
for nic in node.interfaces:
nic_dict = {
"id": nic.id,
"name": nic.name,
"mac": nic.mac,
"max_speed": nic.max_speed,
"current_speed": nic.current_speed
}
assigned_ngs = network_manager.get_default_nic_networkgroups(
node, nic)
for ng in assigned_ngs:
nic_dict.setdefault('assigned_networks', []).append(
{'id': ng.id, 'name': ng.name})
allowed_ngs = network_manager.get_allowed_nic_networkgroups(
node, nic)
for ng in allowed_ngs:
nic_dict.setdefault('allowed_networks', []).append(
{'id': ng.id, 'name': ng.name})
nics.append(nic_dict)
return nics
def update(cls, cluster, network_configuration):
from nailgun.network.manager import NetworkManager
network_manager = NetworkManager()
if 'net_manager' in network_configuration:
setattr(
cluster,
'net_manager',
network_configuration['net_manager'])
if 'networks' in network_configuration:
for ng in network_configuration['networks']:
ng_db = orm().query(NetworkGroup).get(ng['id'])
for key, value in ng.iteritems():
if key == "ip_ranges":
# deleting old ip ranges
map(
orm().delete,
orm().query(IPAddrRange).filter_by(
network_group_id=ng['id']
)
)
for r in value:
new_ip_range = IPAddrRange(
first=r[0],
last=r[1],
network_group_id=ng['id']
)
orm().add(new_ip_range)
orm().commit()
else:
setattr(ng_db, key, value)
network_manager.create_networks(ng_db)
ng_db.cluster.add_pending_changes('networks')
def get_common_attrs(cls, cluster):
"""Common attributes for all facts
"""
common_attrs = super(OrchestratorHASerializer, cls).get_common_attrs(
cluster)
netmanager = NetworkManager()
common_attrs['management_vip'] = netmanager.assign_vip(
cluster.id, 'management')
common_attrs['public_vip'] = netmanager.assign_vip(
cluster.id, 'public')
sorted_nodes = sorted(
common_attrs['nodes'], key=lambda node: node['uid'])
controller_nodes = cls.filter_by_roles(
sorted_nodes, ['controller', 'primary-controller'])
common_attrs['last_controller'] = controller_nodes[-1]['name']
# Assign primary controller in nodes list
cls.set_primary_controller(common_attrs['nodes'])
common_attrs['mp'] = [
{'point': '1', 'weight': '1'},
{'point': '2', 'weight': '2'}]
return common_attrs
def get_common_attrs(cls, cluster):
"""Common attributes for all facts
"""
common_attrs = super(OrchestratorHASerializer, cls).get_common_attrs(
cluster)
netmanager = NetworkManager()
common_attrs['management_vip'] = netmanager.assign_vip(
cluster.id, 'management')
common_attrs['public_vip'] = netmanager.assign_vip(
cluster.id, 'public')
common_attrs['last_controller'] = sorted(
common_attrs['controller_nodes'],
key=lambda node: node['uid'])[-1]['name']
first_controller = filter(
lambda node: 'controller' in node['role'],
common_attrs['nodes'])[0]
first_controller['role'] = 'primary-controller'
common_attrs['mp'] = [
{'point': '1', 'weight': '1'},
{'point': '2', 'weight': '2'}]
common_attrs['mountpoints'] = '1 1\\n2 2\\n'
return common_attrs
def serialize_for_cluster(cls, cluster):
result = {}
result['net_manager'] = cluster.net_manager
result['networks'] = map(
cls.serialize_network_group,
cluster.network_groups
)
net_manager = NetworkManager()
result['networks'].append(
cls.serialize_network_group(
net_manager.get_admin_network_group()
)
)
if cluster.dns_nameservers:
result['dns_nameservers'] = {
"nameservers": cluster.dns_nameservers
}
if cluster.is_ha_mode:
nw_metadata = cluster.release.networks_metadata["nova_network"]
for network in nw_metadata["networks"]:
if network.get("assign_vip") is not False:
result['{0}_vip'.format(
network["name"]
)] = net_manager.assign_vip(
cluster.id,
network["name"]
)
return result
def get_common_attrs(cls, cluster):
"""Common attributes for all facts
"""
common_attrs = super(
NovaOrchestratorHASerializer,
cls
).get_common_attrs(cluster)
netmanager = NetworkManager()
common_attrs['management_vip'] = netmanager.assign_vip(
cluster.id, 'management')
common_attrs['public_vip'] = netmanager.assign_vip(
cluster.id, 'public')
sorted_nodes = sorted(
common_attrs['nodes'], key=lambda node: int(node['uid']))
controller_nodes = cls.filter_by_roles(
sorted_nodes, ['controller', 'primary-controller'])
common_attrs['last_controller'] = controller_nodes[-1]['name']
# Assign primary controller in nodes list
cls.set_primary_controller(common_attrs['nodes'])
common_attrs['mp'] = [
{'point': '1', 'weight': '1'},
{'point': '2', 'weight': '2'}]
return common_attrs
def render(cls, instance, fields=None):
json_data = JSONHandler.render(instance, fields=cls.fields)
network_manager = NetworkManager()
json_data['network_data'] = network_manager.get_node_networks(
instance.id
)
return json_data
def prepare_for_provisioning(cls, nodes):
"""Prepare environment for provisioning,
update fqdns, assign admin IPs
"""
cls.update_slave_nodes_fqdn(nodes)
for node in nodes:
NetworkManager.assign_admin_ips(node.id)
def prepare_for_provisioning(self):
from nailgun.network.manager import NetworkManager
from nailgun.task.helpers import TaskHelper
netmanager = NetworkManager()
for node in TaskHelper.nodes_to_provision(self):
netmanager.assign_admin_ips(
node.id, len(node.meta.get('interfaces', [])))
def prepare_for_provisioning(cls, nodes):
"""Prepare environment for provisioning,
update fqdns, assign admin ips
"""
cls.update_slave_nodes_fqdn(nodes)
for node in nodes:
NetworkManager.assign_admin_ips(
node.id, len(node.meta.get('interfaces', [])))
def prepare_for_provisioning(cls, nodes):
"""Prepare environment for provisioning,
update fqdns, assign admin ips
"""
cls.update_slave_nodes_fqdn(nodes)
for node in nodes:
NetworkManager.assign_admin_ips(
node.id, len(node.meta.get('interfaces', [])))
def __format_node_for_naily(cls, n):
netmanager = NetworkManager()
return {
'id': n.id, 'status': n.status, 'error_type': n.error_type,
'uid': n.id, 'ip': n.ip, 'mac': n.mac, 'role': n.role,
'fqdn': n.fqdn, 'progress': n.progress, 'meta': n.meta,
'network_data': netmanager.get_node_networks(n.id),
'online': n.online
}
def render(cls, instance, fields=None):
json_data = None
try:
json_data = JSONHandler.render(instance, fields=cls.fields)
network_manager = NetworkManager()
json_data["network_data"] = network_manager.get_node_networks(instance.id)
except Exception:
logger.error(traceback.format_exc())
return json_data
def __format_node_for_naily(cls, n):
netmanager = NetworkManager()
return {
'id': n.id, 'status': n.status, 'error_type': n.error_type,
'uid': n.id, 'ip': n.ip, 'mac': n.mac, 'role': n.role,
'fqdn': n.fqdn, 'progress': n.progress, 'meta': n.meta,
'network_data': netmanager.get_node_networks(n.id),
'online': n.online
}
def get_admin_ips(cls, node):
netmanager = NetworkManager()
admin_net_id = netmanager.get_admin_network_id()
admin_ips = set([
i.ip_addr for i in db().query(IPAddr).
filter_by(node=node.id).
filter_by(network=admin_net_id)])
return admin_ips
def prepare_for_provisioning(self):
from nailgun.network.manager import NetworkManager
from nailgun.task.helpers import TaskHelper
netmanager = NetworkManager()
nodes = TaskHelper.nodes_to_provision(self)
TaskHelper.update_slave_nodes_fqdn(nodes)
for node in nodes:
netmanager.assign_admin_ips(node.id, len(node.meta.get("interfaces", [])))
def get_admin_ips(cls, node):
netmanager = NetworkManager()
admin_net_id = netmanager.get_admin_network_id()
admin_ips = set([
i.ip_addr for i in db().query(IPAddr).
filter_by(node=node.id).
filter_by(network=admin_net_id)])
return admin_ips
def _success_action(cls, task, status, progress):
network_manager = NetworkManager()
# check if all nodes are ready
if any(map(lambda n: n.status == 'error', task.cluster.nodes)):
cls._error_action(task, 'error', 100)
return
if task.cluster.mode in ('singlenode', 'multinode'):
# determining horizon url - it's an IP
# of a first cluster controller
controller = db().query(Node).filter_by(cluster_id=task.cluster_id,
role='controller').first()
if controller:
logger.debug(
u"Controller is found, node_id=%s, "
"getting it's IP addresses", controller.id)
public_net = filter(
lambda n: n['name'] == 'public' and 'ip' in n,
network_manager.get_node_networks(controller.id))
if public_net:
horizon_ip = public_net[0]['ip'].split('/')[0]
message = (
u"Deployment of environment '{0}' is done. "
"Access the OpenStack dashboard (Horizon) at "
"http://{1}/ or via internal network at http://{2}/"
).format(task.cluster.name, horizon_ip, controller.ip)
else:
message = (
u"Deployment of environment '{0}' is done").format(
task.cluster.name)
logger.warning(u"Public ip for controller node "
"not found in '{0}'".format(
task.cluster.name))
else:
message = (u"Deployment of environment"
" '{0}' is done").format(task.cluster.name)
logger.warning(u"Controller node not found in '{0}'".format(
task.cluster.name))
elif task.cluster.mode == 'ha':
# determining horizon url in HA mode - it's vip
# from a public network saved in task cache
args = task.cache.get('args')
try:
vip = args['attributes']['public_vip']
message = (
u"Deployment of environment '{0}' is done. "
"Access the OpenStack dashboard (Horizon) at http://{1}/"
).format(task.cluster.name, vip)
except Exception as exc:
logger.error(": ".join([str(exc), traceback.format_exc()]))
message = (u"Deployment of environment"
" '{0}' is done").format(task.cluster.name)
logger.warning(u"Cannot find virtual IP for '{0}'".format(
task.cluster.name))
notifier.notify("done", message, task.cluster_id)
TaskHelper.update_task_status(task.uuid, status, progress, message)
def serialize_for_cluster(cls, cluster):
result = {}
result["net_manager"] = cluster.net_manager
result["networks"] = map(cls.serialize_network_group, cluster.network_groups)
if cluster.is_ha_mode:
net_manager = NetworkManager()
result["management_vip"] = net_manager.assign_vip(cluster.id, "management")
result["public_vip"] = net_manager.assign_vip(cluster.id, "public")
return result
def render(cls, instance, fields=None):
json_data = None
try:
json_data = JSONHandler.render(instance, fields=cls.fields)
network_manager = NetworkManager()
json_data['network_data'] = network_manager.get_node_networks(
instance.id)
except Exception:
logger.error(traceback.format_exc())
return json_data
def prepare_for_provisioning(self):
from nailgun.network.manager import NetworkManager
from nailgun.task.helpers import TaskHelper
netmanager = NetworkManager()
nodes = TaskHelper.nodes_to_provision(self)
TaskHelper.update_slave_nodes_fqdn(nodes)
for node in nodes:
netmanager.assign_admin_ips(node.id,
len(node.meta.get('interfaces', [])))
def remove_cluster_resp(cls, **kwargs):
network_manager = NetworkManager()
logger.info(
"RPC method remove_cluster_resp received: %s" %
json.dumps(kwargs)
)
task_uuid = kwargs.get('task_uuid')
cls.remove_nodes_resp(**kwargs)
task = db().query(Task).filter_by(uuid=task_uuid).first()
cluster = task.cluster
if task.status in ('ready',):
logger.debug("Removing environment itself")
cluster_name = cluster.name
nws = itertools.chain(
*[n.networks for n in cluster.network_groups]
)
ips = db().query(IPAddr).filter(
IPAddr.network.in_([n.id for n in nws])
)
map(db().delete, ips)
db().commit()
db().delete(cluster)
db().commit()
# Dmitry's hack for clearing VLANs without networks
network_manager.clear_vlans()
notifier.notify(
"done",
u"Environment '%s' and all its nodes are deleted" % (
cluster_name
)
)
elif task.status in ('error',):
cluster.status = 'error'
db().add(cluster)
db().commit()
if not task.message:
task.message = "Failed to delete nodes:\n{0}".format(
cls._generate_error_message(
task,
error_types=('deletion',)
)
)
notifier.notify(
"error",
task.message,
cluster.id
)
def PUT(self, cluster_id):
cluster = self.get_object_or_404(Cluster, cluster_id)
data = self.checked_data()
network_manager = NetworkManager()
for key, value in data.iteritems():
if key == "nodes":
# Todo: sepatate nodes for deletion and addition by set().
new_nodes = db().query(Node).filter(
Node.id.in_(value)
)
nodes_to_remove = [n for n in cluster.nodes
if n not in new_nodes]
nodes_to_add = [n for n in new_nodes
if n not in cluster.nodes]
for node in nodes_to_add:
if not node.online:
raise web.badrequest(
"Can not add offline node to cluster")
map(cluster.nodes.remove, nodes_to_remove)
map(cluster.nodes.append, nodes_to_add)
for node in nodes_to_remove:
network_manager.clear_assigned_networks(node.id)
network_manager.clear_all_allowed_networks(node.id)
for node in nodes_to_add:
network_manager.allow_network_assignment_to_all_interfaces(
node.id
)
network_manager.assign_networks_to_main_interface(node.id)
else:
setattr(cluster, key, value)
db().commit()
return self.render(cluster)
def PUT(self):
data = self.validator.validate_collection_structure(web.data())
network_manager = NetworkManager()
updated_nodes_ids = []
for node_data in data:
self.validator.verify_data_correctness(node_data)
node_id = network_manager._update_attrs(node_data)
updated_nodes_ids.append(node_id)
updated_nodes = db().query(Node).filter(
Node.id.in_(updated_nodes_ids)).all()
return map(self.render, updated_nodes)
def PUT(self, node_id):
""":returns: Collection of JSONized Node objects.
:http: * 200 (nodes are successfully updated)
* 400 (invalid nodes data specified)
"""
interfaces_data = self.checked_data(
self.validator.validate_structure_and_data, node_id=node_id)
node_data = {'id': node_id, 'interfaces': interfaces_data}
NetworkManager._update_attrs(node_data)
node = self.get_object_or_404(Node, node_id)
return map(self.render, node.interfaces)
def PUT(self):
data = self.validator.validate_collection_structure(web.data())
network_manager = NetworkManager()
updated_nodes_ids = []
for node_data in data:
self.validator.verify_data_correctness(node_data)
node_id = network_manager._update_attrs(node_data)
updated_nodes_ids.append(node_id)
updated_nodes = db().query(Node).filter(
Node.id.in_(updated_nodes_ids)
).all()
return map(self.render, updated_nodes)
def PUT(self, node_id):
""":returns: Collection of JSONized Node objects.
:http: * 200 (nodes are successfully updated)
* 400 (invalid nodes data specified)
"""
interfaces_data = self.validator.validate_json(web.data())
node_data = {'id': node_id, 'interfaces': interfaces_data}
self.validator.validate(node_data)
NetworkManager._update_attrs(node_data)
node = self.get_object_or_404(Node, node_id)
return map(self.render, node.interfaces)
def serialize_for_cluster(cls, cluster):
result = {}
result['net_manager'] = cluster.net_manager
result['networks'] = map(cls.serialize_network_group,
cluster.network_groups)
if cluster.mode == 'ha':
net_manager = NetworkManager()
result['management_vip'] = net_manager.assign_vip(
cluster.id, 'management')
result['public_vip'] = net_manager.assign_vip(cluster.id, 'public')
return result
def PUT(self, node_id):
""":returns: JSONized Node object.
:http: * 200 (OK)
* 400 (invalid node data specified)
* 404 (node not found in db)
"""
node = self.get_object_or_404(Node, node_id)
if not node.attributes:
node.attributes = NodeAttributes(node_id=node.id)
data = self.checked_data(self.validator.validate_update)
network_manager = NetworkManager()
old_cluster_id = node.cluster_id
if data.get("pending_roles") == [] and node.cluster:
node.cluster.clear_pending_changes(node_id=node.id)
if "cluster_id" in data:
if data["cluster_id"] is None and node.cluster:
node.cluster.clear_pending_changes(node_id=node.id)
node.roles = node.pending_roles = []
node.cluster_id = data["cluster_id"]
if node.cluster_id != old_cluster_id:
if old_cluster_id:
network_manager.clear_assigned_networks(node)
network_manager.clear_all_allowed_networks(node.id)
if node.cluster_id:
network_manager.assign_networks_by_default(node)
network_manager.allow_network_assignment_to_all_interfaces(node)
regenerate_volumes = any(
(
"roles" in data and set(data["roles"]) != set(node.roles),
"pending_roles" in data and set(data["pending_roles"]) != set(node.pending_roles),
node.cluster_id != old_cluster_id,
)
)
for key, value in data.iteritems():
# we don't allow to update id explicitly
# and updated cluster_id before all other fields
if key in ("id", "cluster_id"):
continue
setattr(node, key, value)
if not node.status in ("provisioning", "deploying") and regenerate_volumes:
try:
node.attributes.volumes = node.volume_manager.gen_volumes_info()
except Exception as exc:
msg = (u"Failed to generate volumes " "info for node '{0}': '{1}'").format(
node.name or data.get("mac") or data.get("id"), str(exc) or "see logs for details"
)
logger.warning(traceback.format_exc())
notifier.notify("error", msg, node_id=node.id)
db().commit()
return self.render(node)
def get_admin_ip(cls, node):
"""Getting admin ip and assign prefix from admin network."""
network_manager = NetworkManager()
admin_ip = network_manager.get_admin_ips_for_interfaces(node)[
node.admin_interface.name]
admin_ip = IPNetwork(admin_ip)
# Assign prefix from admin network
admin_net = IPNetwork(network_manager.get_admin_network().cidr)
admin_ip.prefixlen = admin_net.prefixlen
return str(admin_ip)
def get_controller_nodes_ips(self, cluster):
"""
Return admin network ips
"""
network_manager = NetworkManager()
admin_net_id = network_manager.get_admin_network_id()
ip_addrs = []
for node in self.controllers(cluster):
ip_addr = db().query(IPAddr).filter_by(node=node.id, network=admin_net_id).first().ip_addr
ip_addrs.append(ip_addr)
return ip_addrs
def get_admin_ip(cls, node):
"""Getting admin ip and assign prefix from admin network."""
network_manager = NetworkManager()
admin_ip = network_manager.get_admin_ips_for_interfaces(
node)[node.admin_interface.name]
admin_ip = IPNetwork(admin_ip)
# Assign prefix from admin network
admin_net = IPNetwork(network_manager.get_admin_network().cidr)
admin_ip.prefixlen = admin_net.prefixlen
return str(admin_ip)
def _success_action(cls, task, status, progress):
network_manager = NetworkManager()
# check if all nodes are ready
if any(map(lambda n: n.status == "error", task.cluster.nodes)):
cls._error_action(task, "error", 100)
return
if task.cluster.mode in ("singlenode", "multinode"):
# determining horizon url - it's an IP
# of a first cluster controller
controller = (
db()
.query(Node)
.filter_by(cluster_id=task.cluster_id)
.filter(Node.role_list.any(name="controller"))
.first()
)
if controller:
logger.debug(u"Controller is found, node_id=%s, " "getting it's IP addresses", controller.id)
public_net = filter(
lambda n: n["name"] == "public" and "ip" in n, network_manager.get_node_networks(controller.id)
)
if public_net:
horizon_ip = public_net[0]["ip"].split("/")[0]
message = (
u"Deployment of environment '{0}' is done. "
"Access the OpenStack dashboard (Horizon) at "
"http://{1}/ or via internal network at http://{2}/"
).format(task.cluster.name, horizon_ip, controller.ip)
else:
message = (u"Deployment of environment '{0}' is done").format(task.cluster.name)
logger.warning(u"Public ip for controller node " "not found in '{0}'".format(task.cluster.name))
else:
message = (u"Deployment of environment" " '{0}' is done").format(task.cluster.name)
logger.warning(u"Controller node not found in '{0}'".format(task.cluster.name))
elif task.cluster.mode == "ha":
# determining horizon url in HA mode - it's vip
# from a public network saved in task cache
args = task.cache.get("args")
try:
vip = args["attributes"]["public_vip"]
message = (
u"Deployment of environment '{0}' is done. "
"Access the OpenStack dashboard (Horizon) at http://{1}/"
).format(task.cluster.name, vip)
except Exception as exc:
logger.error(": ".join([str(exc), traceback.format_exc()]))
message = (u"Deployment of environment" " '{0}' is done").format(task.cluster.name)
logger.warning(u"Cannot find virtual IP for '{0}'".format(task.cluster.name))
notifier.notify("done", message, task.cluster_id)
TaskHelper.update_task_status(task.uuid, status, progress, message)
def add_vlan_interfaces(cls, nodes):
"""Assign fixed_interfaces and vlan_interface.
They should be equal.
"""
netmanager = NetworkManager()
for node in nodes:
node_db = db().query(Node).get(node['uid'])
fixed_interface = netmanager._get_interface_by_network_name(
node_db.id, 'fixed')
node['fixed_interface'] = fixed_interface.name
node['vlan_interface'] = fixed_interface.name
def add_vlan_interfaces(cls, nodes):
"""Assign fixed_interfaces and vlan_interface.
They should be equal.
"""
netmanager = NetworkManager()
for node in nodes:
node_db = db().query(Node).get(node['uid'])
fixed_interface = netmanager._get_interface_by_network_name(
node_db.id, 'fixed')
node['fixed_interface'] = fixed_interface.name
node['vlan_interface'] = fixed_interface.name
def PUT(self, node_id):
""":returns: Collection of JSONized Node objects.
:http: * 200 (nodes are successfully updated)
* 400 (invalid nodes data specified)
"""
interfaces_data = self.validator.validate_json(web.data())
node_data = {'id': node_id, 'interfaces': interfaces_data}
self.validator.validate(node_data)
network_manager = NetworkManager()
network_manager._update_attrs(node_data)
node = self.get_object_or_404(Node, node_id)
return self.render(node)['interfaces']
def __init__(self, app):
self.db = db()
self.app = app
self.tester = TestCase
self.tester.runTest = lambda a: None
self.tester = self.tester()
self.here = os.path.abspath(os.path.dirname(__file__))
self.fixture_dir = os.path.join(self.here, "..", "fixtures")
self.default_headers = {"Content-Type": "application/json"}
self.releases = []
self.clusters = []
self.nodes = []
self.network_manager = NetworkManager()
def serialize_for_cluster(cls, cluster):
result = {}
result['net_manager'] = cluster.net_manager
result['networks'] = map(cls.serialize_network_group,
cluster.network_groups)
if cluster.is_ha_mode:
nw_metadata = cluster.release.networks_metadata
net_manager = NetworkManager()
for network in nw_metadata:
if network.get("assign_vip") is not False:
result['{0}_vip'.format(
network["name"])] = net_manager.assign_vip(
cluster.id, network["name"])
return result
def PUT(self):
""":returns: Collection of JSONized Node objects.
:http: * 200 (nodes are successfully updated)
* 400 (invalid nodes data specified)
"""
data = self.validator.validate_collection_structure(web.data())
network_manager = NetworkManager()
updated_nodes_ids = []
for node_data in data:
self.validator.verify_data_correctness(node_data)
node_id = network_manager._update_attrs(node_data)
updated_nodes_ids.append(node_id)
updated_nodes = db().query(Node).filter(Node.id.in_(updated_nodes_ids)).all()
return map(self.render, updated_nodes)
def POST(self):
""":returns: JSONized Cluster object.
:http: * 201 (cluster successfully created)
* 400 (invalid cluster data specified)
* 409 (cluster with such parameters already exists)
"""
# It's used for cluster creating only.
data = self.checked_data()
cluster = Cluster()
cluster.release = db().query(Release).get(data["release"])
# TODO(NAME): use fields
for field in ('name', 'mode', 'net_manager'):
if data.get(field):
setattr(cluster, field, data.get(field))
db().add(cluster)
db().commit()
attributes = Attributes(
editable=cluster.release.attributes_metadata.get("editable"),
generated=cluster.release.attributes_metadata.get("generated"),
cluster=cluster
)
attributes.generate_fields()
netmanager = NetworkManager()
try:
netmanager.create_network_groups(cluster.id)
cluster.add_pending_changes("attributes")
cluster.add_pending_changes("networks")
if 'nodes' in data and data['nodes']:
nodes = db().query(Node).filter(
Node.id.in_(data['nodes'])
).all()
map(cluster.nodes.append, nodes)
db().commit()
for node in nodes:
netmanager.allow_network_assignment_to_all_interfaces(
node.id
)
netmanager.assign_networks_to_main_interface(node.id)
raise web.webapi.created(json.dumps(
ClusterHandler.render(cluster),
indent=4
))
except (
errors.OutOfVLANs,
errors.OutOfIPs,
errors.NoSuitableCIDR,
errors.InvalidNetworkPool
) as e:
# Cluster was created in this request,
# so we no need to use ClusterDeletionManager.
# All relations wiil be cascade deleted automaticly.
# TODO(NAME): investigate transactions
db().delete(cluster)
raise web.badrequest(e.message)
def add_vlan_interfaces(cls, nodes):
"""We shouldn't pass to orchetrator fixed network
when network manager is VlanManager, but we should specify
fixed_interface (private_interface in terms of fuel) as result
we just pass vlan_interface as node attribute.
"""
netmanager = NetworkManager()
for node in nodes:
node_db = db().query(Node).get(node['uid'])
fixed_interface = netmanager._get_interface_by_network_name(
node_db.id, 'fixed')
node['vlan_interface'] = fixed_interface.name
def PUT(self):
""":returns: Collection of JSONized Node objects.
:http: * 200 (nodes are successfully updated)
* 400 (invalid nodes data specified)
"""
data = self.validator.validate_collection_structure(web.data())
network_manager = NetworkManager()
updated_nodes_ids = []
for node_data in data:
self.validator.verify_data_correctness(node_data)
node_id = network_manager._update_attrs(node_data)
updated_nodes_ids.append(node_id)
updated_nodes = db().query(Node).filter(
Node.id.in_(updated_nodes_ids)).all()
return map(self.render, updated_nodes)
class TestNetworkConfigurationHandlerHAMode(BaseIntegrationTest):
def setUp(self):
super(TestNetworkConfigurationHandlerHAMode, self).setUp()
cluster = self.env.create_cluster(api=True, mode="ha_compact")
self.cluster = self.db.query(Cluster).get(cluster["id"])
self.net_manager = NetworkManager()
def test_returns_management_vip_and_public_vip(self):
url = reverse("NovaNetworkConfigurationHandler", kwargs={"cluster_id": self.cluster.id})
resp = json.loads(self.app.get(url, headers=self.default_headers).body)
self.assertEquals(resp["management_vip"], self.net_manager.assign_vip(self.cluster.id, "management"))
self.assertEquals(resp["public_vip"], self.net_manager.assign_vip(self.cluster.id, "public"))
def __add_vlan_interfaces(cls, nodes):
"""
We shouldn't pass to orchetrator fixed network
when network manager is VlanManager, but we should specify
fixed_interface (private_interface in terms of fuel) as result
we just pass vlan_interface as node attribute.
"""
netmanager = NetworkManager()
for node in nodes:
node_db = orm().query(Node).get(node['id'])
fixed_interface = netmanager._get_interface_by_network_name(
node_db, 'fixed')
node['vlan_interface'] = fixed_interface.name
def serialize_for_cluster(cls, cluster):
result = {}
result['net_manager'] = cluster.net_manager
result['networks'] = map(
cls.serialize_network_group,
cluster.network_groups
)
if cluster.mode == 'ha':
net_manager = NetworkManager()
result['management_vip'] = net_manager.assign_vip(
cluster.id, 'management')
result['public_vip'] = net_manager.assign_vip(
cluster.id, 'public')
return result
def setUp(self):
super(TestRepoAvailability, self).setUp()
self.env.create(cluster_kwargs={
'net_provider': 'neutron',
'net_segment_type': 'gre'
},
nodes_kwargs=[{
'roles': ['controller']
}, {
'roles': ['controller']
}, {
'roles': ['compute']
}, {
'roles': ['compute'],
'online': False
}])
self.cluster = self.env.clusters[0]
self.public_ng = next(ng for ng in self.cluster.network_groups
if ng.name == 'public')
self.free_ips = NetworkManager.get_free_ips(self.public_ng, 2)
self.repo_urls = objects.Cluster.get_repo_urls(self.cluster)
self.controllers = [
n for n in self.cluster.nodes if 'controller' in n.all_roles
]
self.online_uids = [n.uid for n in self.cluster.nodes if n.online]
def get_common_attrs(cls, cluster):
"""Common attributes for all facts
"""
common_attrs = super(DeploymentHASerializer,
cls).get_common_attrs(cluster)
for ng in cluster.network_groups:
if ng.meta.get("assign_vip"):
common_attrs[ng.name + '_vip'] = NetworkManager.assign_vip(
cluster.id, ng.name)
common_attrs['mp'] = [{
'point': '1',
'weight': '1'
}, {
'point': '2',
'weight': '2'
}]
sorted_nodes = sorted(common_attrs['nodes'],
key=lambda node: int(node['uid']))
controller_nodes = cls.filter_by_roles(
sorted_nodes, ['controller', 'primary-controller'])
common_attrs['last_controller'] = controller_nodes[-1]['name']
# Assign primary controller in nodes list
cls.set_primary_controller(common_attrs['nodes'])
return common_attrs
def get_default(self, node):
if node.cluster and node.cluster.net_provider == 'neutron':
network_manager = NeutronManager()
else:
network_manager = NetworkManager()
return network_manager.get_default_networks_assignment(node)
def POST(self, cluster_id):
""":returns: Empty string
:http: * 204 (node successfully unassigned)
* 404 (node not found in db)
"""
nodes = self.checked_data(self.validator.validate_collection_update)
for node in nodes:
if node.status == "discover":
node.cluster.clear_pending_changes(node_id=node.id)
node.pending_roles = []
node.cluster_id = None
node.pending_addition = False
NetworkManager.clear_assigned_networks(node)
else:
node.pending_deletion = True
db().commit()
raise web.ok
def admin_interface(self):
"""Iterate over interfaces, if admin subnet include
ip address of current interface then return this interface.
:raises: errors.CanNotFindInterface
"""
from nailgun.network.manager import NetworkManager
network_manager = NetworkManager()
for interface in self.interfaces:
ip_addr = interface.ip_addr
if network_manager.is_ip_belongs_to_admin_subnet(ip_addr):
return interface
logger.warning(u'Cannot find admin interface for node '
'return first interface: "%s"' % self.full_name)
return self.interfaces[0]
def render(cls, nodes, fields=None):
json_list = []
network_manager = NetworkManager()
ips_mapped = network_manager.get_grouped_ips_by_node()
networks_grouped = network_manager.get_networks_grouped_by_cluster()
for node in nodes:
try:
json_data = JSONHandler.render(node, fields=cls.fields)
json_data['network_data'] = network_manager.\
get_node_networks_optimized(
node, ips_mapped.get(node.id, []),
networks_grouped.get(node.cluster_id, []))
json_list.append(json_data)
except Exception:
logger.error(traceback.format_exc())
return json_list
