openstack
/
fuel-web
Code Issues Proposed changes

Remove Network and Vlan models 

These models are removed and NetworkGroup model have all relationships that Network model had.
Vlan model was utilized to check that newly created networks
have the same VLAN IDs being assigned as networks of other clusters.
Now this can be checked using NetworkGroup model but not checked
because the result of this checking was used for logging only.

Implements: blueprint nailgun-remove-network-model

Change-Id: Iaec7d5acdb0e47d9e9cf4c224e1be768df83107f
This commit is contained in:
Aleksey Kasatkin 2013-12-06 16:09:00 +02:00
parent 1eb3b71370
commit 61827f3464
19 changed files with 108 additions and 262 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
nailgun/nailgun/db/sqlalchemy/models/__init__.py
View File

@ -29,11 +29,9 @@ from nailgun.db.sqlalchemy.models.node import Role
from nailgun.db.sqlalchemy.models.node import NodeAttributes
from nailgun.db.sqlalchemy.models.node import NodeNICInterface
from nailgun.db.sqlalchemy.models.network import Network
from nailgun.db.sqlalchemy.models.network import NetworkGroup
from nailgun.db.sqlalchemy.models.network import IPAddr
from nailgun.db.sqlalchemy.models.network import IPAddrRange
from nailgun.db.sqlalchemy.models.network import Vlan
from nailgun.db.sqlalchemy.models.network import AllowedNetworks
from nailgun.db.sqlalchemy.models.network import NetworkAssignment

38
nailgun/nailgun/db/sqlalchemy/models/network.py
View File

@ -18,9 +18,8 @@ from sqlalchemy import Column
from sqlalchemy import Enum
from sqlalchemy import ForeignKey
from sqlalchemy import Integer
from sqlalchemy.orm import relationship
from sqlalchemy import String
from sqlalchemy import Unicode
from sqlalchemy.orm import relationship, backref
from nailgun.db.sqlalchemy.models.base import Base
@ -28,11 +27,12 @@ from nailgun.db.sqlalchemy.models.base import Base
class IPAddr(Base):
__tablename__ = 'ip_addrs'
id = Column(Integer, primary_key=True)
network = Column(Integer, ForeignKey('networks.id', ondelete="CASCADE"))
network = Column(Integer, ForeignKey('network_groups.id',
ondelete="CASCADE"))
node = Column(Integer, ForeignKey('nodes.id', ondelete="CASCADE"))
ip_addr = Column(String(25), nullable=False)
network_data = relationship("Network")
network_data = relationship("NetworkGroup")
node_data = relationship("Node")
@ -44,29 +44,6 @@ class IPAddrRange(Base):
last = Column(String(25), nullable=False)
class Vlan(Base):
__tablename__ = 'vlan'
id = Column(Integer, primary_key=True)
network = relationship("Network",
backref=backref("vlan"))
class Network(Base):
__tablename__ = 'networks'
id = Column(Integer, primary_key=True)
# can be nullable only for fuelweb admin net
release = Column(Integer, ForeignKey('releases.id'))
name = Column(Unicode(100), nullable=False)
vlan_id = Column(Integer, ForeignKey('vlan.id'))
network_group_id = Column(Integer, ForeignKey('network_groups.id'))
cidr = Column(String(25), nullable=False)
gateway = Column(String(25))
nodes = relationship(
"Node",
secondary=IPAddr.__table__,
backref="networks")
class NetworkGroup(Base):
__tablename__ = 'network_groups'
NAMES = (
@ -93,16 +70,17 @@ class NetworkGroup(Base):
network_size = Column(Integer, default=256)
amount = Column(Integer, default=1)
vlan_start = Column(Integer)
networks = relationship("Network", cascade="delete",
backref="network_group")
cidr = Column(String(25))
gateway = Column(String(25))
netmask = Column(String(25), nullable=False)
ip_ranges = relationship(
"IPAddrRange",
backref="network_group"
)
nodes = relationship(
"Node",
secondary=IPAddr.__table__,
backref="networks")
@classmethod
def generate_vlan_ids_list(cls, ng):

9
nailgun/nailgun/fixtures/admin_network.json
View File

@ -10,15 +10,6 @@
"vlan_start": null
}
},
{
"pk": 1,
"model": "nailgun.network",
"fields": {
"name": "fuelweb_admin",
"network_group": 1,
"cidr": "{{settings.ADMIN_NETWORK['cidr']}}"
}
},
{
"pk": 1,
"model": "nailgun.i_p_addr_range",

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

@ -21,8 +21,6 @@ from itertools import ifilter
from itertools import imap
from itertools import islice
import math
from netaddr import IPAddress
from netaddr import IPNetwork
from netaddr import IPRange
@ -34,12 +32,10 @@ from nailgun.db import db
from nailgun.db.sqlalchemy.models import Cluster
from nailgun.db.sqlalchemy.models import IPAddr
from nailgun.db.sqlalchemy.models import IPAddrRange
from nailgun.db.sqlalchemy.models import Network
from nailgun.db.sqlalchemy.models import NetworkAssignment
from nailgun.db.sqlalchemy.models import NetworkGroup
from nailgun.db.sqlalchemy.models import Node
from nailgun.db.sqlalchemy.models import NodeNICInterface
from nailgun.db.sqlalchemy.models import Vlan
from nailgun.errors import errors
from nailgun.logger import logger
@ -64,40 +60,6 @@ class NetworkManager(object):
db().add(ip_range)
db().commit()
@classmethod
def get_admin_network_id(cls, fail_if_not_found=True):
'''Method for receiving Admin Network ID.
:param fail_if_not_found: Raise an error
if admin network is not found in database.
:type fail_if_not_found: bool
:returns: Admin Network ID or None.
:raises: errors.AdminNetworkNotFound
'''
admin_net = db().query(Network).filter_by(
name="fuelweb_admin"
).first()
if not admin_net and fail_if_not_found:
raise errors.AdminNetworkNotFound()
return admin_net.id
@classmethod
def get_admin_network(cls, fail_if_not_found=True):
'''Method for receiving Admin Network.
:param fail_if_not_found: Raise an error
if admin network is not found in database.
:type fail_if_not_found: bool
:returns: Admin Network or None.
:raises: errors.AdminNetworkNotFound
'''
admin_net = db().query(Network).filter_by(
name="fuelweb_admin"
).first()
if not admin_net and fail_if_not_found:
raise errors.AdminNetworkNotFound()
return admin_net
@classmethod
def get_admin_network_group_id(cls, fail_if_not_found=True):
'''Method for receiving Admin NetworkGroup ID.
@ -133,57 +95,20 @@ class NetworkManager(object):
return admin_ng
@classmethod
def create_networks(cls, nw_group):
"""Method for creation of networks for network group.
def cleanup_network_group(cls, nw_group):
"""Network group cleanup - deletes all IPs were assigned within
the network group.
:param nw_group: NetworkGroup object.
:type nw_group: NetworkGroup
:returns: None
"""
fixnet = IPNetwork(nw_group.cidr)
subnet_bits = int(math.ceil(math.log(nw_group.network_size, 2)))
logger.debug("Specified network size requires %s bits", subnet_bits)
subnets = list(fixnet.subnet(32 - subnet_bits,
count=nw_group.amount))
logger.debug("Base CIDR sliced on subnets: %s", subnets)
for net in nw_group.networks:
logger.debug("Deleting old network with id=%s, cidr=%s",
net.id, net.cidr)
ips = db().query(IPAddr).filter(
IPAddr.network == net.id
).all()
map(db().delete, ips)
db().delete(net)
db().commit()
# Dmitry's hack for clearing VLANs without networks
cls.clear_vlans()
db().commit()
nw_group.networks = []
for n in xrange(nw_group.amount):
vlan_id = None
if nw_group.vlan_start is not None:
vlan_db = db().query(Vlan).get(nw_group.vlan_start + n)
if vlan_db:
logger.warning("Intersection with existing vlan_id: %s",
vlan_db.id)
else:
vlan_db = Vlan(id=nw_group.vlan_start + n)
db().add(vlan_db)
vlan_id = vlan_db.id
logger.debug("Created VLAN object, vlan_id=%s", vlan_id)
gateway = None
if nw_group.gateway:
gateway = nw_group.gateway
net_db = Network(
release=nw_group.release,
name=nw_group.name,
cidr=str(subnets[n]),
vlan_id=vlan_id,
gateway=gateway,
network_group_id=nw_group.id)
db().add(net_db)
logger.debug("Deleting old IPs for network with id=%s, cidr=%s",
nw_group.id, nw_group.cidr)
ips = db().query(IPAddr).filter(
IPAddr.network == nw_group.id
).all()
map(db().delete, ips)
db().commit()
@classmethod
@ -196,21 +121,21 @@ class NetworkManager(object):
:type num: int
:returns: None
'''
admin_net_id = cls.get_admin_network_id()
admin_net_id = cls.get_admin_network_group_id()
node_admin_ips = db().query(IPAddr).filter_by(
node=node_id,
network=admin_net_id
).all()
if not node_admin_ips or len(node_admin_ips) < num:
admin_net = db().query(Network).get(admin_net_id)
admin_net = db().query(NetworkGroup).get(admin_net_id)
logger.debug(
u"Trying to assign admin ips: node=%s count=%s",
node_id,
num - len(node_admin_ips)
)
free_ips = cls.get_free_ips(
admin_net.network_group.id,
admin_net.id,
num=num - len(node_admin_ips)
)
logger.info(len(free_ips))
@ -251,7 +176,7 @@ class NetworkManager(object):
)
)
network = db().query(Network).join(NetworkGroup).\
network = db().query(NetworkGroup).\
filter(NetworkGroup.cluster_id == cluster_id).\
filter_by(name=network_name).first()
@ -295,7 +220,7 @@ class NetworkManager(object):
network_name
)
)
free_ip = cls.get_free_ips(network.network_group.id)[0]
free_ip = cls.get_free_ips(network.id)[0]
ip_db = IPAddr(
network=network.id,
node=node_id,
@ -327,7 +252,7 @@ class NetworkManager(object):
if not cluster:
raise Exception(u"Cluster id='%s' not found" % cluster_id)
network = db().query(Network).join(NetworkGroup).\
network = db().query(NetworkGroup).\
filter(NetworkGroup.cluster_id == cluster_id).\
filter_by(name=network_name).first()
@ -335,7 +260,7 @@ class NetworkManager(object):
raise Exception(u"Network '%s' for cluster_id=%s not found." %
(network_name, cluster_id))
admin_net_id = cls.get_admin_network_id()
admin_net_id = cls.get_admin_network_group_id()
cluster_ips = [ne.ip_addr for ne in db().query(IPAddr).filter_by(
network=network.id,
node=None
@ -353,23 +278,13 @@ class NetworkManager(object):
vip = cluster_ips[0]
else:
# IP address has not been assigned, let's do it
vip = cls.get_free_ips(network.network_group.id)[0]
vip = cls.get_free_ips(network.id)[0]
ne_db = IPAddr(network=network.id, ip_addr=vip)
db().add(ne_db)
db().commit()
return vip
@classmethod
def clear_vlans(cls):
"""Removes from DB all Vlans without Networks assigned to them.
"""
map(
db().delete,
db().query(Vlan).filter_by(network=None)
)
db().commit()
@classmethod
def _chunked_range(cls, iterable, chunksize=64):
"""We want to be able to iterate over iterable chunk by chunk.
@ -400,7 +315,7 @@ class NetworkManager(object):
addr = IPAddress(ip_addr)
ipranges = imap(
lambda ir: IPRange(ir.first, ir.last),
network.network_group.ip_ranges
network.ip_ranges
)
for r in ipranges:
if addr in r:
@ -451,15 +366,13 @@ class NetworkManager(object):
"""
ips = db().query(IPAddr).order_by(IPAddr.id)
if joined:
ips = ips.options(
joinedload('network_data'),
joinedload('network_data.network_group'))
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)
admin_net_id = cls.get_admin_network_id(False)
admin_net_id = cls.get_admin_network_group_id(False)
if admin_net_id:
ips = ips.filter(
not_(IPAddr.network == admin_net_id)
@ -510,27 +423,25 @@ class NetworkManager(object):
network_data = []
network_ids = []
for ip in ips:
net = db().query(Network).get(ip.network)
net = db().query(NetworkGroup).get(ip.network)
interface = cls._get_interface_by_network_name(
node_db.id, net.name)
if net.name == 'public':
# Get prefix from netmask instead of cidr
# for public network
network_group = db().query(NetworkGroup).get(
net.network_group_id)
# Convert netmask to prefix
prefix = str(IPNetwork(
'0.0.0.0/' + network_group.netmask).prefixlen)
netmask = network_group.netmask
'0.0.0.0/' + net.netmask).prefixlen)
netmask = net.netmask
else:
prefix = str(IPNetwork(net.cidr).prefixlen)
netmask = str(IPNetwork(net.cidr).netmask)
network_data.append({
'name': net.name,
'vlan': net.vlan_id,
'vlan': net.vlan_start,
'ip': ip.ip_addr + '/' + prefix,
'netmask': netmask,
'brd': str(IPNetwork(net.cidr).broadcast),
@ -565,11 +476,10 @@ class NetworkManager(object):
@classmethod
def get_networks_grouped_by_cluster(cls):
networks = db().query(Network).options(joinedload('network_group')).\
order_by(Network.id).all()
networks = db().query(NetworkGroup).order_by(NetworkGroup.id).all()
return cls.group_by_key_and_history(
networks,
lambda net: net.network_group.cluster_id)
lambda net: net.cluster_id)
@classmethod
def get_node_networks_optimized(cls, node_db, ips_db, networks):
@ -598,15 +508,15 @@ class NetworkManager(object):
# Convert netmask to prefix
prefix = str(IPNetwork(
'0.0.0.0/' + net.network_group.netmask).prefixlen)
netmask = net.network_group.netmask
'0.0.0.0/' + net.netmask).prefixlen)
netmask = net.netmask
else:
prefix = str(IPNetwork(net.cidr).prefixlen)
netmask = str(IPNetwork(net.cidr).netmask)
network_data.append({
'name': net.name,
'vlan': net.vlan_id,
'vlan': net.vlan_start,
'ip': ip.ip_addr + '/' + prefix,
'netmask': netmask,
'brd': str(IPNetwork(net.cidr).broadcast),
@ -626,7 +536,7 @@ class NetworkManager(object):
continue
network_data.append({
'name': net.name,
'vlan': net.vlan_id,
'vlan': net.vlan_start,
'dev': interface.name})
network_data.append(cls._get_admin_network(node_db))
@ -637,16 +547,16 @@ class NetworkManager(object):
def _add_networks_wo_ips(cls, cluster_db, network_ids, node_db):
add_net_data = []
# And now let's add networks w/o IP addresses
nets = db().query(Network).join(NetworkGroup).\
nets = db().query(NetworkGroup).\
filter(NetworkGroup.cluster_id == cluster_db.id)
if network_ids:
nets = nets.filter(not_(Network.id.in_(network_ids)))
nets = nets.filter(not_(NetworkGroup.id.in_(network_ids)))
# For now, we pass information about all networks,
# so these vlans will be created on every node we call this func for
# However it will end up with errors if we precreate vlans in VLAN mode
# in fixed network. We are skipping fixed nets in Vlan mode.
for net in nets.order_by(Network.id).all():
for net in nets.order_by(NetworkGroup.id).all():
interface = cls._get_interface_by_network_name(
node_db,
net.name
@ -656,7 +566,7 @@ class NetworkManager(object):
continue
add_net_data.append({
'name': net.name,
'vlan': net.vlan_id,
'vlan': net.vlan_start,
'dev': interface.name})
add_net_data.append(cls._get_admin_network(node_db))
@ -737,7 +647,7 @@ class NetworkManager(object):
@classmethod
def is_ip_belongs_to_admin_subnet(cls, ip_addr):
admin_cidr = cls.get_admin_network().cidr
admin_cidr = cls.get_admin_network_group().cidr
if ip_addr and IPAddress(ip_addr) in IPNetwork(admin_cidr):
return True
return False
@ -801,7 +711,7 @@ class NetworkManager(object):
def get_admin_ips_for_interfaces(cls, node):
"""Returns mapping admin {"inteface name" => "admin ip"}
"""
admin_net_id = cls.get_admin_network_id()
admin_net_id = cls.get_admin_network_group_id()
admin_ips = set([
i.ip_addr for i in db().query(IPAddr).
order_by(IPAddr.id).

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

@ -336,7 +336,7 @@ class NeutronManager(NetworkManager):
db().commit()
nw_group.ip_ranges.append(new_ip_range)
db().commit()
cls.create_networks(nw_group)
cls.cleanup_network_group(nw_group)
used_vlans.append(vlan_start)
used_nets.append(str(new_net))
@ -380,7 +380,7 @@ class NeutronManager(NetworkManager):
'neutron_parameters']['predefined_networks']
pre_nets['net04_ext']['L3']['gateway'] = ng['gateway']
if ng_db.meta.get("notation"):
cls.create_networks(ng_db)
cls.cleanup_network_group(ng_db)
ng_db.cluster.add_pending_changes('networks')
if 'neutron_parameters' in network_configuration:

4
nailgun/nailgun/network/nova_network.py
View File

@ -60,7 +60,7 @@ class NovaNetworkManager(NetworkManager):
db().commit()
nw_group.ip_ranges.append(new_ip_range)
db().commit()
cls.create_networks(nw_group)
cls.cleanup_network_group(nw_group)
@classmethod
def assign_networks_by_default(cls, node):
@ -186,5 +186,5 @@ class NovaNetworkManager(NetworkManager):
setattr(ng_db, key, value)
cls.create_networks(ng_db)
cls.cleanup_network_group(ng_db)
ng_db.cluster.add_pending_changes('networks')

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

@ -397,7 +397,7 @@ class NetworkDeploymentSerializer(object):
admin_ip = IPNetwork(admin_ip)
# Assign prefix from admin network
admin_net = IPNetwork(network_manager.get_admin_network().cidr)
admin_net = IPNetwork(network_manager.get_admin_network_group().cidr)
admin_ip.prefixlen = admin_net.prefixlen
return str(admin_ip)

8
nailgun/nailgun/rpc/receiver.py
View File

@ -131,11 +131,8 @@ class NailgunReceiver(object):
logger.debug("Removing environment itself")
cluster_name = cluster.name
nws = itertools.chain(
*[n.networks for n in cluster.network_groups]
)
ips = db().query(IPAddr).filter(
IPAddr.network.in_([n.id for n in nws])
IPAddr.network.in_([n.id for n in cluster.network_groups])
)
map(db().delete, ips)
db().commit()
@ -143,9 +140,6 @@ class NailgunReceiver(object):
db().delete(cluster)
db().commit()
# Dmitry's hack for clearing VLANs without networks
NetworkManager.clear_vlans()
notifier.notify(
"done",
u"Environment '%s' and all its nodes are deleted" % (

2
nailgun/nailgun/task/helpers.py
View File

@ -59,7 +59,7 @@ class TaskHelper(object):
bak = os.path.join(prefix, "%s.bak" % str(node.fqdn))
new = os.path.join(prefix, str(node.fqdn))
admin_net_id = NetworkManager.get_admin_network_id()
admin_net_id = NetworkManager.get_admin_network_group_id()
links = map(
lambda i: os.path.join(prefix, i.ip_addr),
db().query(IPAddr.ip_addr).

2
nailgun/nailgun/test/base.py
View File

@ -401,7 +401,7 @@ class Environment(object):
if self.network_manager.is_ip_belongs_to_admin_subnet(ip)]
if not admin_ips:
admin_cidr = self.network_manager.get_admin_network().cidr
admin_cidr = self.network_manager.get_admin_network_group().cidr
interfaces[0]['ip'] = str(IPNetwork(admin_cidr).ip)
def set_interfaces_in_meta(self, meta, interfaces):

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

@ -208,7 +208,7 @@ class TestHandlers(BaseIntegrationTest):
deployment_msg['args']['deployment_info'] = deployment_info
provision_nodes = []
admin_net = self.env.network_manager.get_admin_network()
admin_net = self.env.network_manager.get_admin_network_group()
for n in sorted(self.env.nodes, key=lambda n: n.id):
udev_interfaces_mapping = ','.join([
@ -262,7 +262,7 @@ class TestHandlers(BaseIntegrationTest):
pnd['interfaces'][i.name] = {
'mac_address': i.mac,
'static': '0',
'netmask': admin_net.network_group.netmask,
'netmask': admin_net.netmask,
'ip_address': admin_ips.pop(),
}
if 'interfaces_extra' not in pnd:
@ -564,7 +564,7 @@ class TestHandlers(BaseIntegrationTest):
deployment_msg['args']['deployment_info'] = deployment_info
provision_nodes = []
admin_net = self.env.network_manager.get_admin_network()
admin_net = self.env.network_manager.get_admin_network_group()
for n in sorted(self.env.nodes, key=lambda n: n.id):
udev_interfaces_mapping = ','.join([
@ -619,7 +619,7 @@ class TestHandlers(BaseIntegrationTest):
pnd['interfaces'][i['name']] = {
'mac_address': i['mac'],
'static': '0',
'netmask': admin_net.network_group.netmask,
'netmask': admin_net.netmask,
'ip_address': admin_ips.pop(),
}
if 'interfaces_extra' not in pnd:

9
nailgun/nailgun/test/integration/test_cluster_collection_handlers.py
View File

@ -20,7 +20,6 @@ from mock import patch
from sqlalchemy.sql import not_
from nailgun.db.sqlalchemy.models import Cluster
from nailgun.db.sqlalchemy.models import Network
from nailgun.db.sqlalchemy.models import NetworkGroup
from nailgun.db.sqlalchemy.models import Release
from nailgun.network.nova_network import NovaNetworkManager
@ -153,15 +152,15 @@ class TestHandlers(BaseIntegrationTest):
headers=self.default_headers
)
self.assertEquals(201, resp.status)
nets = self.db.query(Network).filter(
not_(Network.name == "fuelweb_admin")
nets = self.db.query(NetworkGroup).filter(
not_(NetworkGroup.name == "fuelweb_admin")
).all()
obtained = []
for net in nets:
obtained.append({
'release': net.release,
'name': net.name,
'vlan_id': net.vlan_id,
'vlan_id': net.vlan_start,
'cidr': net.cidr,
'gateway': net.gateway
})
@ -184,7 +183,7 @@ class TestHandlers(BaseIntegrationTest):
'release': release.id,
'name': u'fixed',
'vlan_id': 103,
'cidr': '10.0.0.0/24',
'cidr': '10.0.0.0/16',
'gateway': '10.0.0.1'
},
{

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

@ -16,7 +16,6 @@
from nailgun.db.sqlalchemy.models import IPAddr
from nailgun.db.sqlalchemy.models import Network
from nailgun.db.sqlalchemy.models import NetworkGroup
from nailgun.test.base import BaseIntegrationTest
from nailgun.test.base import fake_tasks
@ -42,7 +41,7 @@ class TestHorizonURL(BaseIntegrationTest):
supertask = self.env.launch_deployment()
self.env.wait_ready(supertask, 60)
network = self.db.query(Network).join(NetworkGroup).\
network = self.db.query(NetworkGroup).\
filter(NetworkGroup.cluster_id == self.env.clusters[0].id).\
filter_by(name="public").first()
lost_ips = self.db.query(IPAddr).filter_by(

10
nailgun/nailgun/test/integration/test_network_configuration.py
View File

@ -127,8 +127,8 @@ class TestNovaNetworkConfigurationHandlerMultinode(BaseIntegrationTest):
resp = self.env.nova_networks_put(self.cluster.id, new_nets)
self.assertEquals(resp.status, 202)
self.db.refresh(network)
self.assertEquals(len(network.networks), 1)
self.assertEquals(network.networks[0].vlan_id, 500)
self.assertEquals(network.amount, 1)
self.assertEquals(network.vlan_start, 500)
def test_update_networks_and_net_manager(self):
network = self.db.query(NetworkGroup).filter(
@ -144,7 +144,7 @@ class TestNovaNetworkConfigurationHandlerMultinode(BaseIntegrationTest):
self.assertEquals(
self.cluster.net_manager,
new_net['net_manager'])
self.assertEquals(network.networks[0].vlan_id, new_vlan_id)
self.assertEquals(network.vlan_start, new_vlan_id)
def test_networks_update_fails_with_wrong_net_id(self):
new_nets = {'networks': [{'id': 500,
@ -320,8 +320,8 @@ class TestNeutronNetworkConfigurationHandlerMultinode(BaseIntegrationTest):
self.assertEquals(resp.status, 202)
self.db.refresh(network)
self.assertEquals(len(network.networks), 1)
self.assertEquals(network.networks[0].vlan_id, 500)
self.assertEquals(network.amount, 1)
self.assertEquals(network.vlan_start, 500)
def test_update_networks_fails_if_change_net_segmentation_type(self):
resp = self.env.neutron_networks_get(self.cluster.id)

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

@ -30,7 +30,6 @@ import nailgun
from nailgun.db.sqlalchemy.models import IPAddr
from nailgun.db.sqlalchemy.models import IPAddrRange
from nailgun.db.sqlalchemy.models import Network
from nailgun.db.sqlalchemy.models import NetworkGroup
from nailgun.db.sqlalchemy.models import Node
from nailgun.db.sqlalchemy.models import NodeNICInterface
@ -62,7 +61,7 @@ class TestNetworkManager(BaseIntegrationTest):
"management"
)
management_net = self.db.query(Network).join(NetworkGroup).\
management_net = self.db.query(NetworkGroup).\
filter(
NetworkGroup.cluster_id == self.env.clusters[0].id
).filter_by(
@ -186,9 +185,7 @@ class TestNetworkManager(BaseIntegrationTest):
ips = self.env.network_manager._get_ips_except_admin(joined=True)
self.assertEqual(len(ips), 2)
self.assertTrue(isinstance(ips[0].node_data, Node))
self.assertTrue(isinstance(ips[0].network_data, Network))
self.assertTrue(isinstance(ips[0].network_data.network_group,
NetworkGroup))
self.assertTrue(isinstance(ips[0].network_data, NetworkGroup))
def test_get_node_networks_optimization(self):
self.env.create(
@ -230,7 +227,7 @@ class TestNetworkManager(BaseIntegrationTest):
self.assertTrue(isinstance(networks, dict))
self.assertIn(cluster['id'], networks)
self.assertEqual(len(networks[cluster['id']]), 5)
networks_keys = (n.network_group.name for n in networks[cluster['id']])
networks_keys = (n.name for n in networks[cluster['id']])
# NetworkGroup.names[1:6] - all except fuel_admin and private
# private is not used with NovaNetwork
self.assertEqual(sorted(networks_keys),
@ -258,14 +255,13 @@ class TestNetworkManager(BaseIntegrationTest):
def test_assign_admin_ips(self):
node = self.env.create_node()
self.env.network_manager.assign_admin_ips(node.id, 2)
admin_net_id = self.env.network_manager.get_admin_network_id()
admin_ng_id = self.env.network_manager.get_admin_network_group_id()
admin_network_range = self.db.query(IPAddrRange).\
filter_by(network_group_id=admin_ng_id).all()[0]
admin_ips = self.db.query(IPAddr).\
filter_by(node=node.id).\
filter_by(network=admin_net_id).all()
filter_by(network=admin_ng_id).all()
self.assertEquals(len(admin_ips), 2)
map(
lambda x: self.assertIn(
@ -280,12 +276,11 @@ class TestNetworkManager(BaseIntegrationTest):
def test_assign_admin_ips_large_range(self):
map(self.db.delete, self.db.query(IPAddrRange).all())
admin_net_id = self.env.network_manager.get_admin_network_id()
admin_ng = self.db.query(Network).get(admin_net_id).network_group
admin_ng_id = self.env.network_manager.get_admin_network_group_id()
mock_range = IPAddrRange(
first='10.0.0.1',
last='10.255.255.254',
network_group_id=admin_ng.id
network_group_id=admin_ng_id
)
self.db.add(mock_range)
self.db.commit()
@ -300,7 +295,7 @@ class TestNetworkManager(BaseIntegrationTest):
# Asserting count of admin node IPs
def asserter(x):
n, c = x
l = len(self.db.query(IPAddr).filter_by(network=admin_net_id).
l = len(self.db.query(IPAddr).filter_by(network=admin_ng_id).
filter_by(node=n).all())
self.assertEquals(l, c)
map(asserter, nc)
@ -308,7 +303,7 @@ class TestNetworkManager(BaseIntegrationTest):
def test_assign_admin_ips_idempotent(self):
node = self.env.create_node()
self.env.network_manager.assign_admin_ips(node.id, 2)
admin_net_id = self.env.network_manager.get_admin_network_id()
admin_net_id = self.env.network_manager.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()])
@ -320,12 +315,11 @@ 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_id()
admin_ng = self.db.query(Network).get(admin_net_id).network_group
admin_net_id = self.env.network_manager.get_admin_network_group_id()
mock_range = IPAddrRange(
first='10.0.0.1',
last='10.0.0.1',
network_group_id=admin_ng.id
network_group_id=admin_net_id
)
self.db.add(mock_range)
self.db.commit()
@ -333,7 +327,7 @@ class TestNetworkManager(BaseIntegrationTest):
node = self.env.create_node()
self.env.network_manager.assign_admin_ips(node.id, 1)
admin_net_id = self.env.network_manager.get_admin_network_id()
admin_net_id = self.env.network_manager.get_admin_network_group_id()
admin_ips = self.db.query(IPAddr).\
filter_by(node=node.id).\
@ -415,7 +409,8 @@ class TestNovaNetworkManager(BaseIntegrationTest):
interfaces = deepcopy(node_db.meta['interfaces'])
# allocate ip from admin subnet
admin_ip = str(IPNetwork(NetworkManager.get_admin_network().cidr)[0])
admin_ip = str(IPNetwork(
NetworkManager.get_admin_network_group().cidr)[0])
for interface in interfaces:
if interface['mac'] == admin_nic.mac:
# reset admin ip for previous admin interface
@ -470,7 +465,8 @@ class TestNeutronManager(BaseIntegrationTest):
interfaces = deepcopy(node_db.meta['interfaces'])
# allocate ip from admin subnet
admin_ip = str(IPNetwork(NetworkManager.get_admin_network().cidr)[0])
admin_ip = str(IPNetwork(
NetworkManager.get_admin_network_group().cidr)[0])
for interface in interfaces:
if interface['mac'] == admin_nic.mac:
# reset admin ip for previous admin interface

48
nailgun/nailgun/test/integration/test_network_models.py
View File

@ -18,9 +18,7 @@ import json
from sqlalchemy.sql import not_
from nailgun.db.sqlalchemy.models import Network
from nailgun.db.sqlalchemy.models import NetworkGroup
from nailgun.db.sqlalchemy.models import Vlan
from nailgun.test.base import BaseIntegrationTest
from nailgun.test.base import fake_tasks
from nailgun.test.base import reverse
@ -44,12 +42,12 @@ class TestNetworkModels(BaseIntegrationTest):
ng = NetworkGroup(**kw)
self.db.add(ng)
self.db.commit()
self.env.network_manager.create_networks(ng)
nets_db = self.db.query(Network).filter(
not_(Network.name == "fuelweb_admin")
self.env.network_manager.cleanup_network_group(ng)
nets_db = self.db.query(NetworkGroup).filter(
not_(NetworkGroup.name == "fuelweb_admin")
).all()
self.assertEquals(len(nets_db), 1)
self.assertEquals(nets_db[0].vlan_id, kw['vlan_start'])
self.assertEquals(nets_db[0].vlan_start, kw['vlan_start'])
self.assertEquals(nets_db[0].name, kw['name'])
self.assertEquals(nets_db[0].cidr, kw['cidr'])
@ -112,17 +110,13 @@ class TestNetworkModels(BaseIntegrationTest):
ng = NetworkGroup(**kw)
self.db.add(ng)
self.db.commit()
self.env.network_manager.create_networks(ng)
nets_db = self.db.query(Network).filter(
not_(Network.name == "fuelweb_admin")
self.env.network_manager.cleanup_network_group(ng)
nets_db = self.db.query(NetworkGroup).filter(
not_(NetworkGroup.name == "fuelweb_admin")
).all()
self.assertEquals(len(nets_db), kw['amount'])
self.assertEquals(nets_db[0].vlan_id, kw['vlan_start'])
self.assertEquals(nets_db[kw['amount'] - 1].vlan_id,
kw['vlan_start'] + kw['amount'] - 1)
self.assertEquals(nets_db[0].amount, kw['amount'])
self.assertEquals(nets_db[0].vlan_start, kw['vlan_start'])
self.assertEquals(all(x.name == kw['name'] for x in nets_db), True)
vlans_db = self.db.query(Vlan).all()
self.assertEquals(len(vlans_db), kw['amount'])
def test_network_group_slices_cidr_for_networks(self):
cluster = self.env.create_cluster(api=False)
@ -137,13 +131,12 @@ class TestNetworkModels(BaseIntegrationTest):
ng = NetworkGroup(**kw)
self.db.add(ng)
self.db.commit()
self.env.network_manager.create_networks(ng)
nets_db = self.db.query(Network).filter(
not_(Network.name == "fuelweb_admin")
self.env.network_manager.cleanup_network_group(ng)
nets_db = self.db.query(NetworkGroup).filter(
not_(NetworkGroup.name == "fuelweb_admin")
).all()
self.assertEquals(len(nets_db), kw['amount'])
self.assertEquals(nets_db[0].cidr, '10.0.0.0/25')
self.assertEquals(nets_db[1].cidr, '10.0.0.128/25')
self.assertEquals(nets_db[0].amount, kw['amount'])
self.assertEquals(nets_db[0].cidr, '10.0.0.0/16')
self.db.refresh(ng)
self.assertEquals(ng.cidr, '10.0.0.0/16')
@ -160,7 +153,7 @@ class TestNetworkModels(BaseIntegrationTest):
ng = NetworkGroup(**kw)
self.db.add(ng)
self.db.commit()
self.env.network_manager.create_networks(ng)
self.env.network_manager.cleanup_network_group(ng)
self.db.refresh(ng)
self.assertEquals(ng.cidr, "172.0.0.0/24")
@ -177,7 +170,7 @@ class TestNetworkModels(BaseIntegrationTest):
ng = NetworkGroup(**kw)
self.db.add(ng)
self.db.commit()
self.env.network_manager.create_networks(ng)
self.env.network_manager.cleanup_network_group(ng)
self.db.refresh(ng)
self.assertEquals(ng.cidr, "172.0.0.0/8")
@ -195,10 +188,9 @@ class TestNetworkModels(BaseIntegrationTest):
ng = NetworkGroup(**kw)
self.db.add(ng)
self.db.commit()
self.env.network_manager.create_networks(ng)
nets_db = self.db.query(Network).filter(
not_(Network.name == "fuelweb_admin")
self.env.network_manager.cleanup_network_group(ng)
nets_db = self.db.query(NetworkGroup).filter(
not_(NetworkGroup.name == "fuelweb_admin")
).all()
self.assertEquals(len(nets_db), kw['amount'])
self.assertEquals(nets_db[0].amount, kw['amount'])
self.assertEquals(nets_db[0].gateway, "10.0.0.5")
self.assertEquals(nets_db[1].gateway, "10.0.0.5")

5
nailgun/nailgun/test/integration/test_orchestrator_serializer.py
View File

@ -19,7 +19,6 @@ import json
from nailgun.db import db
from nailgun.db.sqlalchemy.models import Cluster
from nailgun.db.sqlalchemy.models import IPAddrRange
from nailgun.db.sqlalchemy.models import Network
from nailgun.db.sqlalchemy.models import NetworkGroup
from nailgun.db.sqlalchemy.models import Node
from nailgun.orchestrator.deployment_serializers \
@ -238,8 +237,8 @@ class TestNovaOrchestratorSerializer(OrchestratorSerializerTestBase):
'172.16.0.10-172.16.0.12'])
def test_configure_interfaces_untagged_network(self):
for network in self.db.query(Network).all():
network.vlan_id = None
for network in self.db.query(NetworkGroup).all():
network.vlan_start = None
self.db.commit()
node_db = sorted(self.cluster.nodes, key=lambda n: n.id)[0]
from nailgun.orchestrator.deployment_serializers \

17
nailgun/nailgun/test/integration/test_rpc_consumer.py
View File

@ -21,12 +21,10 @@ import uuid
from nailgun.db.sqlalchemy.models import Attributes
from nailgun.db.sqlalchemy.models import Cluster
from nailgun.db.sqlalchemy.models import IPAddr
from nailgun.db.sqlalchemy.models import Network
from nailgun.db.sqlalchemy.models import NetworkGroup
from nailgun.db.sqlalchemy.models import Node
from nailgun.db.sqlalchemy.models import Notification
from nailgun.db.sqlalchemy.models import Task
from nailgun.db.sqlalchemy.models import Vlan
from nailgun.rpc import receiver as rcvr
from nailgun.test.base import BaseIntegrationTest
from nailgun.test.base import reverse
@ -859,13 +857,12 @@ class TestConsumer(BaseIntegrationTest):
self.env.create_notification(
cluster_id=cluster_id
)
networks = self.db.query(Network)\
.join(NetworkGroup).\
networks = self.db.query(NetworkGroup).\
filter(NetworkGroup.cluster_id == cluster_id).all()
vlans = []
for net in networks:
vlans.append(net.vlan_id)
vlans.append(net.vlan_start)
task = Task(
uuid=str(uuid.uuid4()),
@ -893,10 +890,6 @@ class TestConsumer(BaseIntegrationTest):
.filter(IPAddr.node.in_([node1_id, node2_id])).all()
self.assertEquals(len(ip_db), 0)
vlan_db = self.db.query(Vlan)\
.filter(Vlan.id.in_(vlans)).all()
self.assertEquals(len(vlan_db), 0)
attrs_db = self.db.query(Attributes)\
.filter_by(cluster_id=cluster_id).all()
self.assertEquals(len(attrs_db), 0)
@ -905,8 +898,7 @@ class TestConsumer(BaseIntegrationTest):
.filter_by(cluster_id=cluster_id).all()
self.assertEquals(len(nots_db), 0)
nets_db = self.db.query(Network)\
.join(NetworkGroup).\
nets_db = self.db.query(NetworkGroup).\
filter(NetworkGroup.cluster_id == cluster_id).all()
self.assertEquals(len(nets_db), 0)
@ -963,7 +955,6 @@ class TestConsumer(BaseIntegrationTest):
.filter_by(cluster_id=cluster_db.id).all()
self.assertNotEqual(len(nots_db), 0)
nets_db = self.db.query(Network)\
.join(NetworkGroup).\
nets_db = self.db.query(NetworkGroup).\
filter(NetworkGroup.cluster_id == cluster_db.id).all()
self.assertNotEqual(len(nets_db), 0)

3
nailgun/nailgun/test/unit/test_node_deletion.py
View File

@ -19,7 +19,6 @@ import logging
from mock import patch
from nailgun.db.sqlalchemy.models import IPAddr
from nailgun.db.sqlalchemy.models import Network
from nailgun.db.sqlalchemy.models import NetworkGroup
from nailgun.db.sqlalchemy.models import Node
from nailgun.test.base import BaseIntegrationTest
@ -59,7 +58,7 @@ class TestNodeDeletion(BaseIntegrationTest):
).first()
self.assertEquals(node_try, None)
management_net = self.db.query(Network).join(NetworkGroup).\
management_net = self.db.query(NetworkGroup).\
filter(NetworkGroup.cluster_id == cluster.id).filter_by(
name='management').first()