def build_ipv4(anm, infrastructure=True): """Builds IPv4 graph""" g_ipv4 = anm.add_overlay("ipv4") g_in = anm['input'] g_graphics = anm['graphics'] g_phy = anm['phy'] g_ipv4.add_nodes_from(g_in) g_ipv4.add_edges_from(g_in.edges(type="physical")) ank_utils.aggregate_nodes(g_ipv4, g_ipv4.nodes("is_switch"), retain="edge_id") edges_to_split = [edge for edge in g_ipv4.edges() if edge.attr_both( "is_l3device")] split_created_nodes = list( ank_utils.split(g_ipv4, edges_to_split, retain='edge_id')) for node in split_created_nodes: node['graphics'].x = ank_utils.neigh_average(g_ipv4, node, "x", g_graphics) + 0.1 # temporary fix for gh-90 node['graphics'].y = ank_utils.neigh_average(g_ipv4, node, "y", g_graphics) + 0.1 # temporary fix for gh-90 asn = ank_utils.neigh_most_frequent( g_ipv4, node, "asn", g_phy) # arbitrary choice node['graphics'].asn = asn node.asn = asn # need to use asn in IP overlay for aggregating subnets switch_nodes = g_ipv4.nodes("is_switch") # regenerate due to aggregated g_ipv4.update(switch_nodes, collision_domain=True) # switches are part of collision domain g_ipv4.update(split_created_nodes, collision_domain=True) # Assign collision domain to a host if all neighbours from same host for node in split_created_nodes: if ank_utils.neigh_equal(g_ipv4, node, "host", g_phy): node.host = ank_utils.neigh_attr( g_ipv4, node, "host", g_phy).next() # first attribute # set collision domain IPs for node in g_ipv4.nodes("collision_domain"): graphics_node = g_graphics.node(node) graphics_node.device_type = "collision_domain" if not node.is_switch: label = "_".join( sorted(ank_utils.neigh_attr(g_ipv4, node, "label", g_phy))) cd_label = "cd_%s" % label # switches keep their names node.label = cd_label node.cd_id = cd_label graphics_node.label = cd_label #TODO: need to set allocate_ipv4 by default in the readers if g_in.data.allocate_ipv4 is False: manual_ipv4_allocation(anm) else: import autonetkit.plugins.ipv4 as ipv4 ipv4.allocate_ips(g_ipv4, infrastructure) ank_utils.save(g_ipv4)
def build_ip(anm): g_ip = anm.add_overlay("ip") g_in = anm['input'] g_graphics = anm['graphics'] g_phy = anm['phy'] g_ip.add_nodes_from(g_in) g_ip.add_edges_from(g_in.edges(type="physical")) ank_utils.aggregate_nodes(g_ip, g_ip.nodes("is_switch"), retain="edge_id") edges_to_split = [edge for edge in g_ip.edges() if edge.attr_both( "is_l3device")] for edge in edges_to_split: edge.split = True # mark as split for use in building nidb split_created_nodes = list( ank_utils.split(g_ip, edges_to_split, retain=['edge_id', 'split'])) for node in split_created_nodes: node['graphics'].x = ank_utils.neigh_average(g_ip, node, "x", g_graphics) + 0.1 # temporary fix for gh-90 node['graphics'].y = ank_utils.neigh_average(g_ip, node, "y", g_graphics) + 0.1 # temporary fix for gh-90 asn = ank_utils.neigh_most_frequent( g_ip, node, "asn", g_phy) # arbitrary choice node['graphics'].asn = asn node.asn = asn # need to use asn in IP overlay for aggregating subnets switch_nodes = g_ip.nodes("is_switch") # regenerate due to aggregated g_ip.update(switch_nodes, collision_domain=True) # switches are part of collision domain g_ip.update(split_created_nodes, collision_domain=True) # Assign collision domain to a host if all neighbours from same host for node in split_created_nodes: if ank_utils.neigh_equal(g_ip, node, "host", g_phy): node.host = ank_utils.neigh_attr( g_ip, node, "host", g_phy).next() # first attribute # set collision domain IPs for node in g_ip.nodes("collision_domain"): graphics_node = g_graphics.node(node) graphics_node.device_type = "collision_domain" if not node.is_switch: label = "_".join( sorted(ank_utils.neigh_attr(g_ip, node, "label", g_phy))) cd_label = "cd_%s" % label # switches keep their names node.label = cd_label node.cd_id = cd_label graphics_node.label = cd_label
def build_ip(anm): import autonetkit.plugins.ipv4 as ip G_ip = anm.add_overlay("ip") G_in = anm['input'] G_graphics = anm['graphics'] G_phy = anm['phy'] G_ip.add_nodes_from(G_in) G_ip.add_edges_from(G_in.edges(type="physical")) ank.aggregate_nodes(G_ip, G_ip.nodes("is_switch"), retain = "edge_id") edges_to_split = [edge for edge in G_ip.edges() if edge.attr_both("is_l3device")] split_created_nodes = list(ank.split(G_ip, edges_to_split, retain='edge_id')) for node in split_created_nodes: node['graphics'].x = ank.neigh_average(G_ip, node, "x", G_graphics) node['graphics'].y = ank.neigh_average(G_ip, node, "y", G_graphics) G_ip.update(split_created_nodes, collision_domain=True) for node in G_ip.nodes("collision_domain"): graphics_node = G_graphics.node(node) node.host = G_phy.node(node.neighbors().next()).host # Set host to be same as one of the neighbors (arbitrary choice) asn = ank.neigh_most_frequent(G_ip, node, "asn", G_phy) # arbitrary choice node.asn = asn graphics_node.asn = asn graphics_node.x = ank.neigh_average(G_ip, node, "x", G_graphics) graphics_node.device_type = "collision_domain" cd_label = "cd_" + "_".join(sorted(ank.neigh_attr(G_ip, node, "label", G_phy))) node.label = cd_label graphics_node.label = cd_label ip.allocate_ips(G_ip)
def assign_asn_to_interasn_cds(g_ip, address_block = None): G_phy = g_ip.overlay("phy") for collision_domain in g_ip.nodes("collision_domain"): neigh_asn = list(ank_utils.neigh_attr(g_ip, collision_domain, "asn", G_phy)) #asn of neighbors if len(set(neigh_asn)) == 1: asn = set(neigh_asn).pop() # asn of any neigh, as all same else: asn = ank_utils.most_frequent(neigh_asn) # allocate cd to asn with most neighbors in it collision_domain.asn = asn return
def assign_asn_to_interasn_cds(g_ip, address_block=None): G_phy = g_ip.overlay('phy') for broadcast_domain in g_ip.nodes('broadcast_domain'): neigh_asn = list(ank_utils.neigh_attr(g_ip, broadcast_domain, 'asn', G_phy)) # asn of neighbors if len(set(neigh_asn)) == 1: asn = set(neigh_asn).pop() # asn of any neigh, as all same else: asn = ank_utils.most_frequent(neigh_asn) # allocate cd to asn with most neighbors in it broadcast_domain.asn = asn return
def assign_asn_to_interasn_cds(G_ip): #TODO: rename to assign_asn_to_cds as also does intra-asn cds #TODO: make this a common function to ip4 and ip6 G_phy = G_ip.overlay("phy") for collision_domain in G_ip.nodes("collision_domain"): neigh_asn = list(ank_utils.neigh_attr(G_ip, collision_domain, "asn", G_phy)) #asn of neighbors if len(set(neigh_asn)) == 1: asn = set(neigh_asn).pop() # asn of any neigh, as all same else: asn = ank_utils.most_frequent(neigh_asn) # allocate cd to asn with most neighbors in it collision_domain.asn = asn return
def assign_asn_to_interasn_cds(G_ip): #TODO: remove this if no longer needed # TODO: rename to assign_asn_to_cds as also does intra-asn cds # TODO: make this a common function to ip4 and ip6 G_phy = G_ip.overlay('phy') for broadcast_domain in G_ip.nodes('broadcast_domain'): neigh_asn = list(ank_utils.neigh_attr(G_ip, broadcast_domain, 'asn', G_phy)) # asn of neighbors if len(set(neigh_asn)) == 1: asn = set(neigh_asn).pop() # asn of any neigh, as all same else: asn = ank_utils.most_frequent(neigh_asn) # allocate bc to asn with most neighbors in it broadcast_domain.asn = asn return
def build_layer2_broadcast(anm): g_l2 = anm['layer2'] g_phy = anm['phy'] g_graphics = anm['graphics'] g_l2_bc = anm.add_overlay('layer2_bc') g_l2_bc.add_nodes_from(g_l2.l3devices()) g_l2_bc.add_nodes_from(g_l2.switches()) g_l2_bc.add_edges_from(g_l2.edges(), retain=['link_type']) # remove external connectors edges_to_split = [edge for edge in g_l2_bc.edges() if edge.src.is_l3device() and edge.dst.is_l3device()] # TODO: debug the edges to split for edge in edges_to_split: edge.split = True # mark as split for use in building nidb split_created_nodes = list(ank_utils.split(g_l2_bc, edges_to_split, retain=['split'], id_prepend='cd_')) # TODO: if parallel nodes, offset # TODO: remove graphics, assign directly if len(g_graphics): co_ords_overlay = g_graphics # source from graphics overlay else: co_ords_overlay = g_phy # source from phy overlay for node in split_created_nodes: node['graphics'].x = ank_utils.neigh_average(g_l2_bc, node, 'x', co_ords_overlay) + 0.1 # temporary fix for gh-90 node['graphics'].y = ank_utils.neigh_average(g_l2_bc, node, 'y', co_ords_overlay) + 0.1 # temporary fix for gh-90 asn = ank_utils.neigh_most_frequent( g_l2_bc, node, 'asn', g_phy) # arbitrary choice node['graphics'].asn = asn node.asn = asn # need to use asn in IP overlay for aggregating subnets # also allocate an ASN for virtual switches vswitches = [n for n in g_l2_bc.nodes() if n['layer2'].device_type == "switch" and n['layer2'].device_subtype == "virtual"] for node in vswitches: # TODO: refactor neigh_most_frequent to allow fallthrough attributes # asn = ank_utils.neigh_most_frequent(g_l2_bc, node, 'asn', g_l2) # # arbitrary choice asns = [n['layer2'].asn for n in node.neighbors()] asns = [x for x in asns if x is not None] asn = ank_utils.most_frequent(asns) node.asn = asn # need to use asn in IP overlay for aggregating subnets # also mark as broadcast domain from collections import defaultdict coincident_nodes = defaultdict(list) for node in split_created_nodes: coincident_nodes[(node['graphics'].x, node['graphics'].y)].append(node) coincident_nodes = {k: v for k, v in coincident_nodes.items() if len(v) > 1} # trim out single node co-ordinates import math for _, val in coincident_nodes.items(): for index, item in enumerate(val): index = index + 1 x_offset = 25 * math.floor(index / 2) * math.pow(-1, index) y_offset = -1 * 25 * math.floor(index / 2) * math.pow(-1, index) item['graphics'].x = item['graphics'].x + x_offset item['graphics'].y = item['graphics'].y + y_offset switch_nodes = g_l2_bc.switches() # regenerate due to aggregated g_l2_bc.update(switch_nodes, broadcast_domain=True) # switches are part of collision domain g_l2_bc.update(split_created_nodes, broadcast_domain=True) # Assign collision domain to a host if all neighbours from same host for node in split_created_nodes: if ank_utils.neigh_equal(g_l2_bc, node, 'host', g_phy): node.host = ank_utils.neigh_attr(g_l2_bc, node, 'host', g_phy).next() # first attribute # set collision domain IPs # TODO; work out why this throws a json exception #autonetkit.ank.set_node_default(g_l2_bc, broadcast_domain=False) for node in g_l2_bc.nodes('broadcast_domain'): graphics_node = g_graphics.node(node) #graphics_node.device_type = 'broadcast_domain' if node.is_switch(): # TODO: check not virtual node['phy'].broadcast_domain = True if not node.is_switch(): # use node sorting, as accomodates for numeric/string names graphics_node.device_type = 'broadcast_domain' neighbors = sorted(neigh for neigh in node.neighbors()) label = '_'.join(neigh.label for neigh in neighbors) cd_label = 'cd_%s' % label # switches keep their names node.label = cd_label graphics_node.label = cd_label node.device_type = "broadcast_domain" node.label = node.id graphics_node.label = node.id for node in vswitches: node.broadcast_domain = True
def allocate_ips(G_ip): log.info("Allocating IP addresses") from netaddr import IPNetwork address_block = IPNetwork("10.0.0.0/8") subnet_address_blocks = address_block.subnet(16) #TODO: need to divide this up per AS G_ip.data.asn_blocks = defaultdict(list) #print G_ip._graph G_phy = G_ip.overlay.phy collision_domains = list(G_ip.nodes("collision_domain")) routers_by_asn = G_phy.groupby("asn", G_phy.nodes(device_type="router")) for collision_domain in collision_domains: neigh_asn = list(ank_utils.neigh_attr(G_ip, collision_domain, "asn", G_phy)) #asn of neighbors if len(set(neigh_asn)) == 1: asn = set(neigh_asn).pop() # asn of any neigh, as all same else: asn = ank_utils.most_frequent(neigh_asn) # allocate cd to asn with most neighbors in it collision_domain.asn = asn cds_by_asn = G_ip.groupby("asn", G_ip.nodes("collision_domain")) # if node or subnet has IP already allocated, then skip from this tree for asn in routers_by_asn: log.info("Allocating IPs for ASN %s" % asn) # Need to iterate by asn with routers, as single router AS may not have a cd asn_cds = cds_by_asn.get(asn) or [] asn_cds = sorted(asn_cds) #tree by ASN #TODO: Add in loopbacks as a subnet also asn_address_block = subnet_address_blocks.next() #print "ips for asn", asn G_ip.data.asn_blocks[asn].append(asn_address_block) #TODO: record this in G_ip graph data not node/edge data # Build list of collision domains sorted by size size_list = defaultdict(list) for cd in asn_cds: sn_size = subnet_size(cd.degree()) # Size of this collision domain size_list[sn_size].append(cd) loopback_size = subnet_size(len(routers_by_asn[asn])) # calculate from number of routers in asn ip_tree = defaultdict(list) # index by level to simplify creation of tree try: current_level = min(size_list) # start at base except ValueError: current_level = loopback_size # no cds, start at loopback asn_loopback_tree_node = None #keep track of to allocate loopbacks at end while True: cds = size_list[current_level] cds = sorted(cds, key = lambda x: x.node_id) # initialse with leaves #TODO: see if can get loopback on leftmost of tree -> then can have allocated with .1 .2 etc rather than .19 .20 etc ip_tree[current_level] += list(TreeNode(cd=cd) for cd in sorted(cds)) if current_level == loopback_size: asn_loopback_tree_node = TreeNode(cd = "loopback") ip_tree[current_level].append(asn_loopback_tree_node) # now connect up at parent level tree_nodes = sorted(ip_tree[current_level]) # both leaves and parents of lower level pairs = list(itertools.izip(tree_nodes[::2], tree_nodes[1::2])) for left, right in pairs: ip_tree[current_level+1].append(TreeNode(left, right)) if len(tree_nodes) % 2 == 1: # odd number of tree nodes, add final_tree_node = tree_nodes[-1] ip_tree[current_level+1].append(TreeNode(final_tree_node, None)) current_level += 1 if asn_loopback_tree_node and len(ip_tree[current_level]) < 2: # loopback has been allocated, and reached top of tree break #if leaf, assign back to collision domain # allocate to tree subnet_bits = 32 - max(ip_tree) tree_subnet = asn_address_block.subnet(subnet_bits) tree_root = ip_tree[max(ip_tree)].pop() # only one node at highest level (root) tree_root.subnet = tree_subnet.next() allocate_to_tree_node(tree_root) #walk_tree(tree_root) allocate_ips_to_cds(tree_root) my_tree = Tree(tree_root, asn) my_tree.save() # Get loopback from loopback tree node loopback_hosts = asn_loopback_tree_node.subnet.iter_hosts() #router.loopback = loopback_hosts.next() for router in sorted(routers_by_asn[asn], key = lambda x: x.label): router.overlay.ip.loopback = loopback_hosts.next() # now allocate to the links of each cd for cd in asn_cds: hosts = cd.subnet.iter_hosts() for edge in sorted(cd.edges()): edge.ip_address = hosts.next()
def build_layer2_broadcast(anm): g_l2 = anm['layer2'] g_phy = anm['phy'] g_graphics = anm['graphics'] g_l2_bc = anm.add_overlay('layer2_bc') g_l2_bc.add_nodes_from(g_l2) g_l2_bc.add_edges_from(g_l2.edges()) edges_to_split = [edge for edge in g_l2_bc.edges() if edge.src.is_l3device() and edge.dst.is_l3device()] for edge in edges_to_split: edge.split = True # mark as split for use in building nidb split_created_nodes = list(ank_utils.split(g_l2_bc, edges_to_split, retain=['split'], id_prepend='cd_')) for node in split_created_nodes: node['graphics'].x = ank_utils.neigh_average(g_l2_bc, node, 'x', g_graphics) + 0.1 # temporary fix for gh-90 node['graphics'].y = ank_utils.neigh_average(g_l2_bc, node, 'y', g_graphics) + 0.1 # temporary fix for gh-90 asn = ank_utils.neigh_most_frequent(g_l2_bc, node, 'asn', g_phy) # arbitrary choice node['graphics'].asn = asn node.asn = asn # need to use asn in IP overlay for aggregating subnets switch_nodes = g_l2_bc.switches() # regenerate due to aggregated g_l2_bc.update(switch_nodes, broadcast_domain=True) # switches are part of collision domain g_l2_bc.update(split_created_nodes, broadcast_domain=True) # Assign collision domain to a host if all neighbours from same host for node in split_created_nodes: if ank_utils.neigh_equal(g_l2_bc, node, 'host', g_phy): node.host = ank_utils.neigh_attr(g_l2_bc, node, 'host', g_phy).next() # first attribute # set collision domain IPs #TODO; work out why this throws a json exception #autonetkit.ank.set_node_default(g_l2_bc, broadcast_domain=False) for node in g_l2_bc.nodes('broadcast_domain'): graphics_node = g_graphics.node(node) #graphics_node.device_type = 'broadcast_domain' if node.is_switch(): node['phy'].broadcast_domain = True if not node.is_switch(): # use node sorting, as accomodates for numeric/string names graphics_node.device_type = 'broadcast_domain' neighbors = sorted(neigh for neigh in node.neighbors()) label = '_'.join(neigh.label for neigh in neighbors) cd_label = 'cd_%s' % label # switches keep their names node.label = cd_label graphics_node.label = cd_label node.device_type = "broadcast_domain"
def build_layer2_broadcast(anm): g_l2 = anm['layer2'] g_phy = anm['phy'] g_graphics = anm['graphics'] g_l2_bc = anm.add_overlay('layer2_bc') g_l2_bc.add_nodes_from(g_l2.l3devices()) g_l2_bc.add_nodes_from(g_l2.switches()) g_l2_bc.add_edges_from(g_l2.edges()) # remove external connectors edges_to_split = [ edge for edge in g_l2_bc.edges() if edge.src.is_l3device() and edge.dst.is_l3device() ] #TODO: debug the edges to split #print "edges to split", edges_to_split for edge in edges_to_split: edge.split = True # mark as split for use in building nidb split_created_nodes = list( ank_utils.split(g_l2_bc, edges_to_split, retain=['split'], id_prepend='cd_')) #TODO: if parallel nodes, offset #TODO: remove graphics, assign directly for node in split_created_nodes: node['graphics'].x = ank_utils.neigh_average(g_l2_bc, node, 'x', g_graphics) + 0.1 # temporary fix for gh-90 node['graphics'].y = ank_utils.neigh_average(g_l2_bc, node, 'y', g_graphics) + 0.1 # temporary fix for gh-90 asn = ank_utils.neigh_most_frequent(g_l2_bc, node, 'asn', g_phy) # arbitrary choice node['graphics'].asn = asn node.asn = asn # need to use asn in IP overlay for aggregating subnets from collections import defaultdict coincident_nodes = defaultdict(list) for node in split_created_nodes: coincident_nodes[(node['graphics'].x, node['graphics'].y)].append(node) coincident_nodes = { k: v for k, v in coincident_nodes.items() if len(v) > 1 } # trim out single node co-ordinates import math for key, val in coincident_nodes.items(): for index, item in enumerate(val): index = index + 1 x_offset = 25 * math.floor(index / 2) * math.pow(-1, index) y_offset = -1 * 25 * math.floor(index / 2) * math.pow(-1, index) item['graphics'].x = item['graphics'].x + x_offset item['graphics'].y = item['graphics'].y + y_offset switch_nodes = g_l2_bc.switches() # regenerate due to aggregated g_l2_bc.update(switch_nodes, broadcast_domain=True) # switches are part of collision domain g_l2_bc.update(split_created_nodes, broadcast_domain=True) # Assign collision domain to a host if all neighbours from same host for node in split_created_nodes: if ank_utils.neigh_equal(g_l2_bc, node, 'host', g_phy): node.host = ank_utils.neigh_attr(g_l2_bc, node, 'host', g_phy).next() # first attribute # set collision domain IPs #TODO; work out why this throws a json exception #autonetkit.ank.set_node_default(g_l2_bc, broadcast_domain=False) for node in g_l2_bc.nodes('broadcast_domain'): graphics_node = g_graphics.node(node) #graphics_node.device_type = 'broadcast_domain' if node.is_switch(): node['phy'].broadcast_domain = True if not node.is_switch(): # use node sorting, as accomodates for numeric/string names graphics_node.device_type = 'broadcast_domain' neighbors = sorted(neigh for neigh in node.neighbors()) label = '_'.join(neigh.label for neigh in neighbors) cd_label = 'cd_%s' % label # switches keep their names node.label = cd_label graphics_node.label = cd_label node.device_type = "broadcast_domain" node.label = node.id graphics_node.label = node.id
def build_ip(anm): import autonetkit.plugins.ip as ip G_ip = anm.add_overlay("ip") G_in = anm['input'] G_graphics = anm['graphics'] G_phy = anm['phy'] G_ip.add_nodes_from(G_in) G_ip.add_edges_from(G_in.edges(type="physical")) #TODO: need to look at if allocate_v6 is specified: ie manually set ank.aggregate_nodes(G_ip, G_ip.nodes("is_switch"), retain = "edge_id") #TODO: add function to update edge properties: can overload node update? edges_to_split = [edge for edge in G_ip.edges() if edge.attr_both("is_l3device")] split_created_nodes = list(ank.split(G_ip, edges_to_split, retain='edge_id')) for node in split_created_nodes: node['graphics'].x = ank.neigh_average(G_ip, node, "x", G_graphics) node['graphics'].y = ank.neigh_average(G_ip, node, "y", G_graphics) asn = ank.neigh_most_frequent(G_ip, node, "asn", G_phy) # arbitrary choice node['graphics'].asn = asn # need to use asn in IP overlay for aggregating subnets node.asn = asn #TODO: could choose largest ASN if tie break #TODO: see if need G_phy - should auto fall through to phy for ASN switch_nodes = G_ip.nodes("is_switch")# regenerate due to aggregated G_ip.update(switch_nodes, collision_domain=True) # switches are part of collision domain G_ip.update(split_created_nodes, collision_domain=True) # Assign collision domain to a host if all neighbours from same host for node in split_created_nodes: if ank.neigh_equal(G_ip, node, "host", G_phy): node.host = ank.neigh_attr(G_ip, node, "host", G_phy).next() # first attribute #TODO: Need to allocate interfaces or appropriate bypass for collision domain nodes # set collision domain IPs #TODO: trim next line collision_domain_id = itertools.count(0) # TODO: remove this, as isn't needed as set id to be based on neighbors for node in G_ip.nodes("collision_domain"): graphics_node = G_graphics.node(node) graphics_node.device_type = "collision_domain" cd_id = collision_domain_id.next() node.cd_id = cd_id #TODO: Use this label if not node.is_switch: label = "_".join(sorted(ank.neigh_attr(G_ip, node, "label", G_phy))) cd_label = "cd_%s" % label # switches keep their names node.label = cd_label node.cd_id = cd_label graphics_node.label = cd_label if G_in.data.allocate_ipv4 == False: import netaddr G_in_directed = anm['input_directed'] for l3_device in G_ip.nodes("is_l3device"): directed_node = G_in_directed.node(l3_device) l3_device.loopback = directed_node.ipv4loopback for edge in l3_device.edges(): # find edge in G_in_directed directed_edge = G_in_directed.edge(edge) edge.ip_address = netaddr.IPAddress(directed_edge.ipv4) # set subnet onto collision domain (can come from either direction) collision_domain = edge.dst if not collision_domain.subnet: #TODO: see if direct method in netaddr to deduce network prefixlen = directed_edge.netPrefixLenV4 cidr_string = "%s/%s" % (edge.ip_address, prefixlen) intermediate_subnet = netaddr.IPNetwork(cidr_string) cidr_string = "%s/%s" % (intermediate_subnet.network, prefixlen) subnet = netaddr.IPNetwork(cidr_string) collision_domain.subnet = subnet # also need to form aggregated IP blocks (used for e.g. routing prefix advertisement) loopback_blocks = {} infra_blocks = {} for asn, devices in G_ip.groupby("asn").items(): routers = [d for d in devices if d.is_router] loopbacks = [r.loopback for r in routers] loopback_blocks[asn] = netaddr.cidr_merge(loopbacks) collision_domains = [d for d in devices if d.collision_domain] subnets = [cd.subnet for cd in collision_domains] infra_blocks[asn] = netaddr.cidr_merge(subnets) G_ip.data.loopback_blocks = loopback_blocks G_ip.data.infra_blocks = infra_blocks else: ip.allocate_ips(G_ip) ank.save(G_ip)