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