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()