openstack
/
fuel-web
Code Issues Proposed changes

Merge "Move all db queries from network manager to objects"

This commit is contained in:
Jenkins 2016-02-26 09:59:53 +00:00 committed by Gerrit Code Review
parent 358ebd93f4 db52d6a490
commit 476d9a21e7
21 changed files with 277 additions and 550 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
nailgun/nailgun/extensions/cluster_upgrade/objects/adapters.py
View File

@ -79,8 +79,7 @@ class NailgunClusterAdapter(object):
for ng in self.cluster.network_groups) for ng in self.cluster.network_groups)
def get_admin_network_group(self): def get_admin_network_group(self):
manager = self.get_network_manager() return objects.NetworkGroup.get_admin_network_group()
return manager.get_admin_network_group()
class NailgunReleaseAdapter(object): class NailgunReleaseAdapter(object):
@ -125,18 +124,18 @@ class NailgunNetworkManager(object):
self.net_manager.assign_given_vips_for_net_groups(self.cluster, vips) self.net_manager.assign_given_vips_for_net_groups(self.cluster, vips)
def get_admin_network_group(self, node_id=None): def get_admin_network_group(self, node_id=None):
ng = self.net_manager.get_admin_network_group(node_id) ng = objects.NetworkGroup.get_admin_network_group(node_id)
return NailgunNetworkGroupAdapter(ng) return NailgunNetworkGroupAdapter(ng)
def set_node_netgroups_ids(self, node, mapping): def set_node_netgroups_ids(self, node, mapping):
return self.net_manager.set_node_netgroups_ids(node.node, mapping) return objects.Node.set_netgroups_ids(node.node, mapping)
def set_nic_assignment_netgroups_ids(self, node, mapping): def set_nic_assignment_netgroups_ids(self, node, mapping):
return self.net_manager.set_nic_assignment_netgroups_ids( return objects.Node.set_nic_assignment_netgroups_ids(
node.node, mapping) node.node, mapping)
def set_bond_assignment_netgroups_ids(self, node, mapping): def set_bond_assignment_netgroups_ids(self, node, mapping):
return self.net_manager.set_bond_assignment_netgroups_ids( return objects.Node.set_bond_assignment_netgroups_ids(
node.node, mapping) node.node, mapping)

4
nailgun/nailgun/extensions/cluster_upgrade/upgrade.py
View File

@ -20,6 +20,7 @@ from distutils import version
import six import six
from nailgun import consts from nailgun import consts
from nailgun import objects
from nailgun.objects.serializers import network_configuration from nailgun.objects.serializers import network_configuration
from nailgun import utils from nailgun import utils
@ -173,13 +174,12 @@ class UpgradeHelper(object):
node.cluster_id) node.cluster_id)
orig_manager = orig_cluster.get_network_manager() orig_manager = orig_cluster.get_network_manager()
seed_manager = seed_cluster.get_network_manager()
netgroups_id_mapping = cls.get_netgroups_id_mapping( netgroups_id_mapping = cls.get_netgroups_id_mapping(
orig_cluster, seed_cluster) orig_cluster, seed_cluster)
node.update_cluster_assignment(seed_cluster) node.update_cluster_assignment(seed_cluster)
seed_manager.set_node_netgroups_ids(node, netgroups_id_mapping) objects.Node.set_netgroups_ids(node, netgroups_id_mapping)
orig_manager.set_nic_assignment_netgroups_ids( orig_manager.set_nic_assignment_netgroups_ids(
node, netgroups_id_mapping) node, netgroups_id_mapping)
orig_manager.set_bond_assignment_netgroups_ids( orig_manager.set_bond_assignment_netgroups_ids(

5
nailgun/nailgun/network/checker.py
View File

@ -21,7 +21,6 @@ from itertools import product
import netaddr import netaddr
from nailgun import consts from nailgun import consts
from nailgun.db.sqlalchemy import models
from nailgun.errors import errors from nailgun.errors import errors
from nailgun.logger import logger from nailgun.logger import logger
from nailgun import objects from nailgun import objects
@ -44,8 +43,8 @@ class NetworkCheck(object):
self.data = data self.data = data
self.net_man = objects.Cluster.get_network_manager(self.cluster) self.net_man = objects.Cluster.get_network_manager(self.cluster)
self.net_provider = self.cluster.net_provider self.net_provider = self.cluster.net_provider
admin_ng = self.net_man.get_admin_network_group() admin_ng = objects.NetworkGroup.get_admin_network_group()
fields = models.NetworkGroup.__mapper__.columns.keys() + ['meta'] fields = objects.NetworkGroup.fields()
net = NetworkConfigurationSerializer.serialize_network_group(admin_ng, net = NetworkConfigurationSerializer.serialize_network_group(admin_ng,
fields) fields)
# change Admin name for UI # change Admin name for UI

589
nailgun/nailgun/network/manager.py
View File

@ -24,24 +24,9 @@ from netaddr import IPAddress
from netaddr import IPNetwork from netaddr import IPNetwork
from netaddr import IPRange from netaddr import IPRange
import copy
import six import six
from sqlalchemy.orm import joinedload
from sqlalchemy.sql import not_
from sqlalchemy.sql import or_
from nailgun import consts from nailgun import consts
from nailgun.db import db
from nailgun.db.sqlalchemy.models import IPAddr
from nailgun.db.sqlalchemy.models import IPAddrRange
from nailgun.db.sqlalchemy.models import NetworkBondAssignment
from nailgun.db.sqlalchemy.models import NetworkGroup
from nailgun.db.sqlalchemy.models import NetworkNICAssignment
from nailgun.db.sqlalchemy.models import Node
from nailgun.db.sqlalchemy.models import NodeBondInterface
from nailgun.db.sqlalchemy.models import NodeGroup
from nailgun.db.sqlalchemy.models import NodeNICInterface
from nailgun.errors import errors from nailgun.errors import errors
from nailgun.logger import logger from nailgun.logger import logger
from nailgun.network import utils from nailgun.network import utils
@ -74,38 +59,6 @@ class NetworkManager(object):
""" """
cls.assign_admin_ips(nodes) cls.assign_admin_ips(nodes)
@classmethod
def get_admin_network_group_id(cls, node_id=None):
"""Method for receiving Admin NetworkGroup ID.
:param node_id: the ID of Node
:returns: Admin NetworkGroup ID or None.
:raises: errors.AdminNetworkNotFound
"""
return cls.get_admin_network_group(node_id=node_id).id
@classmethod
def get_admin_network_group(cls, node_id=None):
"""Method for receiving Admin NetworkGroup.
:param node_id: The ID of node
:returns: Admin NetworkGroup or None.
:raises: errors.AdminNetworkNotFound
"""
admin_ng = None
admin_ngs = db().query(NetworkGroup).filter_by(
name="fuelweb_admin",
)
if node_id:
node_db = db().query(Node).get(node_id)
admin_ng = admin_ngs.filter_by(group_id=node_db.group_id).first()
admin_ng = admin_ng or admin_ngs.filter_by(group_id=None).first()
if not admin_ng:
raise errors.AdminNetworkNotFound()
return admin_ng
@classmethod @classmethod
def reusable_ip_address(cls, node, network): def reusable_ip_address(cls, node, network):
"""Verifies that ip belongs to network and creates IPAddr in case it is """Verifies that ip belongs to network and creates IPAddr in case it is
@ -115,9 +68,10 @@ class NetworkManager(object):
:returns: IPAddr object or None :returns: IPAddr object or None
""" """
if node.ip and cls.check_ip_belongs_to_net(node.ip, network): if node.ip and cls.check_ip_belongs_to_net(node.ip, network):
return IPAddr(node=node.id, return objects.IPAddr.create(
ip_addr=node.ip, {'network': network.id, 'ip_addr': node.ip, 'node': node.id}
network=network.id) )
return None return None
@classmethod @classmethod
@ -135,73 +89,20 @@ class NetworkManager(object):
nodes_need_ips = defaultdict(list) nodes_need_ips = defaultdict(list)
for node in nodes: for node in nodes:
node_id = node.id node_id = node.id
admin_net = cls.get_admin_network_group(node_id) admin_net = objects.NetworkGroup.get_admin_network_group(node_id)
node_admin_ips = db().query(IPAddr).filter_by( node_admin_ips_count = objects.Node.get_network_ips_count(
node=node_id, network=admin_net.id) node_id, admin_net.id)
logger.debug(u"Trying to assign admin ip: node=%s", node_id) logger.debug(u"Trying to assign admin ip: node=%s", node_id)
if not db().query(node_admin_ips.exists()).scalar(): if not node_admin_ips_count:
reusable_ip = cls.reusable_ip_address(node, admin_net) if not cls.reusable_ip_address(node, admin_net):
if reusable_ip:
db().add(reusable_ip)
else:
nodes_need_ips[admin_net].append(node_id) nodes_need_ips[admin_net].append(node_id)
db().flush()
for admin_net, nodes in six.iteritems(nodes_need_ips): for admin_net, nodes in six.iteritems(nodes_need_ips):
free_ips = cls.get_free_ips(admin_net, len(nodes)) free_ips = cls.get_free_ips(admin_net, len(nodes))
for ip, n in zip(free_ips, nodes): for ip, n in six.moves.zip(free_ips, nodes):
ip_db = IPAddr(node=n, objects.IPAddr.create(
ip_addr=ip, {'network': admin_net.id, 'ip_addr': ip, 'node': n}
network=admin_net.id) )
db().add(ip_db)
db().flush()
@classmethod
def get_node_networks_ips(cls, node):
return dict(
db().query(NetworkGroup.name, IPAddr.ip_addr).
filter(NetworkGroup.group_id == node.group_id).
filter(IPAddr.network == NetworkGroup.id).
filter(IPAddr.node == node.id)
)
@classmethod
def set_node_networks_ips(cls, node, ips_by_network_name):
ngs = db().query(NetworkGroup.name, IPAddr).\
filter(NetworkGroup.group_id == node.group_id).\
filter(IPAddr.network == NetworkGroup.id).\
filter(IPAddr.node == node.id).\
filter(NetworkGroup.name.in_(ips_by_network_name))
for ng_name, ip_addr in ngs:
ip_addr.ip_addr = ips_by_network_name[ng_name]
db().flush()
@classmethod
def set_node_netgroups_ids(cls, node, netgroups_id_mapping):
ip_addrs = db().query(IPAddr).filter(IPAddr.node == node.id)
for ip_addr in ip_addrs:
ip_addr.network = netgroups_id_mapping[ip_addr.network]
db().flush()
@classmethod
def set_nic_assignment_netgroups_ids(cls, node, netgroups_id_mapping):
nic_assignments = db.query(NetworkNICAssignment).\
join(NodeNICInterface).\
filter(NodeNICInterface.node_id == node.id)
for nic_assignment in nic_assignments:
nic_assignment.network_id = \
netgroups_id_mapping[nic_assignment.network_id]
db().flush()
@classmethod
def set_bond_assignment_netgroups_ids(cls, node, netgroups_id_mapping):
bond_assignments = db.query(NetworkBondAssignment).\
join(NodeBondInterface).\
filter(NodeBondInterface.node_id == node.id)
for bond_assignment in bond_assignments:
bond_assignment.network_id = \
netgroups_id_mapping[bond_assignment.network_id]
db().flush()
@classmethod @classmethod
def assign_ips(cls, cluster, nodes, network_name): def assign_ips(cls, cluster, nodes, network_name):
@ -222,8 +123,8 @@ class NetworkManager(object):
:returns: None :returns: None
:raises: Exception, errors.AssignIPError :raises: Exception, errors.AssignIPError
""" """
network_groups = db().query(NetworkGroup).\ network_groups = objects.NetworkGroupCollection.filter_by(
filter_by(name=network_name) iterable=cluster.network_groups, name=network_name)
if not network_groups: if not network_groups:
raise errors.AssignIPError( raise errors.AssignIPError(
@ -246,19 +147,14 @@ class NetworkManager(object):
if network_name == 'public' and \ if network_name == 'public' and \
not objects.Node.should_have_public_with_ip(node): not objects.Node.should_have_public_with_ip(node):
continue continue
group_id = node.group_id or \
objects.Cluster.get_default_group(node.cluster).id
network = network_groups.filter( network = objects.NetworkGroup.get_node_network_by_name(
or_( node, network_name
NetworkGroup.group_id == group_id, )
NetworkGroup.group_id.is_(None)
)
).first()
node_ips = six.moves.map( node_ips = six.moves.map(
lambda i: i.ip_addr, lambda i: i.ip_addr,
cls._get_ips_except_admin( objects.IPAddr.get_ips_except_admin(
node_id=node_id, node_id=node_id,
network_id=network.id network_id=network.id
) )
@ -294,11 +190,9 @@ class NetworkManager(object):
network_name network_name
) )
) )
ip_db = IPAddr(node=n, objects.IPAddr.create(
ip_addr=ip, {'network': network.id, 'ip_addr': ip, 'node': n}
network=network.id) )
db().add(ip_db)
db().flush()
@classmethod @classmethod
def get_assigned_vip(cls, nodegroup, network_name, vip_name): def get_assigned_vip(cls, nodegroup, network_name, vip_name):
@ -311,18 +205,16 @@ class NetworkManager(object):
None, if no VIP matches specificied criterias. None, if no VIP matches specificied criterias.
""" """
network = cls.get_network_by_name_and_nodegroup(network_name, network = objects.NetworkGroup.get_network_by_name_and_nodegroup(
nodegroup) network_name, nodegroup
)
cluster_vip_q = db().query(IPAddr).filter_by(vip_name=vip_name)
filter_args = {'vip_name': vip_name}
if network is not None: if network is not None:
cluster_vip_q = cluster_vip_q.filter_by(network=network.id) filter_args['network'] = network.id
cluster_vip = cluster_vip_q.first() return objects.IPAddrCollection.filter_by(
iterable=None, **filter_args).first()
if cluster_vip:
return cluster_vip
@classmethod @classmethod
def assign_vip(cls, nodegroup, network_name, vip_name): def assign_vip(cls, nodegroup, network_name, vip_name):
@ -349,8 +241,9 @@ class NetworkManager(object):
""" """
already_assigned = cls.get_assigned_vip(nodegroup, already_assigned = cls.get_assigned_vip(nodegroup,
network_name, vip_name) network_name, vip_name)
network = cls.get_network_by_name_and_nodegroup(network_name, network = objects.NetworkGroup.get_network_by_name_and_nodegroup(
nodegroup) network_name, nodegroup
)
if network is None: if network is None:
raise errors.CanNotFindNetworkForNodeGroup( raise errors.CanNotFindNetworkForNodeGroup(
@ -364,11 +257,9 @@ class NetworkManager(object):
network): network):
return already_assigned return already_assigned
cluster_vip = db().query(IPAddr).filter_by( cluster_vip = objects.IPAddrCollection.filter_by(
network=network.id, iterable=None, network=network.id,
node=None, node=None, vip_name=vip_name).first()
vip_name=vip_name
).first()
ips_in_use = None ips_in_use = None
@ -377,19 +268,18 @@ class NetworkManager(object):
# have an IP from the appropriate admin network assigned. # have an IP from the appropriate admin network assigned.
# So we much account for ALL admin IPs, not just the ones # So we much account for ALL admin IPs, not just the ones
# allocated in the current cluster. # allocated in the current cluster.
node_ips = db().query(Node.ip).all() node_ips = objects.Node.get_all_node_ips()
ips_in_use = set(ip[0] for ip in node_ips) ips_in_use = set(ip[0] for ip in node_ips)
# IP address has not been assigned, let's do it # IP address has not been assigned, let's do it
vip = cls.get_free_ips(network, ips_in_use=ips_in_use)[0] vip = cls.get_free_ips(network, ips_in_use=ips_in_use)[0]
vip_obj = IPAddr(network=network.id, ip_addr=vip, vip_name=vip_name) vip_obj = objects.IPAddr.create(
{'network': network.id, 'ip_addr': vip, 'vip_name': vip_name}
)
# delete stalled VIP address after new one was found. # delete stalled VIP address after new one was found.
if cluster_vip: if cluster_vip:
db().delete(cluster_vip) objects.IPAddr.delete(cluster_vip)
db().add(vip_obj)
db().flush()
return vip_obj return vip_obj
@ -430,6 +320,7 @@ class NetworkManager(object):
vips = defaultdict(dict) vips = defaultdict(dict)
for vip in cluster_vips: for vip in cluster_vips:
vips[vip.network_data.name][vip.vip_name] = vip.ip_addr vips[vip.network_data.name][vip.vip_name] = vip.ip_addr
return vips return vips
@classmethod @classmethod
@ -467,15 +358,14 @@ class NetworkManager(object):
cluster.id)) cluster.id))
if vip_name in assigned_vips_by_type: if vip_name in assigned_vips_by_type:
assigned_vip = assigned_vips_by_type[vip_name] assigned_vip = assigned_vips_by_type[vip_name]
assigned_vip.ip_addr = ip_addr objects.IPAddr.update(
assigned_vip, {'ip_addr': ip_addr})
else: else:
vip = IPAddr( objects.IPAddr.create(
network=net_group.id, {'network': net_group.id,
ip_addr=ip_addr, 'ip_addr': ip_addr,
vip_name=vip_name, 'vip_name': vip_name
) })
db().add(vip)
db().flush()
@classmethod @classmethod
def assign_vips_for_net_groups_for_api(cls, cluster, allocate=True): def assign_vips_for_net_groups_for_api(cls, cluster, allocate=True):
@ -516,23 +406,6 @@ class NetworkManager(object):
if ip_str not in ips_in_use: if ip_str not in ips_in_use:
yield ip_str yield ip_str
@classmethod
def check_ips_belong_to_admin_ranges(cls, ips):
"""Check if every provided IP belongs to any Admin networks' IP range.
:param ips: list of IPs (e.g. ['192.168.1.1', '127.0.0.1'], ...)
:return: *True* if all IPs belong to Admin ranges or *False* otherwise
"""
admin_ranges_db = db().query(
IPAddrRange.first,
IPAddrRange.last
).join(
NetworkGroup
).filter(
NetworkGroup.name == consts.NETWORKS.fuelweb_admin
)
return cls.check_ips_belong_to_ranges(ips, admin_ranges_db)
@classmethod @classmethod
def get_free_ips_from_ranges(cls, net_name, ip_ranges, ips_in_use, count): def get_free_ips_from_ranges(cls, net_name, ip_ranges, ips_in_use, count):
"""Gets the list of free IP addresses for given IP ranges. """Gets the list of free IP addresses for given IP ranges.
@ -558,11 +431,7 @@ class NetworkManager(object):
"Not enough free IP addresses in ranges [{0}] of '{1}' " "Not enough free IP addresses in ranges [{0}] of '{1}' "
"network".format(ranges_str, net_name)) "network".format(ranges_str, net_name))
ips_in_db = db().query( ips_in_db = objects.IPAddr.get_distinct_in_list(free_ips)
IPAddr.ip_addr.distinct()
).filter(
IPAddr.ip_addr.in_(free_ips)
)
for ip in ips_in_db: for ip in ips_in_db:
free_ips.remove(ip[0]) free_ips.remove(ip[0])
@ -586,36 +455,6 @@ class NetworkManager(object):
exc.network_id = network_group.id exc.network_id = network_group.id
raise raise
@classmethod
def _get_ips_except_admin(cls, node_id=None,
network_id=None, joined=False):
"""Receives IP addresses for node or network except Admin Network.
:param node_id: Node database ID.
:type node_id: int
:param network_id: Network database ID.
:type network_id: int
:returns: List of free IP addresses as SQLAlchemy objects.
"""
ips = db().query(IPAddr).order_by(IPAddr.id)
if joined:
ips = ips.options(joinedload('network_data'))
if node_id:
ips = ips.filter_by(node=node_id)
if network_id:
ips = ips.filter_by(network=network_id)
try:
admin_net_id = cls.get_admin_network_group_id(node_id=node_id)
except errors.AdminNetworkNotFound:
admin_net_id = None
if admin_net_id:
ips = ips.filter(
not_(IPAddr.network == admin_net_id)
)
return ips.all()
@classmethod @classmethod
def _get_pxe_iface_name(cls, node): def _get_pxe_iface_name(cls, node):
"""Returns appropriate pxe iface's name """Returns appropriate pxe iface's name
@ -658,21 +497,14 @@ class NetworkManager(object):
raise errors.CanNotFindInterface( raise errors.CanNotFindInterface(
'Cannot find PXE interface for node: {0}'.format(node.full_name)) 'Cannot find PXE interface for node: {0}'.format(node.full_name))
@classmethod
def clear_assigned_ips(cls, node):
db().query(IPAddr).filter_by(node=node.id).delete()
@classmethod @classmethod
def clear_assigned_networks(cls, node): def clear_assigned_networks(cls, node):
for nic in node.interfaces: for nic in node.interfaces:
while nic.assigned_networks_list: objects.NIC.assign_networks(nic, [])
nic.assigned_networks_list.pop()
db().flush()
@classmethod @classmethod
def clear_bond_configuration(cls, node): def clear_bond_configuration(cls, node):
for bond in node.bond_interfaces: objects.Bond.bulk_delete([bond.id for bond in node.bond_interfaces])
db().delete(bond)
@classmethod @classmethod
def get_default_interface_properties(cls): def get_default_interface_properties(cls):
@ -707,7 +539,8 @@ class NetworkManager(object):
objects.NetworkGroup.is_untagged, objects.NetworkGroup.is_untagged,
iface.assigned_networks_list)): iface.assigned_networks_list)):
continue continue
iface.assigned_networks_list.append(ng) assigned_nets = iface.assigned_networks_list + [ng]
objects.NIC.assign_networks(iface, assigned_nets)
break break
else: else:
logger.warning( logger.warning(
@ -716,8 +549,8 @@ class NetworkManager(object):
"interface %r", "interface %r",
ng.name, node.name, ifaces[0].name ng.name, node.name, ifaces[0].name
) )
ifaces[0].assigned_networks_list.append(ng) assigned_nets = ifaces[0].assigned_networks_list + [ng]
db().flush() objects.NIC.assign_networks(ifaces[0], assigned_nets)
@classmethod @classmethod
def get_default_interfaces_configuration(cls, node): def get_default_interfaces_configuration(cls, node):
@ -730,9 +563,10 @@ class NetworkManager(object):
nics = [] nics = []
group_id = (node.group_id or group_id = (node.group_id or
objects.Cluster.get_default_group(node.cluster).id) objects.Cluster.get_default_group(node.cluster).id)
node_group = db().query(NodeGroup).get(group_id) node_group = objects.NodeGroup.get_by_uid(group_id)
admin_net = objects.NetworkGroup.get_admin_network_group(node.id)
ngs = node_group.networks + [cls.get_admin_network_group(node.id)] ngs = node_group.networks + [admin_net]
ngs_by_id = dict((ng.id, ng) for ng in ngs) ngs_by_id = dict((ng.id, ng) for ng in ngs)
# sort Network Groups ids by map_priority # sort Network Groups ids by map_priority
to_assign_ids = list( to_assign_ids = list(
@ -743,7 +577,7 @@ class NetworkManager(object):
) )
ng_ids = set(ng.id for ng in ngs) ng_ids = set(ng.id for ng in ngs)
ng_wo_admin_ids = ng_ids.symmetric_difference( ng_wo_admin_ids = ng_ids.symmetric_difference(
[cls.get_admin_network_group_id(node.id)] [admin_net.id]
) )
pxe_iface = next(six.moves.filter( pxe_iface = next(six.moves.filter(
lambda i: i.pxe, lambda i: i.pxe,
@ -811,27 +645,10 @@ class NetworkManager(object):
for nic in def_set: for nic in def_set:
if 'assigned_networks' in nic: if 'assigned_networks' in nic:
ng_ids = [ng['id'] for ng in nic['assigned_networks']] ng_ids = [ng['id'] for ng in nic['assigned_networks']]
nics[nic['id']].assigned_networks_list = list( new_nets = list(
db().query(NetworkGroup).filter( objects.NetworkGroupCollection.filter_by_list(
NetworkGroup.id.in_(ng_ids))) None, 'id', ng_ids))
db().flush() objects.NIC.assign_networks(nics[nic['id']], new_nets)
@classmethod
def get_cluster_networkgroups_by_node(cls, node):
"""Method for receiving cluster network groups by node.
:param node: Node object.
:type node: Node
:returns: List of network groups for cluster node belongs to.
"""
if node.group_id:
return db().query(NetworkGroup).filter_by(
group_id=node.group_id,
).filter(
NetworkGroup.name != 'fuelweb_admin'
).order_by(NetworkGroup.id).all()
else:
return node.cluster.network_groups
@classmethod @classmethod
def get_node_networkgroups_ids(cls, node): def get_node_networkgroups_ids(cls, node):
@ -841,7 +658,7 @@ class NetworkManager(object):
@classmethod @classmethod
def _get_admin_node_network(cls, node): def _get_admin_node_network(cls, node):
net = cls.get_admin_network_group(node_id=node.id) net = objects.NetworkGroup.get_admin_network_group(node.id)
net_cidr = IPNetwork(net.cidr) net_cidr = IPNetwork(net.cidr)
ip_addr = cls.get_admin_ip_for_node(node.id) ip_addr = cls.get_admin_ip_for_node(node.id)
if ip_addr: if ip_addr:
@ -918,7 +735,7 @@ class NetworkManager(object):
@classmethod @classmethod
def _update_attrs(cls, node_data): def _update_attrs(cls, node_data):
node_db = db().query(Node).get(node_data['id']) node_db = objects.Node.get_by_uid(node_data['id'])
is_ether = lambda x: x['type'] == consts.NETWORK_INTERFACE_TYPES.ether is_ether = lambda x: x['type'] == consts.NETWORK_INTERFACE_TYPES.ether
is_bond = lambda x: x['type'] == consts.NETWORK_INTERFACE_TYPES.bond is_bond = lambda x: x['type'] == consts.NETWORK_INTERFACE_TYPES.bond
interfaces = filter(is_ether, node_data['interfaces']) interfaces = filter(is_ether, node_data['interfaces'])
@ -931,56 +748,49 @@ class NetworkManager(object):
interfaces_db interfaces_db
)[0] )[0]
# Remove all old network's assignment for this interface. # Remove all old network's assignment for this interface.
db().query(NetworkNICAssignment).filter_by( nets_to_assign = \
interface_id=current_iface.id [objects.NetworkGroup.get_by_uid(ng['id']) for ng
).delete() in iface['assigned_networks']]
objects.NIC.assign_networks(current_iface, nets_to_assign)
net_ids = [net['id'] for net in iface['assigned_networks']] update = {}
ngs = db().query(NetworkGroup).filter(
NetworkGroup.id.in_(net_ids)).all()
current_iface.assigned_networks_list.extend(ngs)
if 'interface_properties' in iface: if 'interface_properties' in iface:
current_iface.interface_properties = \ update['interface_properties'] = iface['interface_properties']
iface['interface_properties']
if 'offloading_modes' in iface: if 'offloading_modes' in iface:
current_iface.offloading_modes = \ update['offloading_modes'] = iface['offloading_modes']
iface['offloading_modes']
objects.NIC.update(current_iface, update)
objects.Node.clear_bonds(node_db)
node_db.bond_interfaces = []
for bond in bond_interfaces: for bond in bond_interfaces:
bond_db = NodeBondInterface()
bond_db.node = node_db
bond_db.name = bond['name']
if bond.get('bond_properties', {}).get('mode'): if bond.get('bond_properties', {}).get('mode'):
bond_db.mode = bond['bond_properties']['mode'] mode = bond['bond_properties']['mode']
else: else:
bond_db.mode = bond['mode'] mode = bond['mode']
bond_db.mac = bond.get('mac') data = {
bond_db.bond_properties = bond.get('bond_properties', {}) 'node': node_db,
bond_db.interface_properties = bond.get('interface_properties', {}) 'name': bond['name'],
'mode': mode,
'mac': bond.get('mac'),
'bond_properties': bond.get('bond_properties', {}),
'interface_properties': bond.get('interface_properties', {}),
}
bond_db = objects.Bond.create(data)
# Add new network assignment. # Add new network assignment.
net_ids = [net['id'] for net in bond['assigned_networks']] nets_to_assign = \
ngs = db().query(NetworkGroup).filter( [objects.NetworkGroup.get_by_uid(ng['id']) for ng
NetworkGroup.id.in_(net_ids)).all() in bond['assigned_networks']]
bond_db.assigned_networks_list.extend(ngs) objects.Bond.assign_networks(bond_db, nets_to_assign)
# Add new slaves. # Add new slaves.
for nic in bond['slaves']: node_nics = {nic['name']: nic for nic in node_db.nic_interfaces}
bond_db.slaves.append( slaves = [node_nics[n['name']] for n in bond['slaves']]
db().query(NodeNICInterface).filter_by(
name=nic['name']
).filter_by(
node_id=node_db.id
).first()
)
bond_db.offloading_modes = bond.get('offloading_modes', {}) update = {
'slaves': slaves,
'offloading_modes': bond.get('offloading_modes', {})
}
objects.Bond.update(bond_db, update)
db().add(bond_db)
db().flush()
return node_db.id return node_db.id
@classmethod @classmethod
@ -1053,12 +863,16 @@ class NetworkManager(object):
if iface_mapped: if iface_mapped:
# clear old Admin-pxe mapping # clear old Admin-pxe mapping
iface_mapped.assigned_networks_list = \ net_list = \
[n for n in iface_mapped.assigned_networks_list [n for n in iface_mapped.assigned_networks_list
if n.name != consts.NETWORKS.fuelweb_admin] if n.name != consts.NETWORKS.fuelweb_admin]
objects.NIC.assign_networks(iface_mapped, net_list)
iface_pxe.assigned_networks_list.append( iface_pxe.assigned_networks_list.append(
cls.get_admin_network_group(node.id)) objects.NetworkGroup.get_admin_network_group(node.id))
db().flush() objects.NIC.assign_networks(
iface_pxe, iface_pxe.assigned_networks_list
)
@classmethod @classmethod
def check_interfaces_correctness(cls, node): def check_interfaces_correctness(cls, node):
@ -1103,25 +917,29 @@ class NetworkManager(object):
@classmethod @classmethod
def is_ip_belongs_to_admin_subnet(cls, ip_addr, node_id=None): def is_ip_belongs_to_admin_subnet(cls, ip_addr, node_id=None):
admin_cidr = cls.get_admin_network_group(node_id).cidr admin_cidr = objects.NetworkGroup.get_admin_network_group(node_id).cidr
if ip_addr and IPAddress(ip_addr) in IPNetwork(admin_cidr): if ip_addr and IPAddress(ip_addr) in IPNetwork(admin_cidr):
return True return True
return False return False
@classmethod @classmethod
def __add_new_interface(cls, node, interface_attrs): def __add_new_interface(cls, node, interface_attrs):
interface = NodeNICInterface() data = {
interface.node_id = node.id 'node_id': node.id,
'mac': interface_attrs['mac'],
'name': interface_attrs['name']
}
interface = objects.NIC.create(data)
cls.__set_interface_attributes(interface, interface_attrs) cls.__set_interface_attributes(interface, interface_attrs)
db().add(interface) objects.NIC.update(interface, {})
db().flush()
@classmethod @classmethod
def __update_existing_interface(cls, interface, interface_attrs, def __update_existing_interface(cls, interface, interface_attrs,
update_by_agent=False): update_by_agent=False):
cls.__set_interface_attributes(interface, interface_attrs, cls.__set_interface_attributes(interface, interface_attrs,
update_by_agent) update_by_agent)
db().flush() objects.NIC.update(interface, {})
@classmethod @classmethod
def __set_interface_attributes(cls, interface, interface_attrs, def __set_interface_attributes(cls, interface, interface_attrs,
@ -1159,11 +977,9 @@ class NetworkManager(object):
interfaces_mac_addresses = map( interfaces_mac_addresses = map(
lambda interface: interface['mac'].lower(), interfaces) lambda interface: interface['mac'].lower(), interfaces)
interfaces_to_delete = db().query(NodeNICInterface).filter( interfaces_to_delete = \
NodeNICInterface.node_id == node.id objects.NICCollection.get_interfaces_not_in_mac_list(
).filter( node.id, interfaces_mac_addresses)
not_(NodeNICInterface.mac.in_(interfaces_mac_addresses))
).all()
if interfaces_to_delete: if interfaces_to_delete:
mac_addresses = ' '.join( mac_addresses = ' '.join(
@ -1173,52 +989,23 @@ class NetworkManager(object):
logger.info("Interfaces %s removed from node %s" % ( logger.info("Interfaces %s removed from node %s" % (
mac_addresses, node_name)) mac_addresses, node_name))
map(db().delete, interfaces_to_delete) objects.NIC.bulk_delete([i.id for i in interfaces_to_delete])
db().flush()
@classmethod @classmethod
def get_admin_ip_for_node(cls, node_id): def get_admin_ip_for_node(cls, node_id):
"""Returns first admin IP address for node.""" """Returns first admin IP address for node."""
admin_net_id = cls.get_admin_network_group_id(node_id=node_id) return objects.Node.get_admin_ip(node_id)
admin_ip = db().query(IPAddr).order_by(
IPAddr.id
).filter_by(
node=node_id
).filter_by(
network=admin_net_id
).first()
return getattr(admin_ip, 'ip_addr', None)
@classmethod @classmethod
def get_admin_ips_for_interfaces(cls, node): def get_admin_ips_for_interfaces(cls, node):
"""Returns mapping admin {"inteface name" => "admin ip"}.""" """Returns mapping admin {"inteface name" => "admin ip"}."""
admin_net_id = cls.get_admin_network_group_id(node) admin_ips = objects.Node.get_admin_ip(node.id)
admin_ips = set([
i.ip_addr for i in db().query(IPAddr).
order_by(IPAddr.id).
filter_by(node=node).
filter_by(network=admin_net_id)])
interfaces_names = sorted(set([ interfaces_names = sorted(set([
interface.name for interface in node.interfaces])) interface.name for interface in node.interfaces]))
return dict(zip(interfaces_names, admin_ips)) return dict(zip(interfaces_names, admin_ips))
@classmethod
def _get_admin_network(cls, node):
"""Returns dict with admin network."""
net = cls.get_admin_network_group(node_id=node)
return {
'id': net.id,
'cidr': net.cidr,
'name': net.name,
'gateway': net.gateway,
'vlan': net.vlan_start,
'dev': cls.get_admin_interface(node).name
}
@classmethod @classmethod
def get_admin_interface(cls, node): def get_admin_interface(cls, node):
try: try:
@ -1245,8 +1032,6 @@ class NetworkManager(object):
:return: Network device which has appointed network :return: Network device which has appointed network
with specified network name with specified network name
""" """
if not isinstance(node, Node):
node = db().query(Node).get(node)
for interface in node.interfaces: for interface in node.interfaces:
for network in interface.assigned_networks_list: for network in interface.assigned_networks_list:
if network.name == network_name: if network.name == network_name:
@ -1272,11 +1057,7 @@ class NetworkManager(object):
nodegroup = objects.Cluster.get_controllers_node_group(cluster_db) nodegroup = objects.Cluster.get_controllers_node_group(cluster_db)
ip = cls.assign_vip(nodegroup, consts.NETWORKS.public).ip_addr ip = cls.assign_vip(nodegroup, consts.NETWORKS.public).ip_addr
elif cluster_db.mode in ('singlenode', 'multinode'): elif cluster_db.mode in ('singlenode', 'multinode'):
controller = db().query(Node).filter_by( controller = objects.Cluster.get_single_controller(cluster_id)
cluster_id=cluster_id
).filter(
Node.roles.any('controller')
).first()
public_net = filter( public_net = filter(
lambda network: network['name'] == 'public', lambda network: network['name'] == 'public',
@ -1336,42 +1117,24 @@ class NetworkManager(object):
""" """
return range1.first <= range2.last and range2.first <= range1.last return range1.first <= range2.last and range2.first <= range1.last
@classmethod
def get_node_interface_by_netname(cls, node_id, netname):
iface = db().query(NodeNICInterface).join(
(NetworkGroup, NodeNICInterface.assigned_networks_list)
).filter(
NetworkGroup.name == netname
).filter(
NodeNICInterface.node_id == node_id
).first()
if iface:
return iface
return db().query(NodeBondInterface).join(
(NetworkGroup, NodeBondInterface.assigned_networks_list)
).filter(
NetworkGroup.name == netname
).filter(
NodeBondInterface.node_id == node_id
).first()
@classmethod @classmethod
def create_admin_network_group(cls, cluster_id, group_id): def create_admin_network_group(cls, cluster_id, group_id):
cluster_db = objects.Cluster.get_by_uid(cluster_id) cluster_db = objects.Cluster.get_by_uid(cluster_id)
admin_meta = copy.copy(cls.get_admin_network_group().meta) admin_ng = objects.NetworkGroup.get_admin_network_group()
admin_meta = dict(admin_ng.meta)
admin_meta['configurable'] = True admin_meta['configurable'] = True
new_admin = NetworkGroup( admin_meta['ip_range'] = ['9.9.9.2', '9.9.9.254']
release=cluster_db.release.id,
name='fuelweb_admin', data = {
cidr='9.9.9.0/24', 'release': cluster_db.release.id,
gateway='9.9.9.1', 'name': consts.NETWORKS.fuelweb_admin,
group_id=group_id, 'cidr': '9.9.9.0/24',
vlan_start=None, 'gateway': '9.9.9.1',
meta=admin_meta 'group_id': group_id,
) 'vlan_start': None,
db().add(new_admin) 'meta': admin_meta
db().flush() }
new_admin = objects.NetworkGroup.create(data)
objects.NetworkGroup._update_range_from_cidr( objects.NetworkGroup._update_range_from_cidr(
new_admin, new_admin.cidr, use_gateway=True) new_admin, new_admin.cidr, use_gateway=True)
@ -1483,11 +1246,7 @@ class NetworkManager(object):
# delete intersecting IPs # delete intersecting IPs
# TODO(akasatkin): need to reexamine deleting of IPs when # TODO(akasatkin): need to reexamine deleting of IPs when
# manual setting of IPs will be allowed # manual setting of IPs will be allowed
db.query(IPAddr).filter( objects.IPAddr.delete_by_network(network.gateway, network.id)
IPAddr.ip_addr == network.gateway,
IPAddr.network == network.id
).delete(synchronize_session='fetch')
db().flush()
@classmethod @classmethod
def create_network_groups(cls, cluster, neutron_segment_type, def create_network_groups(cls, cluster, neutron_segment_type,
@ -1522,7 +1281,7 @@ class NetworkManager(object):
def update_networks(cls, network_configuration): def update_networks(cls, network_configuration):
for ng in network_configuration.get('networks', []): for ng in network_configuration.get('networks', []):
ng_db = db().query(NetworkGroup).get(ng['id']) ng_db = objects.NetworkGroup.get_by_uid(ng['id'])
if 'meta' not in ng: if 'meta' not in ng:
# there are no restrictions on update process if # there are no restrictions on update process if
@ -1562,14 +1321,9 @@ class NetworkManager(object):
for key, value in network_configuration['networking_parameters'] \ for key, value in network_configuration['networking_parameters'] \
.items(): .items():
setattr(cluster.network_config, key, value) setattr(cluster.network_config, key, value)
db().flush()
@classmethod objects.Cluster.update(
def cluster_has_bonds(cls, cluster_id): cluster, {'network_config': cluster.network_config})
return db().query(Node).filter(
Node.cluster_id == cluster_id
).filter(
Node.bond_interfaces.any()).count() > 0
@classmethod @classmethod
def create_network_groups_and_config(cls, cluster, data): def create_network_groups_and_config(cls, cluster, data):
@ -1601,8 +1355,8 @@ class NetworkManager(object):
:param node_id: The ID of Node Object. :param node_id: The ID of Node Object.
:return: The GW from Admin network if it's set. else Admin IP :return: The GW from Admin network if it's set. else Admin IP
""" """
return cls.get_admin_network_group(node_id).gateway \ admin_net = objects.NetworkGroup.get_admin_network_group(node_id)
or settings.MASTER_IP return admin_net.gateway or settings.MASTER_IP
@classmethod @classmethod
def get_networks_not_on_node(cls, node, networks=None): def get_networks_not_on_node(cls, node, networks=None):
@ -1615,7 +1369,7 @@ class NetworkManager(object):
(n.name, n.cidr) (n.name, n.cidr)
for n in node.cluster.network_groups if n.cidr for n in node.cluster.network_groups if n.cidr
) )
admin_net = cls.get_admin_network_group() admin_net = objects.NetworkGroup.get_admin_network_group()
all_nets.add((admin_net.name, admin_net.cidr)) all_nets.add((admin_net.name, admin_net.cidr))
output = defaultdict(list) output = defaultdict(list)
@ -1699,23 +1453,14 @@ class NetworkManager(object):
@classmethod @classmethod
def get_assigned_ips_by_network_id(cls, network_id): def get_assigned_ips_by_network_id(cls, network_id):
"""Returns IPs related to network with provided ID.""" """Returns IPs related to network with provided ID."""
return [ return objects.NetworkGroup.get_assigned_ips(network_id)
x[0] for x in
db().query(IPAddr.ip_addr).filter(
IPAddr.network == network_id,
or_(IPAddr.node.isnot(None), IPAddr.vip_name.isnot(None))
)
]
@classmethod @classmethod
def get_admin_networks(cls, cluster_nodegroup_info=False): def get_admin_networks(cls, cluster_nodegroup_info=False):
admin_db = db().query( admin_dbs = objects.NetworkGroupCollection.filter_by(
NetworkGroup iterable=None, name=consts.NETWORKS.fuelweb_admin)
).filter_by(
name=consts.NETWORKS.fuelweb_admin
)
result = [] result = []
for net in admin_db: for net in admin_dbs:
net_info = { net_info = {
'id': net.id, 'id': net.id,
'cidr': net.cidr, 'cidr': net.cidr,
@ -1736,31 +1481,6 @@ class NetworkManager(object):
result.append(net_info) result.append(net_info)
return result return result
@classmethod
def get_network_by_name_and_nodegroup(cls, name, nodegroup):
"""Find a network that matches a specified name and a nodegroup.
:param name: Name of a network
:param nodegroup: The nodegroup object
:return: Network object that matches a specified name and a nodegroup.
Admin network, if nothing found.
"""
network = db().query(NetworkGroup).\
filter_by(name=name, group_id=nodegroup.id).first()
network = next((net for net in nodegroup.networks if net.name == name),
None)
# FIXME:
# Built-in fuelweb_admin network doesn't belong to any node
# group, since it's shared between all clusters. So we need
# to handle this very special case if we want to be able
# to allocate VIP in default admin network.
if not network and name == consts.NETWORKS.fuelweb_admin:
network = cls.get_admin_network_group()
return network
class AllocateVIPs70Mixin(object): class AllocateVIPs70Mixin(object):
@ -1866,9 +1586,7 @@ class AllocateVIPs70Mixin(object):
# VIPs to purge is modified inside the loop above # VIPs to purge is modified inside the loop above
# and may not contain elements at this point # and may not contain elements at this point
if vips_to_purge: if vips_to_purge:
db.query(IPAddr).filter( objects.IPAddr.bulk_delete(ip.id for ip in vips_to_purge)
IPAddr.id.in_([ip.id for ip in vips_to_purge])
).delete(synchronize_session='fetch')
@classmethod @classmethod
def _build_vip_info(cls, vip_info, vip_addr): def _build_vip_info(cls, vip_info, vip_addr):
@ -2178,18 +1896,7 @@ class AssignIPs70Mixin(object):
nodes_by_id = dict((n.id, n) for n in nodes) nodes_by_id = dict((n.id, n) for n in nodes)
query = ( query = objects.Cluster.get_network_groups_and_node_ids(cluster.id)
db().query(
Node.id,
NetworkGroup.id,
NetworkGroup.name,
NetworkGroup.meta)
.join(NodeGroup.nodes)
.join(NodeGroup.networks)
.filter(NodeGroup.cluster_id == cluster.id,
NetworkGroup.name != consts.NETWORKS.fuelweb_admin)
.order_by(NetworkGroup.id)
)
# Group by NetworkGroup.id # Group by NetworkGroup.id
for key, items in groupby(query, lambda x: x[1]): for key, items in groupby(query, lambda x: x[1]):

54
nailgun/nailgun/network/neutron.py
View File

@ -149,10 +149,7 @@ class NeutronManager70(
if not node.group_id: if not node.group_id:
return {} return {}
ngs = db().query(models.NetworkGroup, models.IPAddr.ip_addr).\ ngs = objects.Node.get_networks_ips(node)
filter(models.NetworkGroup.group_id == node.group_id). \
filter(models.IPAddr.network == models.NetworkGroup.id). \
filter(models.IPAddr.node == node.id)
if not ngs: if not ngs:
return {} return {}
@ -164,7 +161,7 @@ class NeutronManager70(
'meta': ng.meta, 'meta': ng.meta,
'gateway': ng.gateway 'gateway': ng.gateway
} }
admin_ng = cls.get_admin_network_group(node.id) admin_ng = objects.NetworkGroup.get_admin_network_group(node.id)
if admin_ng: if admin_ng:
networks[admin_ng.name] = { networks[admin_ng.name] = {
'ip': cls.get_ip_w_cidr_prefix_len( 'ip': cls.get_ip_w_cidr_prefix_len(
@ -242,12 +239,7 @@ class NeutronManager70(
@classmethod @classmethod
def assign_ips_in_node_group(cls, net_id, net_name, node_ids, ip_ranges): def assign_ips_in_node_group(cls, net_id, net_name, node_ids, ip_ranges):
"""Assigns IP addresses for nodes in given network.""" """Assigns IP addresses for nodes in given network."""
ips_by_node_id = db().query( ips_by_node_id = objects.IPAddr.get_by_node_for_network(net_id)
models.IPAddr.ip_addr,
models.IPAddr.node
).filter_by(
network=net_id
)
nodes_dont_need_ip = set() nodes_dont_need_ip = set()
ips_in_use = set() ips_in_use = set()
@ -270,11 +262,12 @@ class NeutronManager70(
net_name net_name
) )
) )
ip_db = models.IPAddr(node=node_id, new_ip = {
ip_addr=ip, 'node': node_id,
network=net_id) 'ip_addr': ip,
db().add(ip_db) 'network': net_id
db().flush() }
objects.IPAddr.create(new_ip)
@classmethod @classmethod
def assign_ips_for_nodes_w_template(cls, cluster, nodes): def assign_ips_for_nodes_w_template(cls, cluster, nodes):
@ -283,26 +276,8 @@ class NeutronManager70(
IPs for every node are allocated only for networks which are mapped IPs for every node are allocated only for networks which are mapped
to the particular node according to the template. to the particular node according to the template.
""" """
network_by_group = db().query( network_by_group = objects.NetworkGroup.get_by_cluster(cluster.id)
models.NetworkGroup.id, ip_ranges_by_network = objects.IPAddrRange.get_by_cluster(cluster.id)
models.NetworkGroup.name,
models.NetworkGroup.meta,
).join(
models.NetworkGroup.nodegroup
).filter(
models.NodeGroup.cluster_id == cluster.id,
models.NetworkGroup.name != consts.NETWORKS.fuelweb_admin
)
ip_ranges_by_network = db().query(
models.IPAddrRange.first,
models.IPAddrRange.last,
).join(
models.NetworkGroup.ip_ranges,
models.NetworkGroup.nodegroup
).filter(
models.NodeGroup.cluster_id == cluster.id
)
for group_id, nodes_in_group in itertools.groupby( for group_id, nodes_in_group in itertools.groupby(
nodes, lambda n: n.group_id): nodes, lambda n: n.group_id):
@ -430,7 +405,7 @@ class NeutronManager70(
# Default admin network has no node group # Default admin network has no node group
if network == consts.NETWORKS.fuelweb_admin: if network == consts.NETWORKS.fuelweb_admin:
net_db = cls.get_admin_network_group(node.id) net_db = objects.NetworkGroup.get_admin_network_group(node.id)
else: else:
net_db = objects.NetworkGroup.get_from_node_group_by_name( net_db = objects.NetworkGroup.get_from_node_group_by_name(
node.group_id, network) node.group_id, network)
@ -443,9 +418,8 @@ class NeutronManager70(
# Ensure network_group configuration is consistent # Ensure network_group configuration is consistent
# with the template # with the template
if vlan != net_db.vlan_start: if vlan != net_db.vlan_start:
net_db.vlan_start = vlan data = {'vlan_start': vlan}
db().add(net_db) objects.NetworkGroup.update(net_db, data)
db().flush()
ng = {'id': net_db.id} ng = {'id': net_db.id}
node_ifaces[iface]['assigned_networks'].append(ng) node_ifaces[iface]['assigned_networks'].append(ng)

1
nailgun/nailgun/objects/cluster.py
View File

@ -1392,6 +1392,7 @@ class Cluster(NailgunObject):
q = db().query(models.Node).filter_by(cluster_id=instance.id) q = db().query(models.Node).filter_by(cluster_id=instance.id)
return q.filter(models.Node.status != status).count() return q.filter(models.Node.status != status).count()
@classmethod
def get_network_groups_and_node_ids(cls, instance_id): def get_network_groups_and_node_ids(cls, instance_id):
"""Get network group information for the given cluster """Get network group information for the given cluster

1
nailgun/nailgun/objects/interface.py
View File

@ -40,6 +40,7 @@ class NIC(NailgunObject):
:returns: None :returns: None
""" """
instance.assigned_networks_list = networks instance.assigned_networks_list = networks
db().flush()
class NICCollection(NailgunCollection): class NICCollection(NailgunCollection):

29
nailgun/nailgun/objects/network_group.py
View File

@ -301,6 +301,35 @@ class NetworkGroup(NailgunObject):
for node in cluster.nodes: for node in cluster.nodes:
nm.assign_networks_by_template(node) nm.assign_networks_by_template(node)
@classmethod
def get_node_network_by_name(cls, node, network_name):
if network_name == consts.NETWORKS.fuelweb_admin:
return cls.get_admin_network_group(node.id)
else:
return cls.get_from_node_group_by_name(node.group_id, network_name)
@classmethod
def get_network_by_name_and_nodegroup(cls, name, nodegroup):
"""Find a network that matches a specified name and a nodegroup.
:param name: Name of a network
:param nodegroup: The nodegroup object
:return: Network object that matches a specified name and a nodegroup.
Admin network, if nothing found.
"""
network = cls.get_from_node_group_by_name(nodegroup.id, name)
# FIXME:
# Built-in fuelweb_admin network doesn't belong to any node
# group, since it's shared between all clusters. So we need
# to handle this very special case if we want to be able
# to allocate VIP in default admin network.
if not network and name == consts.NETWORKS.fuelweb_admin:
network = cls.get_admin_network_group()
return network
class NetworkGroupCollection(NailgunCollection): class NetworkGroupCollection(NailgunCollection):

10
nailgun/nailgun/objects/node.py
View File

@ -109,8 +109,14 @@ class Node(NailgunObject):
:param ips_by_network_name: dict :param ips_by_network_name: dict
:returns: None :returns: None
""" """
ngs = cls.get_networks_ips(instance) ngs = db().query(
ngs = ngs.filter(models.NetworkGroup.name.in_(ips_by_network_name)) models.NetworkGroup.name, models.IPAddr
).filter(
models.NetworkGroup.group_id == instance.group_id,
models.IPAddr.network == models.NetworkGroup.id,
models.IPAddr.node == instance.id,
models.NetworkGroup.name.in_(ips_by_network_name)
)
for ng_name, ip_addr in ngs: for ng_name, ip_addr in ngs:
ip_addr.ip_addr = ips_by_network_name[ng_name] ip_addr.ip_addr = ips_by_network_name[ng_name]
db().flush() db().flush()

1
nailgun/nailgun/objects/node_group.py
View File

@ -54,6 +54,7 @@ class NodeGroup(NailgunObject):
raise errors.CannotCreate(exc.message) raise errors.CannotCreate(exc.message)
db().flush() db().flush()
db().refresh(cluster)
return new_group return new_group

19
nailgun/nailgun/orchestrator/base_serializers.py
View File

@ -22,8 +22,7 @@ from netaddr import IPNetwork
from nailgun.db import db from nailgun.db import db
from nailgun.db.sqlalchemy.models import NetworkGroup from nailgun.db.sqlalchemy.models import NetworkGroup
from nailgun.errors import errors from nailgun.errors import errors
from nailgun.objects import Cluster from nailgun import objects
from nailgun.objects import Node
from nailgun.settings import settings from nailgun.settings import settings
@ -46,14 +45,14 @@ class MellanoxMixin(object):
:returns: None :returns: None
""" """
cluster_attrs = Cluster.get_editable_attributes(cluster) cluster_attrs = objects.Cluster.get_editable_attributes(cluster)
neutron_mellanox_data = cluster_attrs.get('neutron_mellanox', {}) neutron_mellanox_data = cluster_attrs.get('neutron_mellanox', {})
# We need to support mellanox for releases < 8.0. So if mellanox # We need to support mellanox for releases < 8.0. So if mellanox
# attributes exist (primary in old releases) then merge them with # attributes exist (primary in old releases) then merge them with
# common node attributes. # common node attributes.
if neutron_mellanox_data: if neutron_mellanox_data:
storage_data = cluster_attrs.get('storage', {}) storage_data = cluster_attrs.get('storage', {})
nm = Cluster.get_network_manager(cluster) nm = objects.Cluster.get_network_manager(cluster)
node_attrs['neutron_mellanox'] = {} node_attrs['neutron_mellanox'] = {}
# Find Physical port for VFs generation # Find Physical port for VFs generation
@ -166,7 +165,7 @@ class VmwareDeploymentSerializerMixin(object):
'cinder-vmware' 'cinder-vmware'
] ]
all_roles = Node.all_roles(node) all_roles = objects.Node.all_roles(node)
use_vcenter = node.cluster.attributes.editable.get('common', {}) \ use_vcenter = node.cluster.attributes.editable.get('common', {}) \
.get('use_vcenter', {}).get('value') .get('use_vcenter', {}).get('value')
@ -261,12 +260,12 @@ class NetworkDeploymentSerializer(object):
@classmethod @classmethod
def update_nodes_net_info(cls, cluster, nodes): def update_nodes_net_info(cls, cluster, nodes):
"""Adds information about networks to each node.""" """Adds information about networks to each node."""
for node in Cluster.get_nodes_not_for_deletion(cluster): for node in objects.Cluster.get_nodes_not_for_deletion(cluster):
netw_data = node.network_data netw_data = node.network_data
addresses = {} addresses = {}
for net in node.cluster.network_groups: for net in node.cluster.network_groups:
if net.name == 'public' and \ if net.name == 'public' and \
not Node.should_have_public_with_ip(node): not objects.Node.should_have_public_with_ip(node):
continue continue
if net.meta.get('render_addr_mask'): if net.meta.get('render_addr_mask'):
addresses.update(cls.get_addr_mask( addresses.update(cls.get_addr_mask(
@ -282,7 +281,7 @@ class NetworkDeploymentSerializer(object):
"""Cluster network attributes.""" """Cluster network attributes."""
common = cls.network_provider_cluster_attrs(cluster) common = cls.network_provider_cluster_attrs(cluster)
common.update( common.update(
cls.network_ranges(Cluster.get_default_group(cluster).id)) cls.network_ranges(objects.Cluster.get_default_group(cluster).id))
common.update({'master_ip': settings.MASTER_IP}) common.update({'master_ip': settings.MASTER_IP})
common['nodes'] = deepcopy(attrs['nodes']) common['nodes'] = deepcopy(attrs['nodes'])
@ -347,13 +346,13 @@ class NetworkDeploymentSerializer(object):
@staticmethod @staticmethod
def get_admin_ip_w_prefix(node): def get_admin_ip_w_prefix(node):
"""Getting admin ip and assign prefix from admin network.""" """Getting admin ip and assign prefix from admin network."""
network_manager = Cluster.get_network_manager(node.cluster) network_manager = objects.Cluster.get_network_manager(node.cluster)
admin_ip = network_manager.get_admin_ip_for_node(node.id) admin_ip = network_manager.get_admin_ip_for_node(node.id)
admin_ip = IPNetwork(admin_ip) admin_ip = IPNetwork(admin_ip)
# Assign prefix from admin network # Assign prefix from admin network
admin_net = IPNetwork( admin_net = IPNetwork(
network_manager.get_admin_network_group(node.id).cidr objects.NetworkGroup.get_admin_network_group(node.id).cidr
) )
admin_ip.prefixlen = admin_net.prefixlen admin_ip.prefixlen = admin_net.prefixlen

2
nailgun/nailgun/orchestrator/neutron_serializers.py
View File

@ -255,7 +255,7 @@ class NeutronNetworkDeploymentSerializer(
attrs['transformations'].append({ attrs['transformations'].append({
'action': 'add-patch', 'action': 'add-patch',
'bridges': [ 'bridges': [
'br-%s' % nm.get_node_interface_by_netname( 'br-%s' % objects.Node.get_interface_by_net_name(
node.id, node.id,
'private' 'private'
).name, ).name,

2
nailgun/nailgun/orchestrator/nova_serializers.py
View File

@ -85,7 +85,7 @@ class NovaNetworkDeploymentSerializer(NetworkDeploymentSerializer):
""" """
net_manager = Cluster.get_network_manager(node.cluster) net_manager = Cluster.get_network_manager(node.cluster)
fixed_interface = net_manager._get_interface_by_network_name( fixed_interface = net_manager._get_interface_by_network_name(
node.id, 'fixed') node, 'fixed')
attrs = {'fixed_interface': fixed_interface.name, attrs = {'fixed_interface': fixed_interface.name,
'vlan_interface': fixed_interface.name} 'vlan_interface': fixed_interface.name}

5
nailgun/nailgun/orchestrator/provisioning_serializers.py
View File

@ -179,9 +179,10 @@ class ProvisioningSerializer(MellanoxMixin):
cluster_attrs, serialized_node) cluster_attrs, serialized_node)
net_manager = objects.Cluster.get_network_manager(node.cluster) net_manager = objects.Cluster.get_network_manager(node.cluster)
gw = net_manager.get_default_gateway(node.id) gw = net_manager.get_default_gateway(node.id)
admin_net = objects.NetworkGroup.get_admin_network_group(node.id)
serialized_node['ks_meta'].update({'gw': gw}) serialized_node['ks_meta'].update({'gw': gw})
serialized_node['ks_meta'].update( serialized_node['ks_meta'].update(
{'admin_net': net_manager.get_admin_network_group(node.id).cidr} {'admin_net': admin_net.cidr}
) )
serialized_node.update(cls.serialize_interfaces(node)) serialized_node.update(cls.serialize_interfaces(node))
@ -195,7 +196,7 @@ class ProvisioningSerializer(MellanoxMixin):
net_manager = objects.Cluster.get_network_manager(node.cluster) net_manager = objects.Cluster.get_network_manager(node.cluster)
admin_ip = net_manager.get_admin_ip_for_node(node.id) admin_ip = net_manager.get_admin_ip_for_node(node.id)
admin_netmask = str(netaddr.IPNetwork( admin_netmask = str(netaddr.IPNetwork(
net_manager.get_admin_network_group(node.id).cidr objects.NetworkGroup.get_admin_network_group(node.id).cidr
).netmask) ).netmask)
for interface in node.nic_interfaces: for interface in node.nic_interfaces:

12
nailgun/nailgun/test/integration/test_cluster_changes_handler.py
View File

@ -248,7 +248,7 @@ class TestHandlers(BaseIntegrationTest):
deployment_msg['args']['post_deployment'] = [] deployment_msg['args']['post_deployment'] = []
provision_nodes = [] provision_nodes = []
admin_net = self.env.network_manager.get_admin_network_group() admin_net = objects.NetworkGroup.get_admin_network_group()
for n in sorted(self.env.nodes, key=lambda n: n.id): for n in sorted(self.env.nodes, key=lambda n: n.id):
udev_interfaces_mapping = ','.join( udev_interfaces_mapping = ','.join(
@ -306,7 +306,7 @@ class TestHandlers(BaseIntegrationTest):
'gw': 'gw':
self.env.network_manager.get_default_gateway(n.id), self.env.network_manager.get_default_gateway(n.id),
'admin_net': 'admin_net':
self.env.network_manager.get_admin_network_group(n.id).cidr objects.NetworkGroup.get_admin_network_group(n.id).cidr
} }
} }
@ -711,7 +711,7 @@ class TestHandlers(BaseIntegrationTest):
deployment_msg['args']['post_deployment'] = [] deployment_msg['args']['post_deployment'] = []
provision_nodes = [] provision_nodes = []
admin_net = self.env.network_manager.get_admin_network_group() admin_net = objects.NetworkGroup.get_admin_network_group()
for n in sorted(self.env.nodes, key=lambda n: n.id): for n in sorted(self.env.nodes, key=lambda n: n.id):
udev_interfaces_mapping = ','.join( udev_interfaces_mapping = ','.join(
@ -769,7 +769,7 @@ class TestHandlers(BaseIntegrationTest):
'gw': 'gw':
self.env.network_manager.get_default_gateway(n.id), self.env.network_manager.get_default_gateway(n.id),
'admin_net': 'admin_net':
self.env.network_manager.get_admin_network_group(n.id).cidr objects.NetworkGroup.get_admin_network_group(n.id).cidr
} }
} }
@ -1215,7 +1215,7 @@ class TestHandlers(BaseIntegrationTest):
deployment_msg['args']['post_deployment'] = [] deployment_msg['args']['post_deployment'] = []
provision_nodes = [] provision_nodes = []
admin_net = self.env.network_manager.get_admin_network_group() admin_net = objects.NetworkGroup.get_admin_network_group()
for n in sorted(self.env.nodes, key=lambda n: n.id): for n in sorted(self.env.nodes, key=lambda n: n.id):
udev_interfaces_mapping = ','.join( udev_interfaces_mapping = ','.join(
@ -1273,7 +1273,7 @@ class TestHandlers(BaseIntegrationTest):
'gw': 'gw':
self.env.network_manager.get_default_gateway(n.id), self.env.network_manager.get_default_gateway(n.id),
'admin_net': 'admin_net':
self.env.network_manager.get_admin_network_group(n.id).cidr objects.NetworkGroup.get_admin_network_group(n.id).cidr
} }
} }

62
nailgun/nailgun/test/integration/test_network_manager.py
View File

@ -259,7 +259,7 @@ class TestNetworkManager(BaseIntegrationTest):
self.assertEqual(needed_vip_ip, ip_before) self.assertEqual(needed_vip_ip, ip_before)
def test_vip_for_admin_network_is_free(self): def test_vip_for_admin_network_is_free(self):
admin_net_id = self.env.network_manager.get_admin_network_group_id() admin_net_id = objects.NetworkGroup.get_admin_network_group().id
self.db.query(IPAddrRange).filter_by( self.db.query(IPAddrRange).filter_by(
network_group_id=admin_net_id network_group_id=admin_net_id
).delete() ).delete()
@ -334,7 +334,7 @@ class TestNetworkManager(BaseIntegrationTest):
self.db().flush() self.db().flush()
admin_net =\ admin_net =\
self.env.network_manager.get_admin_network_group( objects.NetworkGroup.get_admin_network_group(
self.env.nodes[1].id self.env.nodes[1].id
) )
mock_range = IPAddrRange( mock_range = IPAddrRange(
@ -348,7 +348,7 @@ class TestNetworkManager(BaseIntegrationTest):
self.env.network_manager.assign_admin_ips(self.env.nodes) self.env.network_manager.assign_admin_ips(self.env.nodes)
for n in self.env.nodes: for n in self.env.nodes:
admin_net = self.env.network_manager.get_admin_network_group(n.id) admin_net = objects.NetworkGroup.get_admin_network_group(n.id)
ip = self.db.query(IPAddr).\ ip = self.db.query(IPAddr).\
filter_by(network=admin_net.id).\ filter_by(network=admin_net.id).\
filter_by(node=n.id).first() filter_by(node=n.id).first()
@ -416,9 +416,8 @@ class TestNetworkManager(BaseIntegrationTest):
for node in self.env.nodes: for node in self.env.nodes:
# if node_id is not passed to the method vips also will be # if node_id is not passed to the method vips also will be
# returned as they are assigned at the cretion of a cluster # returned as they are assigned at the cretion of a cluster
ip = self.env.network_manager._get_ips_except_admin( ip = objects.IPAddr.get_ips_except_admin(
node_id=node.id, node_id=node.id, include_network_data=True
joined=True
)[0] )[0]
ips.append(ip) ips.append(ip)
@ -434,7 +433,7 @@ class TestNetworkManager(BaseIntegrationTest):
def test_assign_admin_ips(self): def test_assign_admin_ips(self):
node = self.env.create_node() node = self.env.create_node()
self.env.network_manager.assign_admin_ips([node]) self.env.network_manager.assign_admin_ips([node])
admin_ng_id = self.env.network_manager.get_admin_network_group_id() admin_ng_id = objects.NetworkGroup.get_admin_network_group().id
admin_network_range = self.db.query(IPAddrRange).\ admin_network_range = self.db.query(IPAddrRange).\
filter_by(network_group_id=admin_ng_id).all()[0] filter_by(network_group_id=admin_ng_id).all()[0]
@ -449,7 +448,7 @@ class TestNetworkManager(BaseIntegrationTest):
def test_assign_admin_ips_idempotent(self): def test_assign_admin_ips_idempotent(self):
node = self.env.create_node() node = self.env.create_node()
self.env.network_manager.assign_admin_ips([node]) self.env.network_manager.assign_admin_ips([node])
admin_net_id = self.env.network_manager.get_admin_network_group_id() admin_net_id = objects.NetworkGroup.get_admin_network_group().id
admin_ips = set([i.ip_addr for i in self.db.query(IPAddr). admin_ips = set([i.ip_addr for i in self.db.query(IPAddr).
filter_by(node=node.id). filter_by(node=node.id).
filter_by(network=admin_net_id).all()]) filter_by(network=admin_net_id).all()])
@ -461,7 +460,7 @@ class TestNetworkManager(BaseIntegrationTest):
def test_assign_admin_ips_only_one(self): def test_assign_admin_ips_only_one(self):
map(self.db.delete, self.db.query(IPAddrRange).all()) map(self.db.delete, self.db.query(IPAddrRange).all())
admin_net_id = self.env.network_manager.get_admin_network_group_id() admin_net_id = objects.NetworkGroup.get_admin_network_group().id
mock_range = IPAddrRange( mock_range = IPAddrRange(
first='10.0.0.1', first='10.0.0.1',
last='10.0.0.1', last='10.0.0.1',
@ -473,7 +472,7 @@ class TestNetworkManager(BaseIntegrationTest):
node = self.env.create_node() node = self.env.create_node()
self.env.network_manager.assign_admin_ips([node]) self.env.network_manager.assign_admin_ips([node])
admin_net_id = self.env.network_manager.get_admin_network_group_id() admin_net_id = objects.NetworkGroup.get_admin_network_group().id
admin_ips = self.db.query(IPAddr).\ admin_ips = self.db.query(IPAddr).\
filter_by(node=node.id).\ filter_by(node=node.id).\
@ -483,7 +482,7 @@ class TestNetworkManager(BaseIntegrationTest):
def test_assign_admin_ips_for_many_nodes(self): def test_assign_admin_ips_for_many_nodes(self):
map(self.db.delete, self.db.query(IPAddrRange).all()) map(self.db.delete, self.db.query(IPAddrRange).all())
admin_net_id = self.env.network_manager.get_admin_network_group_id() admin_net_id = objects.NetworkGroup.get_admin_network_group().id
mock_range = IPAddrRange( mock_range = IPAddrRange(
first='10.0.0.1', first='10.0.0.1',
last='10.0.0.2', last='10.0.0.2',
@ -497,7 +496,7 @@ class TestNetworkManager(BaseIntegrationTest):
nc = [n1, n2] nc = [n1, n2]
self.env.network_manager.assign_admin_ips(nc) self.env.network_manager.assign_admin_ips(nc)
admin_net_id = self.env.network_manager.get_admin_network_group_id() admin_net_id = objects.NetworkGroup.get_admin_network_group().id
for node, ip in zip(nc, ['10.0.0.1', '10.0.0.2']): for node, ip in zip(nc, ['10.0.0.1', '10.0.0.2']):
admin_ips = self.db.query(IPAddr).\ admin_ips = self.db.query(IPAddr).\
@ -516,7 +515,7 @@ class TestNetworkManager(BaseIntegrationTest):
(ip.network_data.name, ip.ip_addr) for ip in node.ip_addrs (ip.network_data.name, ip.ip_addr) for ip in node.ip_addrs
) )
self.assertEquals(node_net_ips, self.assertEquals(node_net_ips,
self.env.network_manager.get_node_networks_ips(node)) objects.Node.get_networks_ips_dict(node))
def test_set_node_networks_ips(self): def test_set_node_networks_ips(self):
cluster = self.env.create_cluster(api=False) cluster = self.env.create_cluster(api=False)
@ -527,20 +526,19 @@ class TestNetworkManager(BaseIntegrationTest):
node_net_ips = \ node_net_ips = \
dict((net.name, self.env.network_manager.get_free_ips(net)[0]) dict((net.name, self.env.network_manager.get_free_ips(net)[0])
for net in node.networks) for net in node.networks)
self.env.network_manager.set_node_networks_ips(node, node_net_ips) objects.Node.set_networks_ips(node, node_net_ips)
self.assertEquals(node_net_ips, self.assertEquals(node_net_ips,
self.env.network_manager.get_node_networks_ips(node)) objects.Node.get_networks_ips_dict(node))
def test_set_node_netgroups_ids(self): def test_set_netgroups_ids(self):
cluster = self.env.create_cluster(api=False) cluster = self.env.create_cluster(api=False)
node = self.env.create_node(cluster_id=cluster.id) node = self.env.create_node(cluster_id=cluster.id)
self.env.network_manager.assign_ips( self.env.network_manager.assign_ips(
cluster, [node], consts.NETWORKS.management cluster, [node], consts.NETWORKS.management
) )
admin_ng_id = \ admin_ng_id = objects.NetworkGroup.get_admin_network_group(node.id).id
self.env.network_manager.get_admin_network_group_id(node.id)
node_ng_ids = dict((ip.network, admin_ng_id) for ip in node.ip_addrs) node_ng_ids = dict((ip.network, admin_ng_id) for ip in node.ip_addrs)
self.env.network_manager.set_node_netgroups_ids(node, node_ng_ids) objects.Node.set_netgroups_ids(node, node_ng_ids)
for ip in node.ip_addrs: for ip in node.ip_addrs:
self.assertEquals(admin_ng_id, ip.network) self.assertEquals(admin_ng_id, ip.network)
@ -551,12 +549,11 @@ class TestNetworkManager(BaseIntegrationTest):
cluster, [node], consts.NETWORKS.management cluster, [node], consts.NETWORKS.management
) )
admin_ng_id = \ admin_ng_id = \
self.env.network_manager.get_admin_network_group_id(node.id) objects.NetworkGroup.get_admin_network_group(node.id).id
nic_ng_ids = \ nic_ng_ids = \
dict((net.id, admin_ng_id) for iface in node.nic_interfaces dict((net.id, admin_ng_id) for iface in node.nic_interfaces
for net in iface.assigned_networks_list) for net in iface.assigned_networks_list)
self.env.network_manager.set_nic_assignment_netgroups_ids(node, objects.Node.set_nic_assignment_netgroups_ids(node, nic_ng_ids)
nic_ng_ids)
self.db.refresh(node) self.db.refresh(node)
for iface in node.nic_interfaces: for iface in node.nic_interfaces:
for net in iface.assigned_networks_list: for net in iface.assigned_networks_list:
@ -581,12 +578,11 @@ class TestNetworkManager(BaseIntegrationTest):
}] }]
}) })
admin_ng_id = \ admin_ng_id = \
self.env.network_manager.get_admin_network_group_id(node.id) objects.NetworkGroup.get_admin_network_group(node.id).id
bond_ng_ids = \ bond_ng_ids = \
dict((net.id, admin_ng_id) for iface in node.bond_interfaces dict((net.id, admin_ng_id) for iface in node.bond_interfaces
for net in iface.assigned_networks_list) for net in iface.assigned_networks_list)
self.env.network_manager.set_bond_assignment_netgroups_ids(node, objects.Node.set_bond_assignment_netgroups_ids(node, bond_ng_ids)
bond_ng_ids)
self.db.refresh(node) self.db.refresh(node)
for iface in node.bond_interfaces: for iface in node.bond_interfaces:
for net in iface.assigned_networks_list: for net in iface.assigned_networks_list:
@ -793,7 +789,7 @@ class TestNetworkManager(BaseIntegrationTest):
rpc_nodes_provision = nailgun.task.manager.rpc.cast. \ rpc_nodes_provision = nailgun.task.manager.rpc.cast. \
call_args_list[0][0][1][0]['args']['provisioning_info']['nodes'] call_args_list[0][0][1][0]['args']['provisioning_info']['nodes']
admin_ng_id = self.env.network_manager.get_admin_network_group_id() admin_ng_id = objects.NetworkGroup.get_admin_network_group().id
admin_network_range = self.db.query(IPAddrRange).\ admin_network_range = self.db.query(IPAddrRange).\
filter_by(network_group_id=admin_ng_id).all()[0] filter_by(network_group_id=admin_ng_id).all()[0]
@ -877,6 +873,20 @@ class TestNetworkManager(BaseIntegrationTest):
self.assertEqual(len(filter(lambda ng: ng.name == 'restricted_net', self.assertEqual(len(filter(lambda ng: ng.name == 'restricted_net',
cluster.network_groups)), 0) cluster.network_groups)), 0)
def test_clear_assigned_networks(self):
self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"pending_addition": True, "api": True},
]
)
node = self.env.nodes[0]
self.env.network_manager.clear_assigned_networks(node)
for iface in node.interfaces:
self.assertEqual([], iface.assigned_networks_list)
class TestNovaNetworkManager(BaseIntegrationTest): class TestNovaNetworkManager(BaseIntegrationTest):

7
nailgun/nailgun/test/integration/test_network_validation.py
View File

@ -27,6 +27,7 @@ from nailgun.db.sqlalchemy.models import NeutronConfig
from nailgun.db.sqlalchemy.models import NovaNetworkConfig from nailgun.db.sqlalchemy.models import NovaNetworkConfig
from nailgun.errors import errors from nailgun.errors import errors
from nailgun.network.checker import NetworkCheck from nailgun.network.checker import NetworkCheck
from nailgun import objects
from nailgun.test.base import BaseIntegrationTest from nailgun.test.base import BaseIntegrationTest
@ -120,7 +121,7 @@ class TestNovaHandlers(TestNetworkChecking):
self.assertEqual(len(ngs_created), len(self.nets['networks'])) self.assertEqual(len(ngs_created), len(self.nets['networks']))
def test_network_checking_fails_if_admin_intersection(self): def test_network_checking_fails_if_admin_intersection(self):
admin_ng = self.env.network_manager.get_admin_network_group() admin_ng = objects.NetworkGroup.get_admin_network_group()
self.nets['networking_parameters']["fixed_networks_cidr"] = \ self.nets['networking_parameters']["fixed_networks_cidr"] = \
admin_ng.cidr admin_ng.cidr
@ -132,7 +133,7 @@ class TestNovaHandlers(TestNetworkChecking):
self.assertIn("fixed", task['message']) self.assertIn("fixed", task['message'])
def test_network_checking_fails_if_admin_intersection_ip_range(self): def test_network_checking_fails_if_admin_intersection_ip_range(self):
admin_ng = self.env.network_manager.get_admin_network_group() admin_ng = objects.NetworkGroup.get_admin_network_group()
cidr = IPNetwork(admin_ng.cidr) cidr = IPNetwork(admin_ng.cidr)
flt_r0 = str(IPAddress(cidr.first + 2)) flt_r0 = str(IPAddress(cidr.first + 2))
flt_r1 = str(IPAddress(cidr.last)) flt_r1 = str(IPAddress(cidr.last))
@ -418,7 +419,7 @@ class TestNeutronHandlersGre(TestNetworkChecking):
# network to the Admin interface. # network to the Admin interface.
def test_network_checking_fails_if_admin_intersection(self): def test_network_checking_fails_if_admin_intersection(self):
admin_ng = self.env.network_manager.get_admin_network_group() admin_ng = objects.NetworkGroup.get_admin_network_group()
self.find_net_by_name('storage')["cidr"] = admin_ng.cidr self.find_net_by_name('storage')["cidr"] = admin_ng.cidr
task = self.update_neutron_networks_w_error(self.cluster.id, self.nets) task = self.update_neutron_networks_w_error(self.cluster.id, self.nets)

3
nailgun/nailgun/test/integration/test_node_handler.py
View File

@ -336,8 +336,7 @@ class TestHandlers(BaseIntegrationTest):
self.assertRegexpMatches(notif.message, self.assertRegexpMatches(notif.message,
"that does not match any Admin network") "that does not match any Admin network")
nm = objects.Cluster.get_network_manager(node.cluster) admin_ng = objects.NetworkGroup.get_admin_network_group(node.id)
admin_ng = nm.get_admin_network_group(node.id)
ipaddress = str(netaddr.IPRange(admin_ng.ip_ranges[0].first, ipaddress = str(netaddr.IPRange(admin_ng.ip_ranges[0].first,
admin_ng.ip_ranges[0].last)[1]) admin_ng.ip_ranges[0].last)[1])
self.app.put( self.app.put(

4
nailgun/nailgun/test/integration/test_node_nic_assignment.py
View File

@ -464,7 +464,7 @@ class TestNodeNICAdminAssigning(BaseIntegrationTest):
def test_admin_nic_and_ip_assignment(self): def test_admin_nic_and_ip_assignment(self):
cluster = self.env.create_cluster(api=True) cluster = self.env.create_cluster(api=True)
admin_ng = self.env.network_manager.get_admin_network_group() admin_ng = objects.NetworkGroup.get_admin_network_group()
admin_ip = str(IPNetwork(admin_ng.cidr)[0]) admin_ip = str(IPNetwork(admin_ng.cidr)[0])
mac1, mac2 = (self.env.generate_random_mac(), mac1, mac2 = (self.env.generate_random_mac(),
self.env.generate_random_mac()) self.env.generate_random_mac())
@ -517,7 +517,7 @@ class TestNodePublicNetworkToNICAssignment(BaseIntegrationTest):
def create_node_and_check_assignment(self): def create_node_and_check_assignment(self):
meta = self.env.default_metadata() meta = self.env.default_metadata()
admin_ip = str(IPNetwork( admin_ip = str(IPNetwork(
self.env.network_manager.get_admin_network_group().cidr)[1]) objects.NetworkGroup.get_admin_network_group().cidr)[1])
admin_mac = self.env.generate_random_mac() admin_mac = self.env.generate_random_mac()
meta['interfaces'] = [ meta['interfaces'] = [
{'name': 'eth3', 'mac': self.env.generate_random_mac()}, {'name': 'eth3', 'mac': self.env.generate_random_mac()},

2
nailgun/nailgun/test/integration/test_verify_networks_task_manager.py
View File

@ -74,7 +74,7 @@ class TestVerifyNetworkTaskManagers(BaseIntegrationTest):
self.assertEqual(200, resp.status_code) self.assertEqual(200, resp.status_code)
nets = resp.json_body nets = resp.json_body
admin_ng = self.env.network_manager.get_admin_network_group() admin_ng = objects.NetworkGroup.get_admin_network_group()
# find first non-admin network # find first non-admin network
network = next(( network = next((

4
nailgun/nailgun/test/unit/test_network_group_handler.py
View File

@ -171,7 +171,7 @@ class TestHandlers(BaseIntegrationTest):
self.assertFalse(ips_db) self.assertFalse(ips_db)
def test_cannot_delete_admin_network_group(self): def test_cannot_delete_admin_network_group(self):
admin = objects.Cluster.get_network_manager().get_admin_network_group() admin = objects.NetworkGroup.get_admin_network_group()
resp = self.app.delete( resp = self.app.delete(
reverse( reverse(
'NetworkGroupHandler', 'NetworkGroupHandler',
@ -419,7 +419,7 @@ class TestHandlers(BaseIntegrationTest):
'Network release could not be changed.') 'Network release could not be changed.')
def test_modify_admin_network_group_with_wrong_group_id(self): def test_modify_admin_network_group_with_wrong_group_id(self):
admin = objects.Cluster.get_network_manager().get_admin_network_group() admin = objects.NetworkGroup.get_admin_network_group()
admin_network_data = { admin_network_data = {
'id': admin.id, 'id': admin.id,
'group_id': objects.Cluster.get_default_group(self.cluster).id, 'group_id': objects.Cluster.get_default_group(self.cluster).id,