def create_network_groups(cls, cluster, neutron_segment_type, gid=None):
"""Method for creation of network groups for cluster.
:param cluster: Cluster instance.
:type cluster: instance
:returns: None
"""
group_id = gid or objects.Cluster.get_default_group(cluster).id
networks_metadata = cluster.release.networks_metadata
networks_list = networks_metadata[cluster.net_provider]["networks"]
used_nets = [IPNetwork(cls.get_admin_network_group().cidr)]
def check_range_in_use_already(cidr_range):
for n in used_nets:
if cls.is_range_intersection(n, cidr_range):
logger.warn(
"IP range {0} is in use already".format(cidr_range))
break
used_nets.append(cidr_range)
for net in networks_list:
if "seg_type" in net \
and neutron_segment_type != net['seg_type']:
continue
vlan_start = net.get("vlan_start")
cidr, gw, cidr_gw = None, None, None
if net.get("notation"):
if net.get("cidr"):
cidr = IPNetwork(net["cidr"]).cidr
cidr_gw = str(cidr[1])
if net["notation"] == 'cidr' and cidr:
new_ip_range = IPAddrRange(first=str(cidr[2]),
last=str(cidr[-2]))
if net.get('use_gateway'):
gw = cidr_gw
else:
new_ip_range.first = cidr_gw
check_range_in_use_already(cidr)
elif net["notation"] == 'ip_ranges' and net.get("ip_range"):
new_ip_range = IPAddrRange(first=net["ip_range"][0],
last=net["ip_range"][1])
gw = net.get('gateway') or cidr_gw \
if net.get('use_gateway') else None
check_range_in_use_already(
IPRange(new_ip_range.first, new_ip_range.last))
if net['name'] == "management":
gw = "192.168.0.254" #set default manage gateway
nw_group = NetworkGroup(release=cluster.release.id,
name=net['name'],
cidr=str(cidr) if cidr else None,
gateway=gw,
group_id=group_id,
vlan_start=vlan_start,
meta=net)
db().add(nw_group)
db().flush()
if net.get("notation"):
nw_group.ip_ranges.append(new_ip_range)
db().flush()
cls.cleanup_network_group(nw_group)
def test_assign_admin_ip_multiple_groups(self):
self.env.create(cluster_kwargs={
'api': False,
'net_provider': 'neutron',
'net_segment_type': 'gre'
},
nodes_kwargs=[{}, {}])
node_group = self.env.create_node_group()
self.env.nodes[1].group_id = node_group.json_body['id']
self.db().flush()
admin_net =\
self.env.network_manager.get_admin_network_group(
self.env.nodes[1].id
)
mock_range = IPAddrRange(first='9.9.9.1',
last='9.9.9.254',
network_group_id=admin_net.id)
self.db.add(mock_range)
self.db.commit()
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)
ip = self.db.query(IPAddr).\
filter_by(network=admin_net.id).\
filter_by(node=n.id).first()
self.assertIn(IPAddress(ip.ip_addr), IPNetwork(admin_net.cidr))
def test_assign_admin_ips_large_range(self):
map(self.db.delete, self.db.query(IPAddrRange).all())
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)
self.db.add(mock_range)
self.db.commit()
# Creating two nodes
n1 = self.env.create_node()
n2 = self.env.create_node()
nc = zip([n1.id, n2.id], [2048, 2])
# Assinging admin IPs on created nodes
map(lambda (n, c): self.env.network_manager.assign_admin_ips(n, c), nc)
# Asserting count of admin node IPs
def asserter(x):
n, c = x
l = len(
self.db.query(IPAddr).filter_by(network=admin_ng_id).filter_by(
node=n).all())
self.assertEquals(l, c)
map(asserter, nc)
def create_network_groups(cls, cluster_id):
"""Method for creation of network groups for cluster.
:param cluster_id: Cluster database ID.
:type cluster_id: int
:returns: None
:raises: errors.OutOfVLANs, errors.OutOfIPs,
errors.NoSuitableCIDR
"""
cluster_db = db().query(Cluster).get(cluster_id)
networks_metadata = \
cluster_db.release.networks_metadata["nova_network"]
for network in networks_metadata["networks"]:
new_ip_range = IPAddrRange(first=network["ip_range"][0],
last=network["ip_range"][1])
gw = network['gateway'] if network.get('use_gateway') else None
nw_group = NetworkGroup(release=cluster_db.release.id,
name=network['name'],
cidr=network['cidr'],
netmask=network['netmask'],
gateway=gw,
cluster_id=cluster_id,
vlan_start=network['vlan_start'],
amount=1,
network_size=network['network_size']
if 'network_size' in network else 256)
db().add(nw_group)
db().commit()
nw_group.ip_ranges.append(new_ip_range)
db().commit()
cls.cleanup_network_group(nw_group)
def test_floatin_ranges_generation(self):
# Set ip ranges for floating ips
ranges = [['172.16.0.2', '172.16.0.4'],
['172.16.0.3', '172.16.0.5'],
['172.16.0.10', '172.16.0.12']]
floating_network_group = self.db.query(NetworkGroup).filter(
NetworkGroup.name == 'floating'
).filter(
NetworkGroup.cluster_id == self.cluster.id).first()
# Remove floating ip addr ranges
self.db.query(IPAddrRange).filter(
IPAddrRange.network_group_id == floating_network_group.id).delete()
# Add new ranges
for ip_range in ranges:
new_ip_range = IPAddrRange(
first=ip_range[0],
last=ip_range[1],
network_group_id=floating_network_group.id)
self.db.add(new_ip_range)
self.db.commit()
facts = self.serializer.serialize(self.cluster, self.cluster.nodes)
for fact in facts:
self.assertEquals(
fact['floating_network_range'],
['172.16.0.2-172.16.0.4',
'172.16.0.3-172.16.0.5',
'172.16.0.10-172.16.0.12'])
def _set_ip_ranges(cls, network_group_id, ip_ranges):
# deleting old ip ranges
db().query(IPAddrRange).filter_by(
network_group_id=network_group_id).delete()
for r in ip_ranges:
new_ip_range = IPAddrRange(first=r[0],
last=r[1],
network_group_id=network_group_id)
db().add(new_ip_range)
db().commit()
def update_range_mask_from_cidr(cls, network_group, cidr):
"""Update network ranges for cidr
"""
db().query(IPAddrRange).filter_by(
network_group_id=network_group.id).delete()
new_cidr = IPNetwork(cidr)
ip_range = IPAddrRange(network_group_id=network_group.id,
first=str(new_cidr[2]),
last=str(new_cidr[-2]))
db().add(ip_range)
db().commit()
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()
mock_range = IPAddrRange(first='10.0.0.1',
last='10.0.0.1',
network_group_id=admin_net_id)
self.db.add(mock_range)
self.db.commit()
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_ips = self.db.query(IPAddr).\
filter_by(node=node.id).\
filter_by(network=admin_net_id).all()
self.assertEqual(len(admin_ips), 1)
self.assertEqual(admin_ips[0].ip_addr, '10.0.0.1')
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()
mock_range = IPAddrRange(first='10.0.0.1',
last='10.0.0.2',
network_group_id=admin_net_id)
self.db.add(mock_range)
self.db.commit()
n1 = self.env.create_node()
n2 = self.env.create_node()
nc = [n1, n2]
self.env.network_manager.assign_admin_ips(nc)
admin_net_id = self.env.network_manager.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).\
filter_by(node=node.id).\
filter_by(network=admin_net_id).all()
self.assertEqual(len(admin_ips), 1)
self.assertEqual(admin_ips[0].ip_addr, ip)
def create_network_groups(cls, cluster_id):
"""Method for creation of network groups for cluster.
:param cluster_id: Cluster database ID.
:type cluster_id: int
:returns: None
:raises: errors.InvalidNetworkCIDR
"""
cluster_db = db().query(Cluster).get(cluster_id)
networks_metadata = cluster_db.release.networks_metadata
networks_list = networks_metadata[cluster_db.net_provider]["networks"]
used_nets = [IPNetwork(cls.get_admin_network_group().cidr)]
def check_range_in_use_already(cidr_range):
for n in used_nets:
if cls.is_range_intersection(n, cidr_range):
raise errors.InvalidNetworkCIDR(
u"CIDR/range '{0}' of '{1}' network intersects "
u"with IP range '{2}' of other network".format(
str(cidr_range), net['name'], str(n)))
used_nets.append(cidr_range)
for net in networks_list:
if "seg_type" in net and \
cluster_db.net_segment_type != net['seg_type']:
continue
vlan_start = net.get("vlan_start")
net_size = net.get('network_size')
cidr, gw, cidr_gw, netmask = None, None, None, None
if net.get("notation"):
if net.get("cidr"):
cidr = IPNetwork(net["cidr"]).cidr
cidr_gw = str(cidr[1])
netmask = str(cidr.netmask)
net_size = net_size or cidr.size
if net["notation"] == 'cidr' and cidr:
new_ip_range = IPAddrRange(
first=str(cidr[2]),
last=str(cidr[-2])
)
if net.get('use_gateway'):
gw = cidr_gw
else:
new_ip_range.first = cidr_gw
check_range_in_use_already(cidr)
elif net["notation"] == 'ip_ranges' and net.get("ip_range"):
new_ip_range = IPAddrRange(
first=net["ip_range"][0],
last=net["ip_range"][1]
)
gw = net.get('gateway') or cidr_gw \
if net.get('use_gateway') else None
netmask = net.get('netmask') or netmask
check_range_in_use_already(IPRange(new_ip_range.first,
new_ip_range.last))
nw_group = NetworkGroup(
release=cluster_db.release.id,
name=net['name'],
cidr=str(cidr) if cidr else None,
netmask=netmask,
gateway=gw,
cluster_id=cluster_id,
vlan_start=vlan_start,
amount=1,
network_size=net_size or 1,
meta=net
)
db().add(nw_group)
db().commit()
if net.get("notation"):
nw_group.ip_ranges.append(new_ip_range)
db().commit()
cls.cleanup_network_group(nw_group)
def create_network_groups(cls, cluster, neutron_segment_type, gid=None):
"""Method for creation of network groups for cluster.
:param cluster: Cluster instance.
:type cluster: instance
:returns: None
"""
group_id = gid or objects.Cluster.get_default_group(cluster).id
networks_metadata = cluster.release.networks_metadata
networks_list = networks_metadata[cluster.net_provider]["networks"]
used_nets = [IPNetwork(cls.get_admin_network_group().cidr)]
def check_range_in_use_already(cidr_range):
for n in used_nets:
if cls.is_range_intersection(n, cidr_range):
logger.warn("IP range {0} is in use already".format(
cidr_range))
break
used_nets.append(cidr_range)
for net in networks_list:
if "seg_type" in net \
and neutron_segment_type != net['seg_type']:
continue
vlan_start = net.get("vlan_start")
cidr, gw, cidr_gw = None, None, None
if net.get("notation"):
if net.get("cidr"):
cidr = IPNetwork(net["cidr"]).cidr
cidr_gw = str(cidr[1])
if net["notation"] == 'cidr' and cidr:
new_ip_range = IPAddrRange(
first=str(cidr[2]),
last=str(cidr[-2])
)
if net.get('use_gateway'):
gw = cidr_gw
else:
new_ip_range.first = cidr_gw
check_range_in_use_already(cidr)
elif net["notation"] == 'ip_ranges' and net.get("ip_range"):
new_ip_range = IPAddrRange(
first=net["ip_range"][0],
last=net["ip_range"][1]
)
gw = net.get('gateway') or cidr_gw \
if net.get('use_gateway') else None
check_range_in_use_already(IPRange(new_ip_range.first,
new_ip_range.last))
nw_group = NetworkGroup(
release=cluster.release.id,
name=net['name'],
cidr=str(cidr) if cidr else None,
gateway=gw,
group_id=group_id,
vlan_start=vlan_start,
meta=net
)
db().add(nw_group)
db().flush()
if net.get("notation"):
nw_group.ip_ranges.append(new_ip_range)
db().flush()
cls.cleanup_network_group(nw_group)
def create_network_groups(cls, cluster_id):
"""Method for creation of network groups for cluster.
:param cluster_id: Cluster database ID.
:type cluster_id: int
:returns: None
:raises: errors.InvalidNetworkCIDR
"""
cluster_db = db().query(Cluster).get(cluster_id)
networks_metadata = cluster_db.release.networks_metadata
networks_list = networks_metadata[cluster_db.net_provider]["networks"]
used_nets = [IPNetwork(cls.get_admin_network_group().cidr)]
def check_range_in_use_already(cidr_range):
for n in used_nets:
if cls.is_range_intersection(n, cidr_range):
logger.warn(
"IP range {0} is in use already".format(cidr_range))
break
used_nets.append(cidr_range)
for net in networks_list:
if "seg_type" in net and \
cluster_db.net_segment_type != net['seg_type']:
continue
vlan_start = net.get("vlan_start")
net_size = net.get('network_size')
cidr, gw, cidr_gw, netmask = None, None, None, None
if net.get("notation"):
if net.get("cidr"):
cidr = IPNetwork(net["cidr"]).cidr
cidr_gw = str(cidr[1])
netmask = str(cidr.netmask)
net_size = net_size or cidr.size
if net["notation"] == 'cidr' and cidr:
new_ip_range = IPAddrRange(first=str(cidr[2]),
last=str(cidr[-2]))
if net.get('use_gateway'):
gw = cidr_gw
else:
new_ip_range.first = cidr_gw
check_range_in_use_already(cidr)
elif net["notation"] == 'ip_ranges' and net.get("ip_range"):
new_ip_range = IPAddrRange(first=net["ip_range"][0],
last=net["ip_range"][1])
gw = net.get('gateway') or cidr_gw \
if net.get('use_gateway') else None
netmask = net.get('netmask') or netmask
check_range_in_use_already(
IPRange(new_ip_range.first, new_ip_range.last))
nw_group = NetworkGroup(release=cluster_db.release.id,
name=net['name'],
cidr=str(cidr) if cidr else None,
netmask=netmask,
gateway=gw,
cluster_id=cluster_id,
vlan_start=vlan_start,
amount=1,
network_size=net_size or 1,
meta=net)
db().add(nw_group)
db().commit()
if net.get("notation"):
nw_group.ip_ranges.append(new_ip_range)
db().commit()
cls.cleanup_network_group(nw_group)
def create_network_groups(cls, cluster_id):
'''Method for creation of network groups for cluster.
:param cluster_id: Cluster database ID.
:type cluster_id: int
:returns: None
:raises: errors.OutOfVLANs, errors.OutOfIPs,
errors.NoSuitableCIDR
'''
used_nets = []
used_vlans = []
global_params = db().query(GlobalParameters).first()
cluster_db = db().query(Cluster).get(cluster_id)
networks_metadata = cluster_db.release.networks_metadata
admin_network_range = db().query(IPAddrRange).filter_by(
network_group_id=cls.get_admin_network_group_id()).all()[0]
networks_list = networks_metadata["neutron"]["networks"]
def _free_vlans():
free_vlans = set(range(
*global_params.parameters["vlan_range"])) - set(used_vlans)
if not free_vlans or len(free_vlans) < len(networks_list):
raise errors.OutOfVLANs()
return sorted(list(free_vlans))
for network in networks_list:
free_vlans = _free_vlans()
vlan_start = free_vlans[0] if "vlan_start" not in network \
else network.get("vlan_start")
if vlan_start and vlan_start not in free_vlans:
vlan_start = free_vlans[0]
logger.debug("Found free vlan: %s", vlan_start)
pool = network.get('pool')
if not pool:
raise errors.InvalidNetworkPool(
u"Invalid pool '{0}' for network '{1}'".format(
pool, network['name']))
nets_free_set = IPSet(pool) -\
IPSet(
IPNetwork(global_params.parameters["net_exclude"])
) -\
IPSet(
IPRange(
admin_network_range.first,
admin_network_range.last
)
) -\
IPSet(used_nets)
if not nets_free_set:
raise errors.OutOfIPs()
free_cidrs = sorted(list(nets_free_set._cidrs))
new_net = None
for fcidr in free_cidrs:
for n in fcidr.subnet(24, count=1):
new_net = n
break
if new_net:
break
if not new_net:
raise errors.NoSuitableCIDR()
if network.get("ip_range"):
new_ip_range = IPAddrRange(first=network["ip_range"][0],
last=network["ip_range"][1])
else:
new_ip_range = IPAddrRange(first=str(new_net[2]),
last=str(new_net[-2]))
gw = str(new_net[1]) if network.get('use_gateway') else None
nw_group = NetworkGroup(release=cluster_db.release.id,
name=network['name'],
cidr=str(new_net),
netmask=str(new_net.netmask),
gateway=gw,
cluster_id=cluster_id,
vlan_start=vlan_start,
amount=1)
db().add(nw_group)
db().commit()
nw_group.ip_ranges.append(new_ip_range)
db().commit()
cls.cleanup_network_group(nw_group)
used_vlans.append(vlan_start)
used_nets.append(str(new_net))
if cluster_db.net_segment_type == 'vlan':
private_network_group = NetworkGroup(release=cluster_db.release.id,
name="private",
cluster_id=cluster_id,
netmask='32',
vlan_start=None,
amount=1)
db().add(private_network_group)
db().commit()
