def build_layer3(anm): """ l3_connectivity graph: switch nodes aggregated and exploded""" g_in = anm['input'] gl2_conn = anm['layer2_conn'] g_l3 = anm.add_overlay("layer3") g_l3.add_nodes_from(gl2_conn, retain=['label']) g_l3.add_nodes_from(g_in.switches(), retain=['asn']) g_l3.add_edges_from(gl2_conn.edges()) switches = g_l3.switches() ank_utils.aggregate_nodes(g_l3, switches) exploded_edges = ank_utils.explode_nodes(g_l3, switches) # also explode virtual switches vswitches = [ n for n in g_l3.nodes() if n['layer2'].device_type == "switch" and n['layer2'].device_subtype == "virtual" ] # explode each seperately? for edge in exploded_edges: edge.multipoint = True edge.src_int.multipoint = True edge.dst_int.multipoint = True
def build_ebgp(anm): g_in = anm['input'] g_phy = anm['phy'] g_ebgp = anm.add_overlay("ebgp", directed=True) g_ebgp.add_nodes_from(g_in.routers()) ebgp_edges = [e for e in g_in.edges() if not e.attr_equal("asn")] g_ebgp.add_edges_from(ebgp_edges, bidirectional=True, type='ebgp') ebgp_switches = [n for n in g_in.switches() if not ank_utils.neigh_equal(g_phy, n, "asn")] g_ebgp.add_nodes_from(ebgp_switches, retain=['asn']) g_ebgp.log.debug("eBGP switches are %s" % ebgp_switches) g_ebgp.add_edges_from((e for e in g_in.edges() if e.src in ebgp_switches or e.dst in ebgp_switches), bidirectional=True, type='ebgp') ank_utils.aggregate_nodes(g_ebgp, ebgp_switches) # need to recalculate as may have aggregated ebgp_switches = list(g_ebgp.switches()) g_ebgp.log.debug("aggregated eBGP switches are %s" % ebgp_switches) exploded_edges = ank_utils.explode_nodes(g_ebgp, ebgp_switches) same_asn_edges = [] for edge in exploded_edges: if edge.src.asn == edge.dst.asn: same_asn_edges.append(edge) else: edge.multipoint = True """TODO: remove up to here once compiler updated""" g_ebgp.remove_edges_from(same_asn_edges)
def build_layer3(anm): """ l3_connectivity graph: switch nodes aggregated and exploded""" g_in = anm['input'] gl2_conn = anm['layer2_conn'] g_l3 = anm.add_overlay("layer3") g_l3.add_nodes_from(gl2_conn, retain=['label', 'devsubtype']) ank_utils.copy_attr_from(g_in, g_l3, "multicast") g_l3.add_nodes_from(g_in.switches(), retain=['asn']) g_l3.add_edges_from(gl2_conn.edges(), retain=['link_type']) edges_to_remove = [ edge for edge in gl2_conn.edges() if edge.link_type == 'is_not_l3' ] g_l3.remove_edges_from(edges_to_remove) edges_to_remove = [] switches = g_l3.switches() ank_utils.aggregate_nodes(g_l3, switches) exploded_edges = ank_utils.explode_nodes(g_l3, switches, retain=['link_type']) # also explode virtual switches vswitches = [ n for n in g_l3.nodes() if n['layer2'].device_type == "switch" and n['layer2'].device_subtype == "virtual" ] # explode each seperately? for edge in exploded_edges: edge.multipoint = True edge.src_int.multipoint = True edge.dst_int.multipoint = True
def build_ebgp(anm): g_in = anm['input'] g_phy = anm['phy'] g_ebgp = anm.add_overlay("ebgp", directed=True) g_ebgp.add_nodes_from(g_in.nodes("is_router")) ebgp_edges = [e for e in g_in.edges() if not e.attr_equal("asn")] g_ebgp.add_edges_from(ebgp_edges, bidirectional=True, type='ebgp') ebgp_switches = [ n for n in g_in.nodes("is_switch") if not ank_utils.neigh_equal(g_phy, n, "asn") ] g_ebgp.add_nodes_from(ebgp_switches, retain=['asn']) log.debug("eBGP switches are %s" % ebgp_switches) g_ebgp.add_edges_from( (e for e in g_in.edges() if e.src in ebgp_switches or e.dst in ebgp_switches), bidirectional=True, type='ebgp') ank_utils.aggregate_nodes(g_ebgp, ebgp_switches, retain="edge_id") ebgp_switches = list(g_ebgp.nodes( "is_switch")) # need to recalculate as may have aggregated log.debug("aggregated eBGP switches are %s" % ebgp_switches) exploded_edges = ank_utils.explode_nodes(g_ebgp, ebgp_switches, retain="edge_id") for edge in exploded_edges: edge.multipoint = True
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 build_ebgp(anm): g_in = anm['input'] g_phy = anm['phy'] g_ebgp = anm.add_overlay("ebgp", directed=True) g_ebgp.add_nodes_from(g_in.nodes("is_router")) ebgp_edges = [e for e in g_in.edges() if not e.attr_equal("asn")] g_ebgp.add_edges_from(ebgp_edges, bidirectional=True, type='ebgp') ebgp_switches = [n for n in g_in.nodes("is_switch") if not ank_utils.neigh_equal(g_phy, n, "asn")] g_ebgp.add_nodes_from(ebgp_switches, retain=['asn']) log.debug("eBGP switches are %s" % ebgp_switches) g_ebgp.add_edges_from((e for e in g_in.edges() if e.src in ebgp_switches or e.dst in ebgp_switches), bidirectional=True, type='ebgp') ank_utils.aggregate_nodes(g_ebgp, ebgp_switches, retain="edge_id") # need to recalculate as may have aggregated ebgp_switches = list(g_ebgp.nodes("is_switch")) log.debug("aggregated eBGP switches are %s" % ebgp_switches) exploded_edges = ank_utils.explode_nodes(g_ebgp, ebgp_switches, retain="edge_id") same_asn_edges = [] for edge in exploded_edges: if edge.src.asn == edge.dst.asn: same_asn_edges.append(edge) else: edge.multipoint = True """TODO: remove up to here once compiler updated""" g_ebgp.remove_edges_from(same_asn_edges)
def build_layer3(anm): """ l3_connectivity graph: switch nodes aggregated and exploded""" g_in = anm['input'] g_l2 = anm['layer2'] g_l3 = anm.add_overlay("layer3") g_l3.add_nodes_from(g_l2, retain=['label']) g_l3.add_nodes_from(g_in.switches(), retain=['asn']) g_l3.add_edges_from(g_l2.edges()) switches = g_l3.switches() ank_utils.aggregate_nodes(g_l3, switches) exploded_edges = ank_utils.explode_nodes(g_l3, switches) # also explode virtual switches vswitches = [n for n in g_l3.nodes() if n['layer2'].device_type == "switch" and n['layer2'].device_subtype == "virtual"] # explode each seperately? for edge in exploded_edges: edge.multipoint = True edge.src_int.multipoint = True edge.dst_int.multipoint = True
def build_isis(anm): """Build isis overlay""" g_in = anm["input"] if not any(n.igp == "isis" for n in g_in): log.debug("No ISIS nodes") return g_ipv4 = anm["ipv4"] g_isis = anm.add_overlay("isis") g_isis.add_nodes_from(g_in.nodes("is_router", igp="isis"), retain=["asn"]) g_isis.add_nodes_from(g_in.nodes("is_switch"), retain=["asn"]) g_isis.add_edges_from(g_in.edges(), retain=["edge_id"]) # Merge and explode switches ank_utils.aggregate_nodes(g_isis, g_isis.nodes("is_switch"), retain="edge_id") exploded_edges = ank_utils.explode_nodes(g_isis, g_isis.nodes("is_switch"), retain="edge_id") for edge in exploded_edges: edge.multipoint = True g_isis.remove_edges_from([link for link in g_isis.edges() if link.src.asn != link.dst.asn]) for node in g_isis: ip_node = g_ipv4.node(node) node.net = ip_to_net_ent_title_ios(ip_node.loopback) node.process_id = 1 # default for link in g_isis.edges(): link.metric = 1 # default # link.hello = 5 # for debugging, TODO: read from graph for edge in g_isis.edges(): for interface in edge.interfaces(): interface.metric = edge.metric interface.multipoint = edge.multipoint
def build_l3_connectivity(anm): """ l3_connectivity graph: switch nodes aggregated and exploded""" g_in = anm["input"] g_l3conn = anm.add_overlay("layer3") g_l3conn.add_nodes_from( g_in, retain=[ "label", "update", "device_type", "asn", "specified_int_names", "device_subtype", "platform", "host", "syntax", ], ) g_l3conn.add_nodes_from(g_in.switches(), retain=["asn"]) g_l3conn.add_edges_from(g_in.edges()) ank_utils.aggregate_nodes(g_l3conn, g_l3conn.switches()) exploded_edges = ank_utils.explode_nodes(g_l3conn, g_l3conn.switches()) for edge in exploded_edges: edge.multipoint = True edge.src_int.multipoint = True edge.dst_int.multipoint = True
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'], id_prepend="cd")) 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: # use node sorting, as accomodates for numeric/string names 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 node.cd_id = cd_label graphics_node.label = cd_label
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'], id_prepend = "cd")) 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: # use node sorting, as accomodates for numeric/string names 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 node.cd_id = cd_label graphics_node.label = cd_label
def build_layer3(anm): """ l3_connectivity graph: switch nodes aggregated and exploded""" g_in = anm['input'] g_l2 = anm['layer2'] g_l3 = anm.add_overlay("layer3") g_l3.add_nodes_from(g_l2, retain=['label']) g_l3.add_nodes_from(g_in.switches(), retain=['asn']) g_l3.add_edges_from(g_in.edges()) ank_utils.aggregate_nodes(g_l3, g_l3.switches()) exploded_edges = ank_utils.explode_nodes(g_l3, g_l3.switches()) for edge in exploded_edges: edge.multipoint = True edge.src_int.multipoint = True edge.dst_int.multipoint = True
def build_layer2(anm): g_l2 = anm.add_overlay('layer2') g_phy = anm['phy'] g_l2.add_nodes_from(g_phy) g_l2.add_edges_from(g_phy.edges()) # Don't aggregate managed switches unmanaged_switches = [n for n in g_l2.switches() if n.device_subtype != "managed"] ank_utils.aggregate_nodes(g_l2, unmanaged_switches) try: from autonetkit_cisco import build_network as cisco_build_network except ImportError: pass else: cisco_build_network.post_layer2(anm)
def build_layer3(anm): """ l3_connectivity graph: switch nodes aggregated and exploded""" g_in = anm['input'] g_l2 = anm['layer2'] g_l3 = anm.add_overlay("layer3") g_l3.add_nodes_from(g_l2 , retain=['label']) g_l3.add_nodes_from(g_in.switches(), retain=['asn']) g_l3.add_edges_from(g_in.edges()) ank_utils.aggregate_nodes(g_l3, g_l3.switches()) exploded_edges = ank_utils.explode_nodes(g_l3, g_l3.switches()) for edge in exploded_edges: edge.multipoint = True edge.src_int.multipoint = True edge.dst_int.multipoint = True
def build_layer1(anm): g_l1 = anm.add_overlay('layer1') g_phy = anm['phy'] g_l1.add_nodes_from(g_phy) g_l1.add_edges_from(g_phy.edges()) # aggregate collision domains hubs = g_l1.nodes(device_type="hub") ank_utils.aggregate_nodes(g_l1, hubs) # TODO: remove aggregated and disconnected nodes # refresh hubs list hubs = g_l1.nodes(device_type="hub") for hub in hubs: hub.collision_domain = True split_ptp(anm) build_layer1_conn(anm)
def build_layer1(anm): g_l1 = anm.add_overlay('layer1') g_phy = anm['phy'] g_l1.add_nodes_from(g_phy, retain=['devsubtype']) g_l1.add_edges_from(g_phy.edges(), retain=['link_type']) # aggregate collision domains hubs = g_l1.nodes(device_type="hub") ank_utils.aggregate_nodes(g_l1, hubs) # TODO: remove aggregated and disconnected nodes # refresh hubs list hubs = g_l1.nodes(device_type="hub") for hub in hubs: hub.collision_domain = True split_ptp(anm) build_layer1_conn(anm)
def build_l3_connectivity(anm): """ l3_connectivity graph: switch nodes aggregated and exploded""" g_in = anm['input'] g_l3conn = anm.add_overlay("l3_conn") g_l3conn.add_nodes_from( g_in, retain=['label', 'update', 'device_type', 'asn', 'specified_int_names', 'device_subtype', 'platform', 'host', 'syntax']) g_l3conn.add_nodes_from(g_in.switches(), retain=['asn']) g_l3conn.add_edges_from(g_in.edges()) ank_utils.aggregate_nodes(g_l3conn, g_l3conn.switches()) exploded_edges = ank_utils.explode_nodes(g_l3conn, g_l3conn.switches()) for edge in exploded_edges: edge.multipoint = True edge.src_int.multipoint = True edge.dst_int.multipoint = True
def build_l3_connectivity(anm): """ creates l3_connectivity graph, which is switch nodes aggregated and exploded""" #TODO: use this as base for ospf, ebgp, ip, etc rather than exploding in each g_in = anm['input'] g_l3conn = anm.add_overlay("l3_conn") g_l3conn.add_nodes_from(g_in, retain=['label', 'update', 'device_type', 'asn', 'specified_int_names', 'device_subtype', 'platform', 'host', 'syntax']) g_l3conn.add_nodes_from(g_in.nodes("is_switch"), retain=['asn']) #TODO: check if edge_id needs to be still retained g_l3conn.add_edges_from(g_in.edges(), retain=['edge_id']) ank_utils.aggregate_nodes(g_l3conn, g_l3conn.nodes("is_switch"), retain="edge_id") exploded_edges = ank_utils.explode_nodes(g_l3conn, g_l3conn.nodes("is_switch"), retain="edge_id") for edge in exploded_edges: edge.multipoint = True
def build_eigrp(anm): """Build eigrp overlay""" g_in = anm['input'] # add regardless, so allows quick check of node in anm['isis'] in compilers g_l3 = anm['layer3'] g_eigrp = anm.add_overlay("eigrp") g_phy = anm['phy'] if not anm['phy'].data.enable_routing: g_eigrp.log.info("Routing disabled, not configuring EIGRP") return if not any(n.igp == "eigrp" for n in g_phy): log.debug("No EIGRP nodes") return eigrp_nodes = [n for n in g_l3 if n['phy'].igp == "eigrp"] g_eigrp.add_nodes_from(eigrp_nodes) g_eigrp.add_edges_from(g_l3.edges(), warn=False) ank_utils.copy_int_attr_from(g_l3, g_eigrp, "multipoint") ank_utils.copy_attr_from(g_in, g_eigrp, "custom_config_eigrp", dst_attr="custom_config") # Merge and explode switches ank_utils.aggregate_nodes(g_eigrp, g_eigrp.switches()) exploded_edges = ank_utils.explode_nodes(g_eigrp, g_eigrp.switches()) for edge in exploded_edges: edge.multipoint = True g_eigrp.remove_edges_from( [link for link in g_eigrp.edges() if link.src.asn != link.dst.asn]) for node in g_eigrp: node.process_id = node.asn for link in g_eigrp.edges(): link.metric = 1 # default for edge in g_eigrp.edges(): for interface in edge.interfaces(): interface.metric = edge.metric interface.multipoint = edge.multipoint
def build_eigrp(anm): """Build eigrp overlay""" g_in = anm['input'] # add regardless, so allows quick check of node in anm['isis'] in compilers g_eigrp = anm.add_overlay("eigrp") if not anm['phy'].data.enable_routing: log.info("Routing disabled, not configuring EIGRP") return if not any(n.igp == "eigrp" for n in g_in): log.debug("No EIGRP nodes") return g_ipv4 = anm['ipv4'] g_eigrp.add_nodes_from(g_in.nodes("is_router", igp = "eigrp"), retain=['asn']) g_eigrp.add_nodes_from(g_in.nodes("is_server", igp = "eigrp"), retain=['asn']) g_eigrp.add_nodes_from(g_in.nodes("is_switch"), retain=['asn']) g_eigrp.add_edges_from(g_in.edges(), retain=['edge_id']) # Merge and explode switches ank_utils.aggregate_nodes(g_eigrp, g_eigrp.nodes("is_switch"), retain="edge_id") exploded_edges = ank_utils.explode_nodes(g_eigrp, g_eigrp.nodes("is_switch"), retain="edge_id") for edge in exploded_edges: edge.multipoint = True g_eigrp.remove_edges_from( [link for link in g_eigrp.edges() if link.src.asn != link.dst.asn]) for node in g_eigrp: ip_node = g_ipv4.node(node) node.net = ip_to_net_ent_title_ios(ip_node.loopback) node.name = "one" # default for link in g_eigrp.edges(): link.metric = 1 # default for edge in g_eigrp.edges(): for interface in edge.interfaces(): interface.metric = edge.metric interface.multipoint = edge.multipoint
def build_l3_connectivity(anm): """ l3_connectivity graph: switch nodes aggregated and exploded""" g_in = anm['input'] g_l3conn = anm.add_overlay("layer3") g_l3conn.add_nodes_from(g_in, retain=[ 'label', 'update', 'device_type', 'asn', 'specified_int_names', 'device_subtype', 'platform', 'host', 'syntax' ]) g_l3conn.add_nodes_from(g_in.switches(), retain=['asn']) g_l3conn.add_edges_from(g_in.edges()) ank_utils.aggregate_nodes(g_l3conn, g_l3conn.switches()) exploded_edges = ank_utils.explode_nodes(g_l3conn, g_l3conn.switches()) for edge in exploded_edges: edge.multipoint = True edge.src_int.multipoint = True edge.dst_int.multipoint = True
def build_eigrp(anm): """Build eigrp overlay""" g_in = anm['input'] # add regardless, so allows quick check of node in anm['isis'] in compilers g_l3 = anm['layer3'] g_eigrp = anm.add_overlay("eigrp") g_phy = anm['phy'] if not anm['phy'].data.enable_routing: g_eigrp.log.info("Routing disabled, not configuring EIGRP") return if not any(n.igp == "eigrp" for n in g_phy): log.debug("No EIGRP nodes") return eigrp_nodes = [n for n in g_l3 if n['phy'].igp == "eigrp"] g_eigrp.add_nodes_from(eigrp_nodes) g_eigrp.add_edges_from(g_l3.edges(), warn=False) ank_utils.copy_int_attr_from(g_l3, g_eigrp, "multipoint") ank_utils.copy_attr_from( g_in, g_eigrp, "custom_config_eigrp", dst_attr="custom_config") # Merge and explode switches ank_utils.aggregate_nodes(g_eigrp, g_eigrp.switches()) exploded_edges = ank_utils.explode_nodes(g_eigrp, g_eigrp.switches()) for edge in exploded_edges: edge.multipoint = True g_eigrp.remove_edges_from( [link for link in g_eigrp.edges() if link.src.asn != link.dst.asn]) for node in g_eigrp: node.process_id = node.asn for link in g_eigrp.edges(): link.metric = 1 # default for edge in g_eigrp.edges(): for interface in edge.interfaces(): interface.metric = edge.metric interface.multipoint = edge.multipoint
def build_l3_connectivity(anm): """ creates l3_connectivity graph, which is switch nodes aggregated and exploded""" #TODO: use this as base for ospf, ebgp, ip, etc rather than exploding in each g_in = anm['input'] g_l3conn = anm.add_overlay("l3_conn") g_l3conn.add_nodes_from(g_in, retain=[ 'label', 'update', 'device_type', 'asn', 'specified_int_names', 'device_subtype', 'platform', 'host', 'syntax' ]) g_l3conn.add_nodes_from(g_in.switches(), retain=['asn']) g_l3conn.add_edges_from(g_in.edges()) ank_utils.aggregate_nodes(g_l3conn, g_l3conn.switches()) exploded_edges = ank_utils.explode_nodes(g_l3conn, g_l3conn.switches()) for edge in exploded_edges: edge.multipoint = True edge.src_int.multipoint = True edge.dst_int.multipoint = True
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 build_ebgp(anm): g_in = anm['input'] g_phy = anm['phy'] g_ebgp = anm.add_overlay("ebgp", directed=True) g_ebgp.add_nodes_from(g_in.nodes("is_router")) ebgp_edges = [e for e in g_in.edges() if not e.attr_equal("asn")] g_ebgp.add_edges_from(ebgp_edges, bidirectional=True, type='ebgp') ebgp_switches = [n for n in g_in.nodes("is_switch") if not ank_utils.neigh_equal(g_phy, n, "asn")] g_ebgp.add_nodes_from(ebgp_switches, retain=['asn']) log.debug("eBGP switches are %s" % ebgp_switches) g_ebgp.add_edges_from((e for e in g_in.edges() if e.src in ebgp_switches or e.dst in ebgp_switches), bidirectional=True, type='ebgp') ank_utils.aggregate_nodes(g_ebgp, ebgp_switches, retain="edge_id") ebgp_switches = list(g_ebgp.nodes("is_switch")) # need to recalculate as may have aggregated log.debug("aggregated eBGP switches are %s" % ebgp_switches) exploded_edges = ank_utils.explode_nodes(g_ebgp, ebgp_switches, retain="edge_id") for edge in exploded_edges: edge.multipoint = True
def build_isis(anm): G_in = anm['input'] G_ip = anm['ip'] G_isis = anm.add_overlay("isis") #G_isis.add_nodes_from(G_in.nodes("is_router", igp = "isis"), retain=['asn']) #TODO: filter only igp=isis nodes, set the igp as a default in build_network G_isis.add_nodes_from(G_in.nodes("is_router"), retain=['asn']) G_isis.add_nodes_from(G_in.nodes("is_switch"), retain=['asn']) G_isis.add_edges_from(G_in.edges(), retain = ['edge_id']) # Merge and explode switches ank.aggregate_nodes(G_isis, G_isis.nodes("is_switch"), retain = "edge_id") ank.explode_nodes(G_isis, G_isis.nodes("is_switch"), retain = "edge_id") G_isis.remove_edges_from([link for link in G_isis.edges() if link.src.asn != link.dst.asn]) for node in G_isis: ip_node = G_ip.node(node) node.net = ip_to_net_ent_title_ios(ip_node.loopback) node.process_id = 1 # default for link in G_isis.edges(): link.metric = 1 # default
def build_isis(anm): """Build isis overlay""" g_in = anm['input'] # add regardless, so allows quick check of node in anm['isis'] in compilers g_isis = anm.add_overlay("isis") if not any(n.igp == "isis" for n in g_in): log.debug("No ISIS nodes") return g_ipv4 = anm['ipv4'] g_isis.add_nodes_from(g_in.nodes("is_router", igp="isis"), retain=['asn']) g_isis.add_nodes_from(g_in.nodes("is_switch"), retain=['asn']) g_isis.add_edges_from(g_in.edges(), retain=['edge_id']) # Merge and explode switches ank_utils.aggregate_nodes(g_isis, g_isis.nodes("is_switch"), retain="edge_id") exploded_edges = ank_utils.explode_nodes(g_isis, g_isis.nodes("is_switch"), retain="edge_id") for edge in exploded_edges: edge.multipoint = True g_isis.remove_edges_from( [link for link in g_isis.edges() if link.src.asn != link.dst.asn]) for node in g_isis: ip_node = g_ipv4.node(node) node.net = ip_to_net_ent_title_ios(ip_node.loopback) node.process_id = 1 # default for link in g_isis.edges(): link.metric = 1 # default # link.hello = 5 # for debugging, TODO: read from graph for edge in g_isis.edges(): for interface in edge.interfaces(): interface.metric = edge.metric interface.multipoint = edge.multipoint
def build_isis(anm): """Build isis overlay""" g_in = anm['input'] # add regardless, so allows quick check of node in anm['isis'] in compilers g_isis = anm.add_overlay("isis") if not anm['phy'].data.enable_routing: g_isis.log.info("Routing disabled, not configuring ISIS") return if not any(n.igp == "isis" for n in g_in): g_isis.log.debug("No ISIS nodes") return g_ipv4 = anm['ipv4'] g_isis.add_nodes_from(g_in.l3devices(igp="isis"), retain=['asn']) g_isis.add_nodes_from(g_in.switches(), retain=['asn']) g_isis.add_edges_from(g_in.edges()) # Merge and explode switches ank_utils.aggregate_nodes(g_isis, g_isis.switches()) exploded_edges = ank_utils.explode_nodes(g_isis, g_isis.switches()) for edge in exploded_edges: edge.multipoint = True g_isis.remove_edges_from( [link for link in g_isis.edges() if link.src.asn != link.dst.asn]) for node in g_isis.routers(): ip_node = g_ipv4.node(node) node.net = ip_to_net_ent_title_ios(ip_node.loopback) node.process_id = 1 # default for link in g_isis.edges(): link.metric = 1 # default for edge in g_isis.edges(): for interface in edge.interfaces(): interface.metric = edge.metric interface.multipoint = edge.multipoint
def build_isis(anm): """Build isis overlay""" g_in = anm['input'] # add regardless, so allows quick check of node in anm['isis'] in compilers g_isis = anm.add_overlay("isis") if not anm['phy'].data.enable_routing: g_isis.log.info("Routing disabled, not configuring ISIS") return if not any(n.igp == "isis" for n in g_in): g_isis.log.debug("No ISIS nodes") return g_ipv4 = anm['ipv4'] g_isis.add_nodes_from(g_in.l3devices(igp = "isis"), retain=['asn']) g_isis.add_nodes_from(g_in.switches(), retain=['asn']) g_isis.add_edges_from(g_in.edges()) # Merge and explode switches ank_utils.aggregate_nodes(g_isis, g_isis.switches()) exploded_edges = ank_utils.explode_nodes(g_isis, g_isis.switches()) for edge in exploded_edges: edge.multipoint = True g_isis.remove_edges_from( [link for link in g_isis.edges() if link.src.asn != link.dst.asn]) for node in g_isis.routers(): ip_node = g_ipv4.node(node) node.net = ip_to_net_ent_title_ios(ip_node.loopback) node.process_id = 1 # default for link in g_isis.edges(): link.metric = 1 # default for edge in g_isis.edges(): for interface in edge.interfaces(): interface.metric = edge.metric interface.multipoint = edge.multipoint
def build_isis(anm): """Build isis overlay""" g_in = anm['input'] g_ipv4 = anm['ipv4'] g_isis = anm.add_overlay("isis") g_isis.add_nodes_from(g_in.nodes("is_router", igp = "isis"), retain=['asn']) g_isis.add_nodes_from(g_in.nodes("is_switch"), retain=['asn']) g_isis.add_edges_from(g_in.edges(), retain=['edge_id']) # Merge and explode switches ank_utils.aggregate_nodes(g_isis, g_isis.nodes("is_switch"), retain="edge_id") ank_utils.explode_nodes(g_isis, g_isis.nodes("is_switch"), retain="edge_id") g_isis.remove_edges_from( [link for link in g_isis.edges() if link.src.asn != link.dst.asn]) for node in g_isis: ip_node = g_ipv4.node(node) node.net = ip_to_net_ent_title_ios(ip_node.loopback) node.process_id = 1 # default for link in g_isis.edges(): link.metric = 1 # default
def build_ospf(anm): """ Build OSPF graph. Allowable area combinations: 0 -> 0 0 -> x (x!= 0) x -> 0 (x!= 0) x -> x (x != 0) Not-allowed: x -> x (x != y != 0) """ import netaddr G_in = anm['input'] G_ospf = anm.add_overlay("ospf") G_ospf.add_nodes_from(G_in.nodes("is_router"), retain=['asn']) G_ospf.add_nodes_from(G_in.nodes("is_switch"), retain=['asn']) G_ospf.add_edges_from(G_in.edges(), retain = ['edge_id']) ank.copy_attr_from(G_in, G_ospf, "ospf_area", dst_attr = "area") #TODO: move this into graphml (and later gml) reader ank.aggregate_nodes(G_ospf, G_ospf.nodes("is_switch"), retain = "edge_id") ank.explode_nodes(G_ospf, G_ospf.nodes("is_switch"), retain= "edge_id") G_ospf.remove_edges_from([link for link in G_ospf.edges() if link.src.asn != link.dst.asn]) # remove inter-AS links area_zero_ip = netaddr.IPAddress("0.0.0.0") area_zero_int = 0 area_zero_ids = set([area_zero_ip, area_zero_int]) default_area = area_zero_int if any(router.area == "0.0.0.0" for router in G_ospf): # string comparison as hasn't yet been cast to IPAddress default_area = area_zero_ip for router in G_ospf: if not router.area or router.area == "None": #TODO: tidy up this default of None being a string router.area = default_area #TODO: could check if 0.0.0.0 used anywhere, if so then use 0.0.0.0 as base format else: try: router.area = int(router.area) except ValueError: try: router.area = netaddr.IPAddress(router.area) except netaddr.core.AddrFormatError: log.warning("Invalid OSPF area %s for %s. Using default of %s" % (router.area, router, default_area)) router.area = default_area for router in G_ospf: # and set area on interface for edge in router.edges(): if edge.area: continue # already allocated (from other "direction", as undirected) if router.area == edge.dst.area: edge.area = router.area # intra-area else: if router.area in area_zero_ids or edge.dst.area in area_zero_ids: # backbone to other area if router.area in area_zero_ids: edge.area = edge.dst.area # router in backbone, use other area else: edge.area = router.area # router not in backbone, use its area for router in G_ospf: areas = set(edge.area for edge in router.edges()) router.areas = list(areas) # store all the edges a router participates in if len(areas) in area_zero_ids: router.type = "backbone" # no ospf edges (such as single node in AS) elif len(areas) == 1: # single area: either backbone (all 0) or internal (all nonzero) if len(areas & area_zero_ids): # intersection has at least one element -> router has area zero router.type = "backbone" else: router.type = "internal" else: # multiple areas if len(areas & area_zero_ids): # intersection has at least one element -> router has area zero router.type = "backbone ABR" else: log.warning("%s spans multiple areas but is not a member of area 0" % router) router.type = "INVALID" if (any(area_zero_int in router.areas for router in G_ospf) and any(area_zero_ip in router.areas for router in G_ospf)): log.warning("Using both area 0 and area 0.0.0.0") #TODO: do we want to allocate non-symmetric OSPF costs? do we need a directed OSPF graph? # (note this will all change once have proper interface nodes) for link in G_ospf.edges(): link.cost = 1
def build_ospf(anm): """ Build OSPF graph. Allowable area combinations: 0 -> 0 0 -> x (x!= 0) x -> 0 (x!= 0) x -> x (x != 0) Not-allowed: x -> x (x != y != 0) #TODO: build check that verifies these rules """ import netaddr g_in = anm['input'] # add regardless, so allows quick check of node in anm['ospf'] in compilers g_ospf = anm.add_overlay("ospf") if not any(n.igp == "ospf" for n in g_in): log.debug("No OSPF nodes") return g_ospf.add_nodes_from(g_in.nodes("is_router", igp="ospf"), retain=['asn']) g_ospf.add_nodes_from(g_in.nodes("is_switch"), retain=['asn']) g_ospf.add_edges_from(g_in.edges(), retain=['edge_id']) ank_utils.copy_attr_from(g_in, g_ospf, "ospf_area", dst_attr="area") ank_utils.copy_edge_attr_from(g_in, g_ospf, "ospf_cost", dst_attr="cost", type=float) ank_utils.aggregate_nodes(g_ospf, g_ospf.nodes("is_switch"), retain="edge_id") exploded_edges = ank_utils.explode_nodes(g_ospf, g_ospf.nodes("is_switch"), retain="edge_id") for edge in exploded_edges: edge.multipoint = True g_ospf.remove_edges_from([ link for link in g_ospf.edges() if link.src.asn != link.dst.asn ]) # remove inter-AS links area_zero_ip = netaddr.IPAddress("0.0.0.0") area_zero_int = 0 area_zero_ids = {area_zero_ip, area_zero_int} default_area = area_zero_int if any(router.area == "0.0.0.0" for router in g_ospf): # string comparison as hasn't yet been cast to IPAddress default_area = area_zero_ip for router in g_ospf: if not router.area or router.area == "None": router.area = default_area # check if 0.0.0.0 used anywhere, if so then use 0.0.0.0 as format else: try: router.area = int(router.area) except ValueError: try: router.area = netaddr.IPAddress(router.area) except netaddr.core.AddrFormatError: log.warning("Invalid OSPF area %s for %s. Using default" " of %s" % (router.area, router, default_area)) router.area = default_area for router in g_ospf: # and set area on interface for edge in router.edges(): if edge.area: continue # allocated (from other "direction", as undirected) if router.area == edge.dst.area: edge.area = router.area # intra-area continue if router.area in area_zero_ids or edge.dst.area in area_zero_ids: # backbone to other area if router.area in area_zero_ids: # router in backbone, use other area edge.area = edge.dst.area else: # router not in backbone, use its area edge.area = router.area for router in g_ospf: areas = {edge.area for edge in router.edges()} router.areas = list(areas) # edges router participates in if len(areas) in area_zero_ids: router.type = "backbone" # no ospf edges (eg single node in AS) elif len(areas) == 1: # single area: either backbone (all 0) or internal (all nonzero) if len(areas & area_zero_ids): # intersection has at least one element -> router has area zero router.type = "backbone" else: router.type = "internal" else: # multiple areas if len(areas & area_zero_ids): # intersection has at least one element -> router has area zero router.type = "backbone ABR" else: log.warning( "%s spans multiple areas but is not a member of area 0" % router) router.type = "INVALID" if (any(area_zero_int in router.areas for router in g_ospf) and any(area_zero_ip in router.areas for router in g_ospf)): log.warning("Using both area 0 and area 0.0.0.0") for link in g_ospf.edges(): if not link.cost: link.cost = 1 # map areas and costs onto interfaces #TODO: later map them directly rather than with edges - this is part of the transition for edge in g_ospf.edges(): for interface in edge.interfaces(): interface.cost = edge.cost interface.area = edge.area interface.multipoint = edge.multipoint for router in g_ospf: router.loopback_zero.area = router.area router.loopback_zero.cost = 0
def build_bgp(anm): """Build iBGP end eBGP overlays""" # eBGP g_in = anm['input'] g_phy = anm['phy'] build_ebgp(anm) build_ebgp_v4(anm) build_ebgp_v6(anm) """TODO: remove from here once compiler updated""" g_bgp = anm.add_overlay("bgp", directed=True) g_bgp.add_nodes_from(g_in.nodes("is_router")) ebgp_edges = [edge for edge in g_in.edges() if not edge.attr_equal("asn")] g_bgp.add_edges_from(ebgp_edges, bidirectional=True, type='ebgp') #TODO: why don't we include edge_id here ebgp_switches = [ n for n in g_in.nodes("is_switch") if not ank_utils.neigh_equal(g_phy, n, "asn") ] g_bgp.add_nodes_from(ebgp_switches, retain=['asn']) log.debug("eBGP switches are %s" % ebgp_switches) g_bgp.add_edges_from((e for e in g_in.edges() if e.src in ebgp_switches or e.dst in ebgp_switches), bidirectional=True, type='ebgp') ank_utils.aggregate_nodes(g_bgp, ebgp_switches, retain="edge_id") ebgp_switches = list( g_bgp.nodes("is_switch")) # need to recalculate as may have aggregated log.debug("aggregated eBGP switches are %s" % ebgp_switches) exploded_edges = ank_utils.explode_nodes(g_bgp, ebgp_switches, retain="edge_id") for edge in exploded_edges: edge.multipoint = True """TODO: remove up to here once compiler updated""" # now iBGP ank_utils.copy_attr_from(g_in, g_bgp, "ibgp_level") ank_utils.copy_attr_from(g_in, g_bgp, "ibgp_l2_cluster") ank_utils.copy_attr_from(g_in, g_bgp, "ibgp_l3_cluster") for node in g_bgp: # set defaults if node.ibgp_level is None: node.ibgp_level = 1 if node.ibgp_level == "None": # if unicode string from yEd node.ibgp_level = 1 #TODO CHECK FOR IBGP NONE node.ibgp_level = int(node.ibgp_level) # ensure is numeric if not node.ibgp_l2_cluster or node.ibgp_l2_cluster == "None": # ibgp_l2_cluster defaults to region node.ibgp_l2_cluster = node.region or "default_l2_cluster" if not node.ibgp_l3_cluster or node.ibgp_l3_cluster == "None": # ibgp_l3_cluster defaults to ASN node.ibgp_l3_cluster = node.asn for asn, devices in ank_utils.groupby("asn", g_bgp): # group by nodes in phy graph routers = list(g_bgp.node(n) for n in devices if n.is_router) # list of nodes from bgp graph ibgp_levels = {int(r.ibgp_level) for r in routers} max_level = max(ibgp_levels) # all possible edge src/dst pairs ibgp_routers = [r for r in routers if r.ibgp_level > 0] all_pairs = [(s, t) for s in ibgp_routers for t in ibgp_routers if s != t] if max_level == 3: up_links, down_links, over_links = three_tier_ibgp_edges( ibgp_routers) elif max_level == 2: up_links, down_links, over_links = build_two_tier_ibgp( ibgp_routers) elif max_level == 1: up_links = [] down_links = [] over_links = [(s, t) for (s, t) in all_pairs if s.ibgp_l3_cluster == t.ibgp_l3_cluster and s.ibgp_l2_cluster == t.ibgp_l2_cluster] else: # no iBGP up_links = [] down_links = [] over_links = [] if max_level > 0: g_bgp.add_edges_from(up_links, type='ibgp', direction='up') g_bgp.add_edges_from(down_links, type='ibgp', direction='down') g_bgp.add_edges_from(over_links, type='ibgp', direction='over') else: log.debug("No iBGP routers in %s" % asn) # and set label back ibgp_label_to_level = { 0: "None", # Explicitly set role to "None" -> Not in iBGP 3: "RR", 1: "RRC", 2: "HRR", } for node in g_bgp: node.ibgp_role = ibgp_label_to_level[node.ibgp_level] ebgp_nodes = [ d for d in g_bgp if any(edge.type == 'ebgp' for edge in d.edges()) ] g_bgp.update(ebgp_nodes, ebgp=True) for ebgp_edge in g_bgp.edges(type="ebgp"): for interface in ebgp_edge.interfaces(): interface.ebgp = True for edge in g_bgp.edges(type='ibgp'): # TODO: need interface querying/selection. rather than hard-coded ids edge.bind_interface(edge.src, 0) #TODO: need to initialise interface zero to be a loopback rather than physical type for node in g_bgp: for interface in node.interfaces(): interface.multipoint = any(e.multipoint for e in interface.edges()) build_ibgp_v4(anm) build_ibgp_v6(anm)
def build_layer2(anm): g_l2 = anm.add_overlay('layer2') g_phy = anm['phy'] g_l2.add_nodes_from(g_phy) g_l2.add_edges_from(g_phy.edges()) ank_utils.aggregate_nodes(g_l2, g_l2.switches())
def build_ospf(anm): """ Build OSPF graph. Allowable area combinations: 0 -> 0 0 -> x (x!= 0) x -> 0 (x!= 0) x -> x (x != 0) Not-allowed: x -> x (x != y != 0) #TODO: build check that verifies these rules """ import netaddr g_in = anm['input'] # add regardless, so allows quick check of node in anm['ospf'] in compilers g_ospf = anm.add_overlay("ospf") if not any(n.igp == "ospf" for n in g_in): log.debug("No OSPF nodes") return g_ospf.add_nodes_from(g_in.nodes("is_router", igp = "ospf"), retain=['asn']) g_ospf.add_nodes_from(g_in.nodes("is_server", igp = "ospf"), retain=['asn']) g_ospf.add_nodes_from(g_in.nodes("is_switch"), retain=['asn']) g_ospf.add_edges_from(g_in.edges(), retain=['edge_id']) ank_utils.copy_attr_from(g_in, g_ospf, "ospf_area", dst_attr="area") ank_utils.copy_edge_attr_from(g_in, g_ospf, "ospf_cost", dst_attr="cost", type=float) ank_utils.aggregate_nodes(g_ospf, g_ospf.nodes("is_switch"), retain="edge_id") exploded_edges = ank_utils.explode_nodes(g_ospf, g_ospf.nodes("is_switch"), retain="edge_id") for edge in exploded_edges: edge.multipoint = True g_ospf.remove_edges_from([link for link in g_ospf.edges( ) if link.src.asn != link.dst.asn]) # remove inter-AS links area_zero_ip = netaddr.IPAddress("0.0.0.0") area_zero_int = 0 area_zero_ids = {area_zero_ip, area_zero_int} default_area = area_zero_int if any(router.area == "0.0.0.0" for router in g_ospf): # string comparison as hasn't yet been cast to IPAddress default_area = area_zero_ip #TODO: use interfaces throughout, rather than edges for router in g_ospf: if not router.area or router.area == "None": router.area = default_area # check if 0.0.0.0 used anywhere, if so then use 0.0.0.0 as format else: try: router.area = int(router.area) except ValueError: try: router.area = netaddr.IPAddress(router.area) except netaddr.core.AddrFormatError: log.warning("Invalid OSPF area %s for %s. Using default" " of %s" % (router.area, router, default_area)) router.area = default_area for router in g_ospf: # and set area on interface for edge in router.edges(): if edge.area: continue # allocated (from other "direction", as undirected) if router.area == edge.dst.area: edge.area = router.area # intra-area continue if router.area in area_zero_ids or edge.dst.area in area_zero_ids: # backbone to other area if router.area in area_zero_ids: # router in backbone, use other area edge.area = edge.dst.area else: # router not in backbone, use its area edge.area = router.area for router in g_ospf: areas = {edge.area for edge in router.edges()} router.areas = list(areas) # edges router participates in if len(areas) in area_zero_ids: router.type = "backbone" # no ospf edges (eg single node in AS) elif len(areas) == 1: # single area: either backbone (all 0) or internal (all nonzero) if len(areas & area_zero_ids): # intersection has at least one element -> router has area zero router.type = "backbone" else: router.type = "internal" else: # multiple areas if len(areas & area_zero_ids): # intersection has at least one element -> router has area zero router.type = "backbone ABR" else: log.warning( "%s spans multiple areas but is not a member of area 0" % router) router.type = "INVALID" if (any(area_zero_int in router.areas for router in g_ospf) and any(area_zero_ip in router.areas for router in g_ospf)): log.warning("Using both area 0 and area 0.0.0.0") for link in g_ospf.edges(): if not link.cost: link.cost = 1 # map areas and costs onto interfaces #TODO: later map them directly rather than with edges - this is part of the transition for edge in g_ospf.edges(): for interface in edge.interfaces(): interface.cost = edge.cost interface.area = edge.area interface.multipoint = edge.multipoint for router in g_ospf: router.loopback_zero.area = router.area router.loopback_zero.cost = 0
def build_ip(anm): #TODO: use the l3_conn graph g_ip = anm.add_overlay('ip') g_in = anm['input'] g_graphics = anm['graphics'] g_phy = anm['phy'] #TODO: add these from layer2 graph - and scrap g_ip: clone g_layer2 to g_ipv4 and g_ipv6 g_ip.add_nodes_from(g_phy) g_ip.add_edges_from(g_phy.edges()) ank_utils.aggregate_nodes(g_ip, g_ip.switches()) edges_to_split = [ edge for edge in g_ip.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_ip, edges_to_split, retain=['split'], id_prepend='cd')) 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.switches() # regenerate due to aggregated g_ip.update(switch_nodes, broadcast_domain=True) # switches are part of collision domain g_ip.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_ip, node, 'host', g_phy): node.host = ank_utils.neigh_attr(g_ip, 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_ip, broadcast_domain=False) for node in g_ip.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 node.cd_id = cd_label graphics_node.label = cd_label node.device_type = "broadcast_domain"
def build_bgp(anm): """Build iBGP end eBGP overlays""" # eBGP g_in = anm['input'] g_phy = anm['phy'] if not anm['phy'].data.enable_routing: log.info("Routing disabled, not configuring BGP") return build_ebgp(anm) build_ebgp_v4(anm) build_ebgp_v6(anm) """TODO: remove from here once compiler updated""" g_bgp = anm.add_overlay("bgp", directed=True) g_bgp.add_nodes_from(g_in.routers()) ebgp_edges = [edge for edge in g_in.edges() if not edge.attr_equal("asn")] g_bgp.add_edges_from(ebgp_edges, bidirectional=True, type='ebgp') ebgp_switches = [n for n in g_in.switches() if not ank_utils.neigh_equal(g_phy, n, "asn")] g_bgp.add_nodes_from(ebgp_switches, retain=['asn']) log.debug("eBGP switches are %s" % ebgp_switches) g_bgp.add_edges_from((e for e in g_in.edges() if e.src in ebgp_switches or e.dst in ebgp_switches), bidirectional=True, type='ebgp') ank_utils.aggregate_nodes(g_bgp, ebgp_switches) ebgp_switches = list(g_bgp.switches()) # need to recalculate as may have aggregated log.debug("aggregated eBGP switches are %s" % ebgp_switches) exploded_edges = ank_utils.explode_nodes(g_bgp, ebgp_switches) same_asn_edges = [] for edge in exploded_edges: if edge.src.asn == edge.dst.asn: same_asn_edges.append(edge) else: edge.multipoint = True """TODO: remove up to here once compiler updated""" g_bgp.remove_edges_from(same_asn_edges) build_ibgp(anm) ebgp_nodes = [d for d in g_bgp if any( edge.type == 'ebgp' for edge in d.edges())] g_bgp.update(ebgp_nodes, ebgp=True) for ebgp_edge in g_bgp.edges(type = "ebgp"): for interface in ebgp_edge.interfaces(): interface.ebgp = True for edge in g_bgp.edges(type='ibgp'): # TODO: need interface querying/selection. rather than hard-coded ids edge.bind_interface(edge.src, 0) #TODO: need to initialise interface zero to be a loopback rather than physical type for node in g_bgp: for interface in node.interfaces(): interface.multipoint = any(e.multipoint for e in interface.edges()) build_ibgp_v4(anm) build_ibgp_v6(anm)
def build_bgp(anm): """Build iBGP end eBGP overlays""" # eBGP g_in = anm["input"] g_phy = anm["phy"] g_bgp = anm.add_overlay("bgp", directed=True) g_bgp.add_nodes_from(g_in.nodes("is_router")) ebgp_edges = [edge for edge in g_in.edges() if not edge.attr_equal("asn")] g_bgp.add_edges_from(ebgp_edges, bidirectional=True, type="ebgp") # TODO: why don't we include edge_id here ebgp_switches = [n for n in g_in.nodes("is_switch") if not ank_utils.neigh_equal(g_phy, n, "asn")] g_bgp.add_nodes_from(ebgp_switches, retain=["asn"]) log.debug("eBGP switches are %s" % ebgp_switches) g_bgp.add_edges_from( (e for e in g_in.edges() if e.src in ebgp_switches or e.dst in ebgp_switches), bidirectional=True, type="ebgp" ) ank_utils.aggregate_nodes(g_bgp, ebgp_switches, retain="edge_id") ebgp_switches = list(g_bgp.nodes("is_switch")) # need to recalculate as may have aggregated log.debug("aggregated eBGP switches are %s" % ebgp_switches) exploded_edges = ank_utils.explode_nodes(g_bgp, ebgp_switches, retain="edge_id") for edge in exploded_edges: edge.multipoint = True # now iBGP ank_utils.copy_attr_from(g_in, g_bgp, "ibgp_level") ank_utils.copy_attr_from(g_in, g_bgp, "ibgp_l2_cluster") ank_utils.copy_attr_from(g_in, g_bgp, "ibgp_l3_cluster") for node in g_bgp: # set defaults if node.ibgp_level is None: node.ibgp_level = 1 if node.ibgp_level == "None": # if unicode string from yEd node.ibgp_level = 1 # TODO CHECK FOR IBGP NONE node.ibgp_level = int(node.ibgp_level) # ensure is numeric if not node.ibgp_l2_cluster or node.ibgp_l2_cluster == "None": # ibgp_l2_cluster defaults to region node.ibgp_l2_cluster = node.region or "default_l2_cluster" if not node.ibgp_l3_cluster or node.ibgp_l3_cluster == "None": # ibgp_l3_cluster defaults to ASN node.ibgp_l3_cluster = node.asn for asn, devices in ank_utils.groupby("asn", g_bgp): # group by nodes in phy graph routers = list(g_bgp.node(n) for n in devices if n.is_router) # list of nodes from bgp graph ibgp_levels = {int(r.ibgp_level) for r in routers} max_level = max(ibgp_levels) # all possible edge src/dst pairs ibgp_routers = [r for r in routers if r.ibgp_level > 0] all_pairs = [(s, t) for s in ibgp_routers for t in ibgp_routers if s != t] if max_level == 3: up_links, down_links, over_links = three_tier_ibgp_edges(ibgp_routers) elif max_level == 2: up_links, down_links, over_links = build_two_tier_ibgp(ibgp_routers) elif max_level == 1: up_links = [] down_links = [] over_links = [ (s, t) for (s, t) in all_pairs if s.ibgp_l3_cluster == t.ibgp_l3_cluster and s.ibgp_l2_cluster == t.ibgp_l2_cluster ] else: # no iBGP up_links = [] down_links = [] over_links = [] if max_level > 0: g_bgp.add_edges_from(up_links, type="ibgp", direction="up") g_bgp.add_edges_from(down_links, type="ibgp", direction="down") g_bgp.add_edges_from(over_links, type="ibgp", direction="over") else: log.debug("No iBGP routers in %s" % asn) # and set label back ibgp_label_to_level = {0: "None", 3: "RR", 1: "RRC", 2: "HRR"} # Explicitly set role to "None" -> Not in iBGP for node in g_bgp: node.ibgp_role = ibgp_label_to_level[node.ibgp_level] ebgp_nodes = [d for d in g_bgp if any(edge.type == "ebgp" for edge in d.edges())] g_bgp.update(ebgp_nodes, ebgp=True) for ebgp_edge in g_bgp.edges(type="ebgp"): for interface in ebgp_edge.interfaces(): interface.ebgp = True for edge in g_bgp.edges(type="ibgp"): # TODO: need interface querying/selection. rather than hard-coded ids edge.bind_interface(edge.src, 0) # TODO: need to initialise interface zero to be a loopback rather than physical type for node in g_bgp: for interface in node.interfaces(): interface.multipoint = any(e.multipoint for e in interface.edges())
def build_bgp(anm): """Build iBGP end eBGP overlays""" # eBGP g_in = anm['input'] g_phy = anm['phy'] if not anm['phy'].data.enable_routing: log.info("Routing disabled, not configuring BGP") return build_ebgp(anm) build_ebgp_v4(anm) build_ebgp_v6(anm) """TODO: remove from here once compiler updated""" g_bgp = anm.add_overlay("bgp", directed=True) g_bgp.add_nodes_from(g_in.nodes("is_router")) ebgp_edges = [edge for edge in g_in.edges() if not edge.attr_equal("asn")] g_bgp.add_edges_from(ebgp_edges, bidirectional=True, type='ebgp') #TODO: why don't we include edge_id here ebgp_switches = [n for n in g_in.nodes("is_switch") if not ank_utils.neigh_equal(g_phy, n, "asn")] g_bgp.add_nodes_from(ebgp_switches, retain=['asn']) log.debug("eBGP switches are %s" % ebgp_switches) g_bgp.add_edges_from((e for e in g_in.edges() if e.src in ebgp_switches or e.dst in ebgp_switches), bidirectional=True, type='ebgp') ank_utils.aggregate_nodes(g_bgp, ebgp_switches, retain="edge_id") ebgp_switches = list(g_bgp.nodes("is_switch")) # need to recalculate as may have aggregated log.debug("aggregated eBGP switches are %s" % ebgp_switches) exploded_edges = ank_utils.explode_nodes(g_bgp, ebgp_switches, retain="edge_id") same_asn_edges = [] for edge in exploded_edges: if edge.src.asn == edge.dst.asn: same_asn_edges.append(edge) else: edge.multipoint = True """TODO: remove up to here once compiler updated""" g_bgp.remove_edges_from(same_asn_edges) # now iBGP ank_utils.copy_attr_from(g_in, g_bgp, "ibgp_level") ank_utils.copy_attr_from(g_in, g_bgp, "ibgp_l2_cluster") ank_utils.copy_attr_from(g_in, g_bgp, "ibgp_l3_cluster") for node in g_bgp: # set defaults if node.ibgp_level is None: node.ibgp_level = 1 if node.ibgp_level == "None": # if unicode string from yEd node.ibgp_level = 1 #TODO CHECK FOR IBGP NONE node.ibgp_level = int(node.ibgp_level) # ensure is numeric if not node.ibgp_l2_cluster or node.ibgp_l2_cluster == "None": # ibgp_l2_cluster defaults to region node.ibgp_l2_cluster = node.region or "default_l2_cluster" if not node.ibgp_l3_cluster or node.ibgp_l3_cluster == "None": # ibgp_l3_cluster defaults to ASN node.ibgp_l3_cluster = node.asn for asn, devices in ank_utils.groupby("asn", g_bgp): # group by nodes in phy graph routers = list(g_bgp.node(n) for n in devices if n.is_router) # list of nodes from bgp graph ibgp_levels = {int(r.ibgp_level) for r in routers} max_level = max(ibgp_levels) # all possible edge src/dst pairs ibgp_routers = [r for r in routers if r.ibgp_level > 0] all_pairs = [(s, t) for s in ibgp_routers for t in ibgp_routers if s != t] if max_level == 3: up_links, down_links, over_links = three_tier_ibgp_edges(ibgp_routers) elif max_level == 2: #TODO: check when this is reached - as RR is not HRR.... due to naming/levels mapping up_links, down_links, over_links = build_two_tier_ibgp(ibgp_routers) elif max_level == 1: up_links = [] down_links = [] over_links = [(s, t) for (s, t) in all_pairs if s.ibgp_l3_cluster == t.ibgp_l3_cluster and s.ibgp_l2_cluster == t.ibgp_l2_cluster ] else: # no iBGP up_links = [] down_links = [] over_links = [] if max_level > 0: g_bgp.add_edges_from(up_links, type='ibgp', direction='up') g_bgp.add_edges_from(down_links, type='ibgp', direction='down') g_bgp.add_edges_from(over_links, type='ibgp', direction='over') else: log.debug("No iBGP routers in %s" % asn) # and set label back ibgp_label_to_level = { 0: "None", # Explicitly set role to "None" -> Not in iBGP 3: "RR", 1: "RRC", 2: "HRR", } for node in g_bgp: node.ibgp_role = ibgp_label_to_level[node.ibgp_level] ebgp_nodes = [d for d in g_bgp if any( edge.type == 'ebgp' for edge in d.edges())] g_bgp.update(ebgp_nodes, ebgp=True) for ebgp_edge in g_bgp.edges(type = "ebgp"): for interface in ebgp_edge.interfaces(): interface.ebgp = True for edge in g_bgp.edges(type='ibgp'): # TODO: need interface querying/selection. rather than hard-coded ids edge.bind_interface(edge.src, 0) #TODO: need to initialise interface zero to be a loopback rather than physical type for node in g_bgp: for interface in node.interfaces(): interface.multipoint = any(e.multipoint for e in interface.edges()) build_ibgp_v4(anm) build_ibgp_v6(anm)
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)
def build_ip(anm): #TODO: use the l3_conn graph g_ip = anm.add_overlay('ip') g_in = anm['input'] g_graphics = anm['graphics'] g_phy = anm['phy'] #TODO: add these from layer2 graph - and scrap g_ip: clone g_layer2 to g_ipv4 and g_ipv6 g_ip.add_nodes_from(g_phy) g_ip.add_edges_from(g_phy.edges()) ank_utils.aggregate_nodes(g_ip, g_ip.switches()) edges_to_split = [edge for edge in g_ip.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_ip, edges_to_split, retain=['split'], id_prepend='cd')) 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.switches() # regenerate due to aggregated g_ip.update(switch_nodes, broadcast_domain=True) # switches are part of collision domain g_ip.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_ip, node, 'host', g_phy): node.host = ank_utils.neigh_attr(g_ip, 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_ip, broadcast_domain=False) for node in g_ip.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 node.cd_id = cd_label graphics_node.label = cd_label node.device_type = "broadcast_domain"
def build_bgp(anm): """Build iBGP end eBGP overlays""" # eBGP g_in = anm['input'] g_phy = anm['phy'] if not anm['phy'].data.enable_routing: log.info("Routing disabled, not configuring BGP") return build_ebgp(anm) build_ebgp_v4(anm) build_ebgp_v6(anm) """TODO: remove from here once compiler updated""" g_bgp = anm.add_overlay("bgp", directed=True) g_bgp.add_nodes_from(g_in.routers()) ebgp_edges = [edge for edge in g_in.edges() if edge.src.asn != edge.dst.asn] g_bgp.add_edges_from(ebgp_edges, bidirectional=True, type='ebgp') ebgp_switches = [n for n in g_in.switches() if not ank_utils.neigh_equal(g_phy, n, "asn")] g_bgp.add_nodes_from(ebgp_switches, retain=['asn']) log.debug("eBGP switches are %s" % ebgp_switches) g_bgp.add_edges_from((e for e in g_in.edges() if e.src in ebgp_switches or e.dst in ebgp_switches), bidirectional=True, type='ebgp') ank_utils.aggregate_nodes(g_bgp, ebgp_switches) ebgp_switches = list(g_bgp.switches()) # need to recalculate as may have aggregated log.debug("aggregated eBGP switches are %s" % ebgp_switches) exploded_edges = ank_utils.explode_nodes(g_bgp, ebgp_switches) same_asn_edges = [] for edge in exploded_edges: if edge.src.asn == edge.dst.asn: same_asn_edges.append(edge) else: edge.multipoint = True """TODO: remove up to here once compiler updated""" ank_utils.copy_attr_from(g_in, g_bgp, "custom_config_bgp", dst_attr="custom_config") g_bgp.remove_edges_from(same_asn_edges) build_ibgp(anm) ebgp_nodes = [d for d in g_bgp if any( edge.type == 'ebgp' for edge in d.edges())] g_bgp.update(ebgp_nodes, ebgp=True) for ebgp_edge in g_bgp.edges(type = "ebgp"): for interface in ebgp_edge.interfaces(): interface.ebgp = True for edge in g_bgp.edges(type='ibgp'): # TODO: need interface querying/selection. rather than hard-coded ids edge.bind_interface(edge.src, 0) #TODO: need to initialise interface zero to be a loopback rather than physical type for node in g_bgp: for interface in node.interfaces(): interface.multipoint = any(e.multipoint for e in interface.edges()) build_ibgp_v4(anm) build_ibgp_v6(anm)