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)
def get_admin_network_group(self):
manager = self.get_network_manager()
return manager.get_admin_network_group()
return objects.NetworkGroup.get_admin_network_group()
class NailgunReleaseAdapter(object):
@ -125,18 +124,18 @@ class NailgunNetworkManager(object):
self.net_manager.assign_given_vips_for_net_groups(self.cluster, vips)
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)
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):
return self.net_manager.set_nic_assignment_netgroups_ids(
return objects.Node.set_nic_assignment_netgroups_ids(
node.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)

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

@ -20,6 +20,7 @@ from distutils import version
import six
from nailgun import consts
from nailgun import objects
from nailgun.objects.serializers import network_configuration
from nailgun import utils
@ -173,13 +174,12 @@ class UpgradeHelper(object):
node.cluster_id)
orig_manager = orig_cluster.get_network_manager()
seed_manager = seed_cluster.get_network_manager()
netgroups_id_mapping = cls.get_netgroups_id_mapping(
orig_cluster, 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(
node, netgroups_id_mapping)
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
from nailgun import consts
from nailgun.db.sqlalchemy import models
from nailgun.errors import errors
from nailgun.logger import logger
from nailgun import objects
@ -44,8 +43,8 @@ class NetworkCheck(object):
self.data = data
self.net_man = objects.Cluster.get_network_manager(self.cluster)
self.net_provider = self.cluster.net_provider
admin_ng = self.net_man.get_admin_network_group()
fields = models.NetworkGroup.__mapper__.columns.keys() + ['meta']
admin_ng = objects.NetworkGroup.get_admin_network_group()
fields = objects.NetworkGroup.fields()
net = NetworkConfigurationSerializer.serialize_network_group(admin_ng,
fields)
# 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 IPRange
import copy
import six
from sqlalchemy.orm import joinedload
from sqlalchemy.sql import not_
from sqlalchemy.sql import or_
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.logger import logger
from nailgun.network import utils
@ -74,38 +59,6 @@ class NetworkManager(object):
"""
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
def reusable_ip_address(cls, node, network):
"""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
"""
if node.ip and cls.check_ip_belongs_to_net(node.ip, network):
return IPAddr(node=node.id,
ip_addr=node.ip,
network=network.id)
return objects.IPAddr.create(
{'network': network.id, 'ip_addr': node.ip, 'node': node.id}
)
return None
@classmethod
@ -135,73 +89,20 @@ class NetworkManager(object):
nodes_need_ips = defaultdict(list)
for node in nodes:
node_id = node.id
admin_net = cls.get_admin_network_group(node_id)
node_admin_ips = db().query(IPAddr).filter_by(
node=node_id, network=admin_net.id)
admin_net = objects.NetworkGroup.get_admin_network_group(node_id)
node_admin_ips_count = objects.Node.get_network_ips_count(
node_id, admin_net.id)
logger.debug(u"Trying to assign admin ip: node=%s", node_id)
if not db().query(node_admin_ips.exists()).scalar():
reusable_ip = cls.reusable_ip_address(node, admin_net)
if reusable_ip:
db().add(reusable_ip)
else:
if not node_admin_ips_count:
if not cls.reusable_ip_address(node, admin_net):
nodes_need_ips[admin_net].append(node_id)
db().flush()
for admin_net, nodes in six.iteritems(nodes_need_ips):
free_ips = cls.get_free_ips(admin_net, len(nodes))
for ip, n in zip(free_ips, nodes):
ip_db = IPAddr(node=n,
ip_addr=ip,
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()
for ip, n in six.moves.zip(free_ips, nodes):
objects.IPAddr.create(
{'network': admin_net.id, 'ip_addr': ip, 'node': n}
)
@classmethod
def assign_ips(cls, cluster, nodes, network_name):
@ -222,8 +123,8 @@ class NetworkManager(object):
:returns: None
:raises: Exception, errors.AssignIPError
"""
network_groups = db().query(NetworkGroup).\
filter_by(name=network_name)
network_groups = objects.NetworkGroupCollection.filter_by(
iterable=cluster.network_groups, name=network_name)
if not network_groups:
raise errors.AssignIPError(
@ -246,19 +147,14 @@ class NetworkManager(object):
if network_name == 'public' and \
not objects.Node.should_have_public_with_ip(node):
continue
group_id = node.group_id or \
objects.Cluster.get_default_group(node.cluster).id
network = network_groups.filter(
or_(
NetworkGroup.group_id == group_id,
NetworkGroup.group_id.is_(None)
)
).first()
network = objects.NetworkGroup.get_node_network_by_name(
node, network_name
)
node_ips = six.moves.map(
lambda i: i.ip_addr,
cls._get_ips_except_admin(
objects.IPAddr.get_ips_except_admin(
node_id=node_id,
network_id=network.id
)
@ -294,11 +190,9 @@ class NetworkManager(object):
network_name
)
)
ip_db = IPAddr(node=n,
ip_addr=ip,
network=network.id)
db().add(ip_db)
db().flush()
objects.IPAddr.create(
{'network': network.id, 'ip_addr': ip, 'node': n}
)
@classmethod
def get_assigned_vip(cls, nodegroup, network_name, vip_name):
@ -311,18 +205,16 @@ class NetworkManager(object):
None, if no VIP matches specificied criterias.
"""
network = cls.get_network_by_name_and_nodegroup(network_name,
nodegroup)
cluster_vip_q = db().query(IPAddr).filter_by(vip_name=vip_name)
network = objects.NetworkGroup.get_network_by_name_and_nodegroup(
network_name, nodegroup
)
filter_args = {'vip_name': vip_name}
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()
if cluster_vip:
return cluster_vip
return objects.IPAddrCollection.filter_by(
iterable=None, **filter_args).first()
@classmethod
def assign_vip(cls, nodegroup, network_name, vip_name):
@ -349,8 +241,9 @@ class NetworkManager(object):
"""
already_assigned = cls.get_assigned_vip(nodegroup,
network_name, vip_name)
network = cls.get_network_by_name_and_nodegroup(network_name,
nodegroup)
network = objects.NetworkGroup.get_network_by_name_and_nodegroup(
network_name, nodegroup
)
if network is None:
raise errors.CanNotFindNetworkForNodeGroup(
@ -364,11 +257,9 @@ class NetworkManager(object):
network):
return already_assigned
cluster_vip = db().query(IPAddr).filter_by(
network=network.id,
node=None,
vip_name=vip_name
).first()
cluster_vip = objects.IPAddrCollection.filter_by(
iterable=None, network=network.id,
node=None, vip_name=vip_name).first()
ips_in_use = None
@ -377,19 +268,18 @@ class NetworkManager(object):
# have an IP from the appropriate admin network assigned.
# So we much account for ALL admin IPs, not just the ones
# 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)
# IP address has not been assigned, let's do it
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.
if cluster_vip:
db().delete(cluster_vip)
db().add(vip_obj)
db().flush()
objects.IPAddr.delete(cluster_vip)
return vip_obj
@ -430,6 +320,7 @@ class NetworkManager(object):
vips = defaultdict(dict)
for vip in cluster_vips:
vips[vip.network_data.name][vip.vip_name] = vip.ip_addr
return vips
@classmethod
@ -467,15 +358,14 @@ class NetworkManager(object):
cluster.id))
if vip_name in assigned_vips_by_type:
assigned_vip = assigned_vips_by_type[vip_name]
assigned_vip.ip_addr = ip_addr
objects.IPAddr.update(
assigned_vip, {'ip_addr': ip_addr})
else:
vip = IPAddr(
network=net_group.id,
ip_addr=ip_addr,
vip_name=vip_name,
)
db().add(vip)
db().flush()
objects.IPAddr.create(
{'network': net_group.id,
'ip_addr': ip_addr,
'vip_name': vip_name
})
@classmethod
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:
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
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.
@ -558,11 +431,7 @@ class NetworkManager(object):
"Not enough free IP addresses in ranges [{0}] of '{1}' "
"network".format(ranges_str, net_name))
ips_in_db = db().query(
IPAddr.ip_addr.distinct()
).filter(
IPAddr.ip_addr.in_(free_ips)
)
ips_in_db = objects.IPAddr.get_distinct_in_list(free_ips)
for ip in ips_in_db:
free_ips.remove(ip[0])
@ -586,36 +455,6 @@ class NetworkManager(object):
exc.network_id = network_group.id
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
def _get_pxe_iface_name(cls, node):
"""Returns appropriate pxe iface's name
@ -658,21 +497,14 @@ class NetworkManager(object):
raise errors.CanNotFindInterface(
'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
def clear_assigned_networks(cls, node):
for nic in node.interfaces:
while nic.assigned_networks_list:
nic.assigned_networks_list.pop()
db().flush()
objects.NIC.assign_networks(nic, [])
@classmethod
def clear_bond_configuration(cls, node):
for bond in node.bond_interfaces:
db().delete(bond)
objects.Bond.bulk_delete([bond.id for bond in node.bond_interfaces])
@classmethod
def get_default_interface_properties(cls):
@ -707,7 +539,8 @@ class NetworkManager(object):
objects.NetworkGroup.is_untagged,
iface.assigned_networks_list)):
continue
iface.assigned_networks_list.append(ng)
assigned_nets = iface.assigned_networks_list + [ng]
objects.NIC.assign_networks(iface, assigned_nets)
break
else:
logger.warning(
@ -716,8 +549,8 @@ class NetworkManager(object):
"interface %r",
ng.name, node.name, ifaces[0].name
)
ifaces[0].assigned_networks_list.append(ng)
db().flush()
assigned_nets = ifaces[0].assigned_networks_list + [ng]
objects.NIC.assign_networks(ifaces[0], assigned_nets)
@classmethod
def get_default_interfaces_configuration(cls, node):
@ -730,9 +563,10 @@ class NetworkManager(object):
nics = []
group_id = (node.group_id or
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)
# sort Network Groups ids by map_priority
to_assign_ids = list(
@ -743,7 +577,7 @@ class NetworkManager(object):
)
ng_ids = set(ng.id for ng in ngs)
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(
lambda i: i.pxe,
@ -811,27 +645,10 @@ class NetworkManager(object):
for nic in def_set:
if 'assigned_networks' in nic:
ng_ids = [ng['id'] for ng in nic['assigned_networks']]
nics[nic['id']].assigned_networks_list = list(
db().query(NetworkGroup).filter(
NetworkGroup.id.in_(ng_ids)))
db().flush()
@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
new_nets = list(
objects.NetworkGroupCollection.filter_by_list(
None, 'id', ng_ids))
objects.NIC.assign_networks(nics[nic['id']], new_nets)
@classmethod
def get_node_networkgroups_ids(cls, node):
@ -841,7 +658,7 @@ class NetworkManager(object):
@classmethod
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)
ip_addr = cls.get_admin_ip_for_node(node.id)
if ip_addr:
@ -918,7 +735,7 @@ class NetworkManager(object):
@classmethod
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_bond = lambda x: x['type'] == consts.NETWORK_INTERFACE_TYPES.bond
interfaces = filter(is_ether, node_data['interfaces'])
@ -931,56 +748,49 @@ class NetworkManager(object):
interfaces_db
)[0]
# Remove all old network's assignment for this interface.
db().query(NetworkNICAssignment).filter_by(
interface_id=current_iface.id
).delete()
net_ids = [net['id'] for net in iface['assigned_networks']]
ngs = db().query(NetworkGroup).filter(
NetworkGroup.id.in_(net_ids)).all()
current_iface.assigned_networks_list.extend(ngs)
nets_to_assign = \
[objects.NetworkGroup.get_by_uid(ng['id']) for ng
in iface['assigned_networks']]
objects.NIC.assign_networks(current_iface, nets_to_assign)
update = {}
if 'interface_properties' in iface:
current_iface.interface_properties = \
iface['interface_properties']
update['interface_properties'] = iface['interface_properties']
if 'offloading_modes' in iface:
current_iface.offloading_modes = \
iface['offloading_modes']
update['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:
bond_db = NodeBondInterface()
bond_db.node = node_db
bond_db.name = bond['name']
if bond.get('bond_properties', {}).get('mode'):
bond_db.mode = bond['bond_properties']['mode']
mode = bond['bond_properties']['mode']
else:
bond_db.mode = bond['mode']
bond_db.mac = bond.get('mac')
bond_db.bond_properties = bond.get('bond_properties', {})
bond_db.interface_properties = bond.get('interface_properties', {})
mode = bond['mode']
data = {
'node': node_db,
'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.
net_ids = [net['id'] for net in bond['assigned_networks']]
ngs = db().query(NetworkGroup).filter(
NetworkGroup.id.in_(net_ids)).all()
bond_db.assigned_networks_list.extend(ngs)
nets_to_assign = \
[objects.NetworkGroup.get_by_uid(ng['id']) for ng
in bond['assigned_networks']]
objects.Bond.assign_networks(bond_db, nets_to_assign)
# Add new slaves.
for nic in bond['slaves']:
bond_db.slaves.append(
db().query(NodeNICInterface).filter_by(
name=nic['name']
).filter_by(
node_id=node_db.id
).first()
)
node_nics = {nic['name']: nic for nic in node_db.nic_interfaces}
slaves = [node_nics[n['name']] for n in bond['slaves']]
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
@classmethod
@ -1053,12 +863,16 @@ class NetworkManager(object):
if iface_mapped:
# clear old Admin-pxe mapping
iface_mapped.assigned_networks_list = \
net_list = \
[n for n in iface_mapped.assigned_networks_list
if n.name != consts.NETWORKS.fuelweb_admin]
objects.NIC.assign_networks(iface_mapped, net_list)
iface_pxe.assigned_networks_list.append(
cls.get_admin_network_group(node.id))
db().flush()
objects.NetworkGroup.get_admin_network_group(node.id))
objects.NIC.assign_networks(
iface_pxe, iface_pxe.assigned_networks_list
)
@classmethod
def check_interfaces_correctness(cls, node):
@ -1103,25 +917,29 @@ class NetworkManager(object):
@classmethod
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):
return True
return False
@classmethod
def __add_new_interface(cls, node, interface_attrs):
interface = NodeNICInterface()
interface.node_id = node.id
data = {
'node_id': node.id,
'mac': interface_attrs['mac'],
'name': interface_attrs['name']
}
interface = objects.NIC.create(data)
cls.__set_interface_attributes(interface, interface_attrs)
db().add(interface)
db().flush()
objects.NIC.update(interface, {})
@classmethod
def __update_existing_interface(cls, interface, interface_attrs,
update_by_agent=False):
cls.__set_interface_attributes(interface, interface_attrs,
update_by_agent)
db().flush()
objects.NIC.update(interface, {})
@classmethod
def __set_interface_attributes(cls, interface, interface_attrs,
@ -1159,11 +977,9 @@ class NetworkManager(object):
interfaces_mac_addresses = map(
lambda interface: interface['mac'].lower(), interfaces)
interfaces_to_delete = db().query(NodeNICInterface).filter(
NodeNICInterface.node_id == node.id
).filter(
not_(NodeNICInterface.mac.in_(interfaces_mac_addresses))
).all()
interfaces_to_delete = \
objects.NICCollection.get_interfaces_not_in_mac_list(
node.id, interfaces_mac_addresses)
if interfaces_to_delete:
mac_addresses = ' '.join(
@ -1173,52 +989,23 @@ class NetworkManager(object):
logger.info("Interfaces %s removed from node %s" % (
mac_addresses, node_name))
map(db().delete, interfaces_to_delete)
db().flush()
objects.NIC.bulk_delete([i.id for i in interfaces_to_delete])
@classmethod
def get_admin_ip_for_node(cls, node_id):
"""Returns first admin IP address for node."""
admin_net_id = cls.get_admin_network_group_id(node_id=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)
return objects.Node.get_admin_ip(node_id)
@classmethod
def get_admin_ips_for_interfaces(cls, node):
"""Returns mapping admin {"inteface name" => "admin ip"}."""
admin_net_id = cls.get_admin_network_group_id(node)
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)])
admin_ips = objects.Node.get_admin_ip(node.id)
interfaces_names = sorted(set([
interface.name for interface in node.interfaces]))
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
def get_admin_interface(cls, node):
try:
@ -1245,8 +1032,6 @@ class NetworkManager(object):
:return: Network device which has appointed network
with specified network name
"""
if not isinstance(node, Node):
node = db().query(Node).get(node)
for interface in node.interfaces:
for network in interface.assigned_networks_list:
if network.name == network_name:
@ -1272,11 +1057,7 @@ class NetworkManager(object):
nodegroup = objects.Cluster.get_controllers_node_group(cluster_db)
ip = cls.assign_vip(nodegroup, consts.NETWORKS.public).ip_addr
elif cluster_db.mode in ('singlenode', 'multinode'):
controller = db().query(Node).filter_by(
cluster_id=cluster_id
).filter(
Node.roles.any('controller')
).first()
controller = objects.Cluster.get_single_controller(cluster_id)
public_net = filter(
lambda network: network['name'] == 'public',
@ -1336,42 +1117,24 @@ class NetworkManager(object):
"""
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
def create_admin_network_group(cls, cluster_id, group_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
new_admin = NetworkGroup(
release=cluster_db.release.id,
name='fuelweb_admin',
cidr='9.9.9.0/24',
gateway='9.9.9.1',
group_id=group_id,
vlan_start=None,
meta=admin_meta
)
db().add(new_admin)
db().flush()
admin_meta['ip_range'] = ['9.9.9.2', '9.9.9.254']
data = {
'release': cluster_db.release.id,
'name': consts.NETWORKS.fuelweb_admin,
'cidr': '9.9.9.0/24',
'gateway': '9.9.9.1',
'group_id': group_id,
'vlan_start': None,
'meta': admin_meta
}
new_admin = objects.NetworkGroup.create(data)
objects.NetworkGroup._update_range_from_cidr(
new_admin, new_admin.cidr, use_gateway=True)
@ -1483,11 +1246,7 @@ class NetworkManager(object):
# delete intersecting IPs
# TODO(akasatkin): need to reexamine deleting of IPs when
# manual setting of IPs will be allowed
db.query(IPAddr).filter(
IPAddr.ip_addr == network.gateway,
IPAddr.network == network.id
).delete(synchronize_session='fetch')
db().flush()
objects.IPAddr.delete_by_network(network.gateway, network.id)
@classmethod
def create_network_groups(cls, cluster, neutron_segment_type,
@ -1522,7 +1281,7 @@ class NetworkManager(object):
def update_networks(cls, network_configuration):
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:
# there are no restrictions on update process if
@ -1562,14 +1321,9 @@ class NetworkManager(object):
for key, value in network_configuration['networking_parameters'] \
.items():
setattr(cluster.network_config, key, value)
db().flush()
@classmethod
def cluster_has_bonds(cls, cluster_id):
return db().query(Node).filter(
Node.cluster_id == cluster_id
).filter(
Node.bond_interfaces.any()).count() > 0
objects.Cluster.update(
cluster, {'network_config': cluster.network_config})
@classmethod
def create_network_groups_and_config(cls, cluster, data):
@ -1601,8 +1355,8 @@ class NetworkManager(object):
:param node_id: The ID of Node Object.
:return: The GW from Admin network if it's set. else Admin IP
"""
return cls.get_admin_network_group(node_id).gateway \
or settings.MASTER_IP
admin_net = objects.NetworkGroup.get_admin_network_group(node_id)
return admin_net.gateway or settings.MASTER_IP
@classmethod
def get_networks_not_on_node(cls, node, networks=None):
@ -1615,7 +1369,7 @@ class NetworkManager(object):
(n.name, 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))
output = defaultdict(list)
@ -1699,23 +1453,14 @@ class NetworkManager(object):
@classmethod
def get_assigned_ips_by_network_id(cls, network_id):
"""Returns IPs related to network with provided ID."""
return [
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))
)
]
return objects.NetworkGroup.get_assigned_ips(network_id)
@classmethod
def get_admin_networks(cls, cluster_nodegroup_info=False):
admin_db = db().query(
NetworkGroup
).filter_by(
name=consts.NETWORKS.fuelweb_admin
)
admin_dbs = objects.NetworkGroupCollection.filter_by(
iterable=None, name=consts.NETWORKS.fuelweb_admin)
result = []
for net in admin_db:
for net in admin_dbs:
net_info = {
'id': net.id,
'cidr': net.cidr,
@ -1736,31 +1481,6 @@ class NetworkManager(object):
result.append(net_info)
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):
@ -1866,9 +1586,7 @@ class AllocateVIPs70Mixin(object):
# VIPs to purge is modified inside the loop above
# and may not contain elements at this point
if vips_to_purge:
db.query(IPAddr).filter(
IPAddr.id.in_([ip.id for ip in vips_to_purge])
).delete(synchronize_session='fetch')
objects.IPAddr.bulk_delete(ip.id for ip in vips_to_purge)
@classmethod
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)
query = (
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)
)
query = objects.Cluster.get_network_groups_and_node_ids(cluster.id)
# Group by NetworkGroup.id
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:
return {}
ngs = db().query(models.NetworkGroup, models.IPAddr.ip_addr).\
filter(models.NetworkGroup.group_id == node.group_id). \
filter(models.IPAddr.network == models.NetworkGroup.id). \
filter(models.IPAddr.node == node.id)
ngs = objects.Node.get_networks_ips(node)
if not ngs:
return {}
@ -164,7 +161,7 @@ class NeutronManager70(
'meta': ng.meta,
'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:
networks[admin_ng.name] = {
'ip': cls.get_ip_w_cidr_prefix_len(
@ -242,12 +239,7 @@ class NeutronManager70(
@classmethod
def assign_ips_in_node_group(cls, net_id, net_name, node_ids, ip_ranges):
"""Assigns IP addresses for nodes in given network."""
ips_by_node_id = db().query(
models.IPAddr.ip_addr,
models.IPAddr.node
).filter_by(
network=net_id
)
ips_by_node_id = objects.IPAddr.get_by_node_for_network(net_id)
nodes_dont_need_ip = set()
ips_in_use = set()
@ -270,11 +262,12 @@ class NeutronManager70(
net_name
)
)
ip_db = models.IPAddr(node=node_id,
ip_addr=ip,
network=net_id)
db().add(ip_db)
db().flush()
new_ip = {
'node': node_id,
'ip_addr': ip,
'network': net_id
}
objects.IPAddr.create(new_ip)
@classmethod
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
to the particular node according to the template.
"""
network_by_group = db().query(
models.NetworkGroup.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
)
network_by_group = objects.NetworkGroup.get_by_cluster(cluster.id)
ip_ranges_by_network = objects.IPAddrRange.get_by_cluster(cluster.id)
for group_id, nodes_in_group in itertools.groupby(
nodes, lambda n: n.group_id):
@ -430,7 +405,7 @@ class NeutronManager70(
# Default admin network has no node group
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:
net_db = objects.NetworkGroup.get_from_node_group_by_name(
node.group_id, network)
@ -443,9 +418,8 @@ class NeutronManager70(
# Ensure network_group configuration is consistent
# with the template
if vlan != net_db.vlan_start:
net_db.vlan_start = vlan
db().add(net_db)
db().flush()
data = {'vlan_start': vlan}
objects.NetworkGroup.update(net_db, data)
ng = {'id': net_db.id}
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)
return q.filter(models.Node.status != status).count()
@classmethod
def get_network_groups_and_node_ids(cls, instance_id):
"""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
"""
instance.assigned_networks_list = networks
db().flush()
class NICCollection(NailgunCollection):

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

@ -301,6 +301,35 @@ class NetworkGroup(NailgunObject):
for node in cluster.nodes:
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):

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

@ -109,8 +109,14 @@ class Node(NailgunObject):
:param ips_by_network_name: dict
:returns: None
"""
ngs = cls.get_networks_ips(instance)
ngs = ngs.filter(models.NetworkGroup.name.in_(ips_by_network_name))
ngs = db().query(
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:
ip_addr.ip_addr = ips_by_network_name[ng_name]
db().flush()

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

@ -54,6 +54,7 @@ class NodeGroup(NailgunObject):
raise errors.CannotCreate(exc.message)
db().flush()
db().refresh(cluster)
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.sqlalchemy.models import NetworkGroup
from nailgun.errors import errors
from nailgun.objects import Cluster
from nailgun.objects import Node
from nailgun import objects
from nailgun.settings import settings
@ -46,14 +45,14 @@ class MellanoxMixin(object):
: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', {})
# We need to support mellanox for releases < 8.0. So if mellanox
# attributes exist (primary in old releases) then merge them with
# common node attributes.
if neutron_mellanox_data:
storage_data = cluster_attrs.get('storage', {})
nm = Cluster.get_network_manager(cluster)
nm = objects.Cluster.get_network_manager(cluster)
node_attrs['neutron_mellanox'] = {}
# Find Physical port for VFs generation
@ -166,7 +165,7 @@ class VmwareDeploymentSerializerMixin(object):
'cinder-vmware'
]
all_roles = Node.all_roles(node)
all_roles = objects.Node.all_roles(node)
use_vcenter = node.cluster.attributes.editable.get('common', {}) \
.get('use_vcenter', {}).get('value')
@ -261,12 +260,12 @@ class NetworkDeploymentSerializer(object):
@classmethod
def update_nodes_net_info(cls, cluster, nodes):
"""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
addresses = {}
for net in node.cluster.network_groups:
if net.name == 'public' and \
not Node.should_have_public_with_ip(node):
not objects.Node.should_have_public_with_ip(node):
continue
if net.meta.get('render_addr_mask'):
addresses.update(cls.get_addr_mask(
@ -282,7 +281,7 @@ class NetworkDeploymentSerializer(object):
"""Cluster network attributes."""
common = cls.network_provider_cluster_attrs(cluster)
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['nodes'] = deepcopy(attrs['nodes'])
@ -347,13 +346,13 @@ class NetworkDeploymentSerializer(object):
@staticmethod
def get_admin_ip_w_prefix(node):
"""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 = IPNetwork(admin_ip)
# Assign prefix from admin network
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

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

@ -255,7 +255,7 @@ class NeutronNetworkDeploymentSerializer(
attrs['transformations'].append({
'action': 'add-patch',
'bridges': [
'br-%s' % nm.get_node_interface_by_netname(
'br-%s' % objects.Node.get_interface_by_net_name(
node.id,
'private'
).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)
fixed_interface = net_manager._get_interface_by_network_name(
node.id, 'fixed')
node, 'fixed')
attrs = {'fixed_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)
net_manager = objects.Cluster.get_network_manager(node.cluster)
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(
{'admin_net': net_manager.get_admin_network_group(node.id).cidr}
{'admin_net': admin_net.cidr}
)
serialized_node.update(cls.serialize_interfaces(node))
@ -195,7 +196,7 @@ class ProvisioningSerializer(MellanoxMixin):
net_manager = objects.Cluster.get_network_manager(node.cluster)
admin_ip = net_manager.get_admin_ip_for_node(node.id)
admin_netmask = str(netaddr.IPNetwork(
net_manager.get_admin_network_group(node.id).cidr
objects.NetworkGroup.get_admin_network_group(node.id).cidr
).netmask)
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'] = []
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):
udev_interfaces_mapping = ','.join(
@ -306,7 +306,7 @@ class TestHandlers(BaseIntegrationTest):
'gw':
self.env.network_manager.get_default_gateway(n.id),
'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'] = []
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):
udev_interfaces_mapping = ','.join(
@ -769,7 +769,7 @@ class TestHandlers(BaseIntegrationTest):
'gw':
self.env.network_manager.get_default_gateway(n.id),
'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'] = []
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):
udev_interfaces_mapping = ','.join(
@ -1273,7 +1273,7 @@ class TestHandlers(BaseIntegrationTest):
'gw':
self.env.network_manager.get_default_gateway(n.id),
'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)
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(
network_group_id=admin_net_id
).delete()
@ -334,7 +334,7 @@ class TestNetworkManager(BaseIntegrationTest):
self.db().flush()
admin_net =\
self.env.network_manager.get_admin_network_group(
objects.NetworkGroup.get_admin_network_group(
self.env.nodes[1].id
)
mock_range = IPAddrRange(
@ -348,7 +348,7 @@ class TestNetworkManager(BaseIntegrationTest):
self.env.network_manager.assign_admin_ips(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).\
filter_by(network=admin_net.id).\
filter_by(node=n.id).first()
@ -416,9 +416,8 @@ class TestNetworkManager(BaseIntegrationTest):
for node in self.env.nodes:
# if node_id is not passed to the method vips also will be
# returned as they are assigned at the cretion of a cluster
ip = self.env.network_manager._get_ips_except_admin(
node_id=node.id,
joined=True
ip = objects.IPAddr.get_ips_except_admin(
node_id=node.id, include_network_data=True
)[0]
ips.append(ip)
@ -434,7 +433,7 @@ class TestNetworkManager(BaseIntegrationTest):
def test_assign_admin_ips(self):
node = self.env.create_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).\
filter_by(network_group_id=admin_ng_id).all()[0]
@ -449,7 +448,7 @@ class TestNetworkManager(BaseIntegrationTest):
def test_assign_admin_ips_idempotent(self):
node = self.env.create_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).
filter_by(node=node.id).
filter_by(network=admin_net_id).all()])
@ -461,7 +460,7 @@ class TestNetworkManager(BaseIntegrationTest):
def test_assign_admin_ips_only_one(self):
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(
first='10.0.0.1',
last='10.0.0.1',
@ -473,7 +472,7 @@ class TestNetworkManager(BaseIntegrationTest):
node = self.env.create_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).\
filter_by(node=node.id).\
@ -483,7 +482,7 @@ class TestNetworkManager(BaseIntegrationTest):
def test_assign_admin_ips_for_many_nodes(self):
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(
first='10.0.0.1',
last='10.0.0.2',
@ -497,7 +496,7 @@ class TestNetworkManager(BaseIntegrationTest):
nc = [n1, n2]
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']):
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
)
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):
cluster = self.env.create_cluster(api=False)
@ -527,20 +526,19 @@ class TestNetworkManager(BaseIntegrationTest):
node_net_ips = \
dict((net.name, self.env.network_manager.get_free_ips(net)[0])
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.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)
node = self.env.create_node(cluster_id=cluster.id)
self.env.network_manager.assign_ips(
cluster, [node], consts.NETWORKS.management
)
admin_ng_id = \
self.env.network_manager.get_admin_network_group_id(node.id)
admin_ng_id = objects.NetworkGroup.get_admin_network_group(node.id).id
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:
self.assertEquals(admin_ng_id, ip.network)
@ -551,12 +549,11 @@ class TestNetworkManager(BaseIntegrationTest):
cluster, [node], consts.NETWORKS.management
)
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 = \
dict((net.id, admin_ng_id) for iface in node.nic_interfaces
for net in iface.assigned_networks_list)
self.env.network_manager.set_nic_assignment_netgroups_ids(node,
nic_ng_ids)
objects.Node.set_nic_assignment_netgroups_ids(node, nic_ng_ids)
self.db.refresh(node)
for iface in node.nic_interfaces:
for net in iface.assigned_networks_list:
@ -581,12 +578,11 @@ class TestNetworkManager(BaseIntegrationTest):
}]
})
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 = \
dict((net.id, admin_ng_id) for iface in node.bond_interfaces
for net in iface.assigned_networks_list)
self.env.network_manager.set_bond_assignment_netgroups_ids(node,
bond_ng_ids)
objects.Node.set_bond_assignment_netgroups_ids(node, bond_ng_ids)
self.db.refresh(node)
for iface in node.bond_interfaces:
for net in iface.assigned_networks_list:
@ -793,7 +789,7 @@ class TestNetworkManager(BaseIntegrationTest):
rpc_nodes_provision = nailgun.task.manager.rpc.cast. \
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).\
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',
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):

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.errors import errors
from nailgun.network.checker import NetworkCheck
from nailgun import objects
from nailgun.test.base import BaseIntegrationTest
@ -120,7 +121,7 @@ class TestNovaHandlers(TestNetworkChecking):
self.assertEqual(len(ngs_created), len(self.nets['networks']))
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"] = \
admin_ng.cidr
@ -132,7 +133,7 @@ class TestNovaHandlers(TestNetworkChecking):
self.assertIn("fixed", task['message'])
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)
flt_r0 = str(IPAddress(cidr.first + 2))
flt_r1 = str(IPAddress(cidr.last))
@ -418,7 +419,7 @@ class TestNeutronHandlersGre(TestNetworkChecking):
# network to the Admin interface.
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
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,
"that does not match any Admin network")
nm = objects.Cluster.get_network_manager(node.cluster)
admin_ng = nm.get_admin_network_group(node.id)
admin_ng = objects.NetworkGroup.get_admin_network_group(node.id)
ipaddress = str(netaddr.IPRange(admin_ng.ip_ranges[0].first,
admin_ng.ip_ranges[0].last)[1])
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):
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])
mac1, mac2 = (self.env.generate_random_mac(),
self.env.generate_random_mac())
@ -517,7 +517,7 @@ class TestNodePublicNetworkToNICAssignment(BaseIntegrationTest):
def create_node_and_check_assignment(self):
meta = self.env.default_metadata()
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()
meta['interfaces'] = [
{'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)
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
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)
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(
reverse(
'NetworkGroupHandler',
@ -419,7 +419,7 @@ class TestHandlers(BaseIntegrationTest):
'Network release could not be changed.')
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 = {
'id': admin.id,
'group_id': objects.Cluster.get_default_group(self.cluster).id,