Example #1
0
def apply_design_rules(anm):
    """Applies appropriate design rules to ANM"""
    g_in = anm['input']

    build_phy(anm)
    g_phy = anm['phy']

    import autonetkit
    autonetkit.update_http(anm)
    build_l3_connectivity(anm)

    check_server_asns(anm)
    autonetkit.update_http(anm)

    build_vrf(anm) # need to do before to add loopbacks before ip allocations
    from autonetkit.design.ip import build_ip, build_ipv4,build_ipv6
    build_ip(anm) # ip infrastructure topology

#TODO: set defaults at the start, rather than inline, ie set g_in.data.address_family then use later

    address_family = g_in.data.address_family or "v4" # default is v4
#TODO: can remove the infrastructure now create g_ip seperately
    if address_family == "None":
        log.info("IP addressing disabled, disabling routing protocol configuration")
        anm['phy'].data.enable_routing = False

    if address_family == "None":
        log.info("IP addressing disabled, skipping IPv4")
        anm.add_overlay("ipv4") # create empty so rest of code follows through
        g_phy.update(g_phy, use_ipv4 = False)
    elif address_family in ("v4", "dual_stack"):
        build_ipv4(anm, infrastructure = True)
        g_phy.update(g_phy, use_ipv4 = True)
    elif address_family == "v6":
        # Allocate v4 loopbacks for router ids
        build_ipv4(anm, infrastructure = False)
        g_phy.update(g_phy, use_ipv4 = False)

    #TODO: Create a collision domain overlay for ip addressing - l2 overlay?
    if address_family == "None":
        log.info("IP addressing disabled, not allocating IPv6")
        anm.add_overlay("ipv6") # create empty so rest of code follows through
        g_phy.update(g_phy, use_ipv6 = False)
    elif address_family in ("v6", "dual_stack"):
        build_ipv6(anm)
        g_phy.update(g_phy, use_ipv6 = True)
    else:
        anm.add_overlay("ipv6") # placeholder for compiler logic

    default_igp = g_in.data.igp or "ospf"
    non_igp_nodes = [n for n in g_in if not n.igp]
#TODO: should this be modifying g_in?
    g_in.update(non_igp_nodes, igp=default_igp) # store igp onto each node

    ank_utils.copy_attr_from(g_in, g_phy, "include_csr")

    try:
        from autonetkit_cisco import build_network as cisco_build_network
    except ImportError, e:
        log.debug("Unable to load autonetkit_cisco %s" % e)
Example #2
0
def manage_network(input_graph_string, timestamp,
    build_options, reload_build=False, grid=None):
    """Build, compile, render network as appropriate"""
    # import build_network_simple as build_network
    import autonetkit.build_network as build_network
    if reload_build:
# remap?
        build_network = reload(build_network)

    if build_options['build']:
        if input_graph_string:
            graph = build_network.load(input_graph_string)
        elif grid:
            graph = build_network.grid_2d(grid)

        anm = build_network.build(graph)
        if not build_options['compile']:
            update_http(anm)

        if build_options['validate']:
            import autonetkit.ank_validate
            try:
                autonetkit.ank_validate.validate(anm)
            except Exception, e:
                log.warning("Unable to validate topologies: %s" % e)
                log.debug("Unable to validate topologies", exc_info=True)
Example #3
0
def collect_sh_ip_route(anm, nidb, start_node = None):
    if not start_node:
        start_node = random.choice([n for n in nidb.nodes("is_router")])

    #TODO: move this to another module, eg measure
    import autonetkit.measure as measure
    import autonetkit.verify as verify
    import autonetkit
    command = 'vtysh -c "show ip route"'
    #TODO: make auto take tap ip if netkit platform node
    #TODO: auto make put into list if isinstance(remote_hosts, nidb_node)
    remote_hosts = [start_node.tap.ip]
    result = measure.send(nidb, command, remote_hosts)

    processed = []
    for line in result:
        processed.append([anm['ipv4'].node(n) for n in line])

    #TODO: move this into verify module
    verification_results = verify.igp_routes(anm, processed)
    processed_with_results = []
    for line in processed:
        prefix = str(line[-1].subnet)
        try:
            result = verification_results[prefix]
        except KeyError:
            result = False # couldn't find prefix
        processed_with_results.append({
            'path': line,
            'verified': result,
            })

    autonetkit.update_http(anm, nidb)
    ank_messaging.highlight([], [], processed_with_results)
Example #4
0
def collect_sh_ip_route(anm, nidb, start_node=None):
    if not start_node:
        start_node = random.choice([n for n in nidb.nodes("is_router")])

    #TODO: move this to another module, eg measure
    import autonetkit.measure as measure
    import autonetkit.verify as verify
    import autonetkit
    command = 'vtysh -c "show ip route"'
    #TODO: make auto take tap ip if netkit platform node
    #TODO: auto make put into list if isinstance(remote_hosts, nidb_node)
    remote_hosts = [start_node.tap.ip]
    result = measure.send(nidb, command, remote_hosts)

    processed = []
    for line in result:
        processed.append([anm['ipv4'].node(n) for n in line])

    #TODO: move this into verify module
    verification_results = verify.igp_routes(anm, processed)
    processed_with_results = []
    for line in processed:
        prefix = str(line[-1].subnet)
        try:
            result = verification_results[prefix]
        except KeyError:
            result = False  # couldn't find prefix
        processed_with_results.append({
            'path': line,
            'verified': result,
        })

    autonetkit.update_http(anm, nidb)
    ank_messaging.highlight([], [], processed_with_results)
Example #5
0
def build(input_graph):
    """Main function to build network overlay topologies"""
    anm = None
    try:
        anm = initialise(input_graph)
        anm = apply_design_rules(anm)
        #print {str(node): {'x': node.x, 'y': node.y} for node in anm['input']}
        import autonetkit
        autonetkit.update_http(anm)
    except Exception, e:
        # Send the visualisation to help debugging
        import autonetkit
        try:
            autonetkit.update_http(anm)
        except Exception, e:
            # problem with vis -> could be coupled with original exception - raise original
            log.warning("Unable to visualise: %s" % e)
Example #6
0
def manual_ipv4_infrastructure_allocation(anm):
    """Applies manual IPv4 allocation"""
    import netaddr
    g_ipv4 = anm['ipv4']

    for node in g_ipv4.nodes("is_l3device"):
        for interface in node.physical_interfaces:
            if not interface['input'].is_bound:
                continue # unbound interface
            ip_address = netaddr.IPAddress(interface['input'].ipv4_address)
            prefixlen = interface['input'].ipv4_prefixlen
            interface.ip_address = ip_address
            interface.prefixlen = prefixlen
            cidr_string = "%s/%s" % (ip_address, prefixlen)
            interface.subnet = netaddr.IPNetwork(cidr_string)

    collision_domains = [d for d in g_ipv4 if d.collision_domain]
    #TODO: allow this to work with specified ip_address/subnet as well as ip_address/prefixlen
    from netaddr import IPNetwork
    for cd in collision_domains:
        connected_interfaces = [edge.dst_int for edge in cd.edges()]
        cd_subnets = [IPNetwork("%s/%s" % (i.subnet.network, i.prefixlen))
            for i in connected_interfaces]

        try:
            assert(len(set(cd_subnets)) == 1)
        except AssertionError:
            log.warning("Non matching subnets from collision domain %s" % cd)
        else:
            cd.subnet = cd_subnets[0] # take first entry

        # apply to remote interfaces
        for edge in cd.edges():
            remote_interface = edge.dst_int
            edge.dst_int.subnet = cd.subnet

    # also need to form aggregated IP blocks (used for e.g. routing prefix
    # advertisement)
    autonetkit.update_http(anm)
    infra_blocks = {}
    for asn, devices in g_ipv4.groupby("asn").items():
        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_ipv4.data.infra_blocks = infra_blocks
Example #7
0
def build(input_graph):
    """Main function to build network overlay topologies"""
    anm = None
    try:
        anm = initialise(input_graph)
        anm = apply_design_rules(anm)
        # print {str(node): {'x': node.x, 'y': node.y} for node in
        # anm['input']}
        autonetkit.update_http(anm)
    except Exception, e:
        # Send the visualisation to help debugging
        try:
            autonetkit.update_http(anm)
        except Exception, e:
            # problem with vis -> could be coupled with original exception -
            # raise original
            log.warning("Unable to visualise: %s" % e)
Example #8
0
def apply_design_rules(anm):
    g_in = anm['input']

    build_phy(anm)
    g_phy = anm['phy']

    autonetkit.update_http(anm)
    build_l3_connectivity(anm)

    build_vrf(anm) # need to do before to add loopbacks before ip allocations
    build_ip(anm) # ip infrastructure topology

#TODO: set defaults at the start, rather than inline, ie set g_in.data.address_family then use later

    address_family = g_in.data.address_family or "v4" # default is v4
#TODO: can remove the infrastructure now create g_ip seperately
    if address_family in ("v4", "dual_stack"):
        build_ipv4(anm, infrastructure = True)
        g_phy.update(g_phy, use_ipv4 = True)
    else:
        build_ipv4(anm, infrastructure = False)

    #TODO: Create a collision domain overlay for ip addressing - l2 overlay?
    if address_family in ("v6", "dual_stack"):
        build_ipv6(anm)
        g_phy.update(g_phy, use_ipv6 = True)
    else:
        anm.add_overlay("ipv6") # placeholder for compiler logic

    default_igp = g_in.data.igp or "ospf" 
    non_igp_nodes = [n for n in g_in if not n.igp]
#TODO: should this be modifying g_in?
    g_in.update(non_igp_nodes, igp=default_igp) # store igp onto each node

    ank_utils.copy_attr_from(g_in, g_phy, "include_csr")

    build_ospf(anm)
    build_isis(anm)
    build_bgp(anm)
    autonetkit.update_http(anm)

# post-processing
    mark_ebgp_vrf(anm)
    build_ibgp_vpn_v4(anm) # build after bgp as is based on
    #autonetkit.update_http(anm)
    return anm
Example #9
0
def apply_design_rules(anm):
    g_in = anm['input']

    build_phy(anm)
    g_phy = anm['phy']

    build_vrf(anm)  # need to do before to add loopbacks before ip allocations
    build_ip(anm)  # ip infrastructure topology

    #TODO: set defaults at the start, rather than inline, ie set g_in.data.address_family then use later

    address_family = g_in.data.address_family or "v4"  # default is v4
    #TODO: can remove the infrastructure now create g_ip seperately
    if address_family in ("v4", "dual_stack"):
        build_ipv4(anm, infrastructure=True)
        g_phy.update(g_phy, use_ipv4=True)
    else:
        build_ipv4(anm, infrastructure=False)

    #TODO: Create a collision domain overlay for ip addressing - l2 overlay?
    if address_family in ("v6", "dual_stack"):
        build_ipv6(anm)
        g_phy.update(g_phy, use_ipv6=True)
    else:
        anm.add_overlay("ipv6")  # placeholder for compiler logic

    default_igp = g_in.data.igp or "ospf"
    non_igp_nodes = [n for n in g_in if not n.igp]
    #TODO: should this be modifying g_in?
    g_in.update(non_igp_nodes, igp=default_igp)  # store igp onto each node

    ank_utils.copy_attr_from(g_in, g_phy, "include_csr")

    build_ospf(anm)
    build_isis(anm)
    build_bgp(anm)
    autonetkit.update_http(anm)

    # post-processing
    mark_ebgp_vrf(anm)
    build_ibgp_vpn_v4(anm)  # build after bgp as is based on
    #autonetkit.update_http(anm)
    return anm
Example #10
0
def manage_network(input_graph_string, timestamp, build_options, reload_build=False, grid = None):
    """Build, compile, render network as appropriate"""
    # import build_network_simple as build_network
    import autonetkit.build_network as build_network
    if reload_build:
# remap?
        build_network = reload(build_network)

    if build_options['build']:
        if input_graph_string:
            graph = build_network.load(input_graph_string)
        elif grid:
            graph = build_network.grid_2d(grid)

        anm = build_network.build(graph)
        if not build_options['compile']:
            update_http(anm)

        if build_options['validate']:
            import autonetkit.ank_validate
            autonetkit.ank_validate.validate(anm)

    if build_options['compile']:
        if build_options['archive']:
            anm.save()
        nidb = compile_network(anm)

        update_http(anm, nidb)
        log.debug("Sent ANM to web server")
        if build_options['archive']:
            nidb.save()
        # render.remove_dirs(["rendered"])
        if build_options['render']:
            render.render(nidb)

    if not(build_options['build'] or build_options['compile']):
        # Load from last run
        import autonetkit.anm
        anm = autonetkit.anm.AbstractNetworkModel()
        anm.restore_latest()
        nidb = NIDB()
        nidb.restore_latest()
        update_http(anm, nidb)

    if build_options['diff']:
        import autonetkit.diff
        nidb_diff = autonetkit.diff.nidb_diff()
        import json
        data = json.dumps(nidb_diff, cls=ank_json.AnkEncoder, indent=4)
        log.info("Wrote diff to diff.json")
        with open("diff.json", "w") as fh:  # TODO: make file specified in config
            fh.write(data)

    if build_options['deploy']:
        deploy_network(anm, nidb, input_graph_string)

    if build_options['measure']:
        measure_network(anm, nidb)

    log.info("Finished")
Example #11
0
def build_ipv6(anm):
    """Builds IPv6 graph, using nodes and edges from IPv4 graph"""
    import autonetkit.plugins.ipv6 as ipv6

    # uses the nodes and edges from ipv4
    g_ipv6 = anm.add_overlay("ipv6")
    g_ip = anm["ip"]
    g_ipv6.add_nodes_from(g_ip, retain="collision_domain")  # retain if collision domain or not
    g_ipv6.add_edges_from(g_ip.edges())
    autonetkit.update_http(anm)

    ipv6.allocate_ips(g_ipv6)

    # TODO: replace this with direct allocation to interfaces in ip alloc plugin
    for node in g_ipv6.nodes("is_l3device"):
        node.loopback_zero.ip_address = node.loopback
        for interface in node:
            edges = list(interface.edges())
            if len(edges):
                edge = edges[0]  # first (only) edge
                interface.ip_address = edge.ip  # TODO: make this consistent
                interface.subnet = edge.dst.subnet  # from collision domain
Example #12
0
def initialise(input_graph):
    """Initialises the input graph with from a NetworkX graph"""
    anm = autonetkit.anm.AbstractNetworkModel()

    input_undirected = nx.Graph(input_graph)
    g_in = anm.add_overlay("input", graph=input_undirected)
    anm.add_overlay("input_directed", graph=input_graph, directed=True)

# set defaults
    if not g_in.data.specified_int_names:
        # if not specified then automatically assign interface names
        g_in.data.specified_int_names = False

    import autonetkit.plugins.graph_product as graph_product
    graph_product.expand(g_in)  # apply graph products if relevant

    expand_fqdn = False
    # TODO: make this set from config and also in the input file
    if expand_fqdn and len(ank_utils.unique_attr(g_in, "asn")) > 1:
        # Multiple ASNs set, use label format device.asn
        anm.set_node_label(".", ['label', 'pop', 'asn'])

    g_in.update(
        g_in.nodes("is_router", platform="junosphere"), syntax="junos")
    g_in.update(g_in.nodes("is_router", platform="dynagen"), syntax="ios")
    g_in.update(g_in.nodes("is_router", platform="netkit"), syntax="quagga")
    g_in.update(g_in.nodes("is_server", platform="netkit"), syntax="quagga")

    g_graphics = anm.add_overlay("graphics")  # plotting data
    g_graphics.add_nodes_from(g_in, retain=['x', 'y', 'device_type',
        'label', 'device_subtype', 'pop', 'asn'])

    if g_in.data.Creator == "Maestro":
        # Multiple ASNs set, use label format device.asn
        anm.set_node_label(".", ['label_full'])

    autonetkit.update_http(anm)
    return anm
Example #13
0
def manage_network(input_graph_string, timestamp, build_options, reload_build=False, grid=None):
    """Build, compile, render network as appropriate"""
    # import build_network_simple as build_network
    import autonetkit.build_network as build_network
    if reload_build:
# remap?
        build_network = reload(build_network)

    if build_options['build']:
        if input_graph_string:
            graph = build_network.load(input_graph_string)
        elif grid:
            graph = build_network.grid_2d(grid)

        anm = build_network.build(graph)
        if not build_options['compile']:
            update_http(anm)

        if build_options['validate']:
            import autonetkit.ank_validate
            try:
                autonetkit.ank_validate.validate(anm)
            except Exception, e:
                log.warning("Unable to validate topologies: %s" % e)
Example #14
0
def build_ipv4(anm, infrastructure=True):
    """Builds IPv4 graph"""
    g_ipv4 = anm.add_overlay("ipv4")
    g_ip = anm["ip"]
    g_in = anm["input"]
    g_ipv4.add_nodes_from(g_ip, retain="collision_domain")  # retain if collision domain or not
    # Copy ASN attribute chosen for collision domains (used in alloc algorithm)
    ank_utils.copy_attr_from(g_ip, g_ipv4, "asn", nbunch=g_ipv4.nodes("collision_domain"))
    g_ipv4.add_edges_from(g_ip.edges())
    autonetkit.update_http(anm)

    # TODO: need to set allocate_ipv4 by default in the readers
    if g_in.data.alloc_ipv4_infrastructure is False:
        manual_ipv4_infrastructure_allocation(anm)
    else:
        import autonetkit.plugins.ipv4 as ipv4

        ipv4.allocate_ips(g_ipv4, infrastructure=True, loopbacks=False)
        # ank_utils.save(g_ipv4)

    if g_in.data.alloc_ipv4_loopbacks is False:
        manual_ipv4_loopback_allocation(anm)
    else:
        import autonetkit.plugins.ipv4 as ipv4

        ipv4.allocate_ips(g_ipv4, infrastructure=False, loopbacks=True)
        # ank_utils.save(g_ipv4)

    # TODO: need to also support secondary_loopbacks for IPv6
    ipv4.allocate_ips(g_ipv4, infrastructure=False, loopbacks=False, secondary_loopbacks=True)

    autonetkit.update_http(anm)

    # TODO: replace this with direct allocation to interfaces in ip alloc plugin
    for node in g_ipv4.nodes("is_l3device"):
        node.loopback_zero.ip_address = node.loopback
        for interface in node:
            edges = list(interface.edges())
            if len(edges):
                edge = edges[0]  # first (only) edge
                interface.ip_address = edge.ip_address
                interface.subnet = edge.dst.subnet  # from collision domain

    # TODO: also map loopbacks to loopback interface 0
    autonetkit.update_http(anm)
Example #15
0
g_dir = anm.add_overlay("dir", directed=True)
g_dir.add_nodes_from(g_phy)
g_dir.add_edges_from(([("r1", "r2")]))
g_dir.add_edges_from(([("r2", "r1")]))
g_dir.add_edges_from(([("r1", "r3")]))

g_dir_multi = anm.add_overlay("dir_multi", directed=True, multi_edge=True)
g_dir_multi.add_nodes_from(g_phy)
g_dir_multi.add_edges_from(([("r1", "r2")]))
g_dir_multi.add_edges_from(([("r1", "r2")]))
g_dir_multi.add_edges_from(([("r1", "r2")]))
g_dir_multi.add_edges_from(([("r1", "r2")]))
g_dir_multi.add_edges_from(([("r2", "r1")]))
g_dir_multi.add_edges_from(([("r2", "r1")]))
g_dir_multi.add_edges_from(([("r2", "r1")]))
g_dir_multi.add_edges_from(([("r2", "r1")]))
g_dir_multi.add_edges_from(([("r2", "r1")]))
g_dir_multi.add_edges_from(([("r1", "r3")]))

for index, edge in enumerate(g_dir_multi.edges()):
    #print index, edge
    edge.index = "i_%s" % index

from networkx.readwrite import json_graph
import json
data = json_graph.node_link_data(graph)
with open("multi.json", "w") as fh:
    fh.write(json.dumps(data, indent=2))

autonetkit.update_http(anm)
Example #16
0
        if build_options['validate']:
            import autonetkit.ank_validate
            try:
                autonetkit.ank_validate.validate(anm)
            except Exception, e:
                log.warning("Unable to validate topologies: %s" % e)
                log.debug("Unable to validate topologies", exc_info=True)


    if build_options['compile']:
        if build_options['archive']:
            anm.save()
        nidb = compile_network(anm)

        update_http(anm, nidb)
        log.debug("Sent ANM to web server")
        if build_options['archive']:
            nidb.save()
        # render.remove_dirs(["rendered"])
        if build_options['render']:
            render.render(nidb)

    if not(build_options['build'] or build_options['compile']):
        # Load from last run
        import autonetkit.anm
        anm = autonetkit.anm.NetworkModel()
        anm.restore_latest()
        nidb = DeviceModel()
        nidb.restore_latest()
        update_http(anm, nidb)
Example #17
0
        if not build_options['compile']:
            update_http(anm)

        if build_options['validate']:
            import autonetkit.ank_validate
            try:
                autonetkit.ank_validate.validate(anm)
            except Exception, e:
                log.warning("Unable to validate topologies: %s" % e)

    if build_options['compile']:
        if build_options['archive']:
            anm.save()
        nidb = compile_network(anm)

        update_http(anm, nidb)
        log.debug("Sent ANM to web server")
        if build_options['archive']:
            nidb.save()
        # render.remove_dirs(["rendered"])
        if build_options['render']:
            render.render(nidb)

    if not(build_options['build'] or build_options['compile']):
        # Load from last run
        import autonetkit.anm
        anm = autonetkit.anm.AbstractNetworkModel()
        anm.restore_latest()
        nidb = NIDB()
        nidb.restore_latest()
        update_http(anm, nidb)
Example #18
0
import autonetkit.collection.process as ank_process
import autonetkit.ank_messaging as ank_messaging
import autonetkit

import pkg_resources
parse_template = pkg_resources.resource_filename("autonetkit",
                                                 "textfsm/linux/traceroute")

anm = autonetkit.ANM()
anm.restore_latest()

nidb = autonetkit.NIDB()
nidb.restore_latest()
print list(nidb.nodes())

autonetkit.update_http(anm, nidb)

emulation_server = "115.146.93.18"
command_list = []

import autonetkit.collection.process as ank_process
reverse_mappings = ank_process.build_reverse_mappings_from_nidb(nidb)

import random
dest_node = random.choice(list(nidb.routers()))
#dest_node = nidb.node("as1r1")
#dest_node = nidb.node("as40r1")
#dest_label = random.choice(["as1r1", "as30r1", "as20r3"])
#dest_node = nidb.node(dest_label)
dest_ip = dest_node.interfaces[1].ipv4_address
command = "traceroute -n -a -U -w 0.5 %s" % dest_ip
Example #19
0
def test():
    log.info("Testing ANM")

    anm = autonetkit.NetworkModel()

    g_in = anm.add_overlay("input")

    router_ids = ["r1", "r2", "r3", "r4", "r5"]
    g_in.add_nodes_from(router_ids)

    g_in.update(device_type="router")
    g_in.update(asn=1)

    positions = {
        'r3': (107, 250),
        'r5': (380, 290),
        'r1': (22, 50),
        'r2': (377, 9),
        'r4': (571, 229)
    }
    for node in g_in:
        node.x = positions[node][0]
        node.y = positions[node][1]
        eth0 = node.add_interface("eth0")
        eth0.speed = 100

    # node->node edges
    input_edges = [("r1", "r2"), ("r2", "r4"), ("r3", "r4"), ("r3", "r5"),
                   ("r1", "r3")]
    input_interface_edges = [(g_in.node(src).interface(1),
                              g_in.node(dst).interface(1))
                             for src, dst in input_edges]
    g_in.add_edges_from(input_interface_edges)

    g_phy = anm['phy']
    g_phy.add_nodes_from(g_in, retain=["device_type", "x", "y", "asn"])
    g_phy.add_edges_from(g_in.edges())

    g_test = anm.add_overlay("test")
    g_test.add_node("test_node")

    # test interfaces
    for node in g_phy:
        pass

    test_node = g_phy.node("r1")

    #TODO: assert here
    node_interfaces = list(test_node.interfaces())
    # test equality
    #TODO: check why == uses eq() but != doesn't...
    assert (not node_interfaces[0] == node_interfaces[1])

    print list(test_node.interfaces())
    for i in test_node.interfaces():
        print i, i.dump()

    print[i.description for i in sorted(node_interfaces)]

    assert ([i.description
             for i in sorted(node_interfaces)] == ['loopback', 'eth0'])

    for interface in test_node:
        # test exists
        assert (interface is not None)
        # test __nonzero__
        assert (interface)
        set_value = 123
        interface.test = set_value
        get_value = interface.test
        assert (set_value == get_value
                )  # TODO: could check is indeed same object reference

    loopback0 = test_node.interface(0)
    assert (not loopback0.is_bound)
    assert (loopback0.is_loopback)
    assert (not loopback0.is_physical)
    assert (loopback0.is_loopback_zero)

    #TODO: need to add more loopbacks to test
    print loopback0
    assert (str(loopback0) == "loopback.r1")

    eth0 = test_node.interface(1)
    assert (eth0.is_bound)
    assert (not eth0.is_loopback)
    assert (not eth0.is_loopback_zero)
    assert (eth0.is_physical)

    assert (eth0.phy == eth0)  # should be itself as phy overlay

    #print eth0.dump()

    #Cross-layer access
    assert (eth0['input'] is not None)

    assert (sorted(eth0.neighbors()) == [
        g_phy.node("r2").interface(1),
        g_phy.node("r3").interface(1)
    ])

    # access non existent overlay
    #TODO: decide if worth trying to assert the logged item
    eth0["non_existent_overlay"]
    # Need to test cross-layer interface access to phy

    #test accessing overlay for node that doesnt exist in that overlay
    test_overlay_node = g_test.node("test_node")
    test_overlay_interface = test_overlay_node.add_interface()
    test_overlay_interface['phy']

    #Want to assertRaises

    # Test edges
    autonetkit.update_http(anm)
    test_edge = g_in.edge("r1", "r2")
    assert (test_edge is not None)

    # test overlays

    # test ANM
    test_node = g_phy.node("r1")
    assert (test_node.asn == 1)
    assert (test_node.device_type == "router")
    #TODO: also need to test for servers
    assert (test_node.is_l3device())
    assert (test_node.is_router())
    assert (not test_node.is_switch())
    assert (not test_node.is_server())
    assert (str(sorted(list(test_node.neighbors()))) == "[r2, r3]")
    assert (str(sorted(list(
        test_node.neighbor_interfaces()))) == "[eth0.r2, eth0.r3]")
    # Test getting from another overlay
    assert (test_node['input'].asn == 1)

    assert (str(sorted(g_phy.nodes())) == "[r1, r2, r3, r4, r5]")

    assert (test_node.label == "r1")
    """
    g_in.update("r4", asn = 2)
    g_in.update(["r1", "r2", "r3"], asn = 1)

    test = g_in.node("r5")

    """
    # More graph level tests
    #TODO: need to allow searching for interface by .interface("eth1", "r1")

    #TODO: need to provide remove_nodes_from

    test_node = g_phy.node("r1")
    search_int = list(test_node.interfaces())[0]
    result_int = g_phy.interface(search_int)
    assert (search_int == result_int)

    search_int = list(test_node.interfaces())[1]
    result_int = g_phy.interface(search_int)
    assert (search_int == result_int)

    assert (g_phy.node("r1").degree() == 2)
    assert (g_phy.node("r3").degree() == 3)

    g_phy.add_edge("r1", "r4")
    assert (g_phy.edge("r1", "r4") is not None)

    edges_to_remove = g_phy.edge("r1", "r4")
    #TODO: remove_edges_from needs to support single/list
    g_phy.remove_edges_from([edges_to_remove])
    assert (g_phy.edge("r1", "r4") is None)

    src_int = g_phy.node("r1").add_interface("eth1")
    dst_int = g_phy.node("r5").add_interface("eth1")
    g_phy.add_edges_from([(src_int, dst_int)])
    edge = g_phy.edge("r1", "r5")
    assert ((edge.src_int, edge.dst_int) == (src_int, dst_int))

    edge_a1 = g_phy.edge("r1", "r2")
    edge_a2 = g_phy.edge("r1", "r2")
    assert (edge_a1 == edge_a2)
    edge_b = g_phy.edge("r1", "r2")
    assert (edge_a1 != edge_b)

    # compare to string
    assert (edge_a1 == ("r1", "r2"))
    assert (edge_a1 != ("r1", "r3"))

    assert (bool(edge_a1) is True)  #exists
    edge_non_existent = g_phy.edge("r1", "r8")
    #TODO: need to document API to check exists/doesn't exist for nodes, edges, interfaces, graphs,....
    assert (bool(edge_non_existent) is False)  #doesn't exist

    # add node
    #TODO: better handling of nodes with no x,y, asn, etc in jsonify
    r6 = g_phy.add_node("r6")
    assert (r6 in g_phy)
    del g_phy[r6]
    assert (r6 not in g_phy)

    # graph data
    g_phy.data.test = 123
    assert (g_phy.data.test == 123)
    assert (g_phy.data['test'] == 123)

    # test adding a node with not attributes for jsonify

    #TODO: test for directed graph

    autonetkit.update_http(anm)
Example #20
0
def test():
	automated = True # whether to open ksdiff, log to file...
	if __name__ == "__main__":
	    automated = False

	dirname, filename = os.path.split(os.path.abspath(__file__))
	parent_dir = os.path.abspath(os.path.join(dirname, os.pardir))

	anm =  autonetkit.NetworkModel()
	input_file = os.path.join(parent_dir, "small_internet.graphml")
	input_graph = graphml.load_graphml(input_file)

	import autonetkit.build_network as build_network
	anm = build_network.initialise(input_graph)
	anm = build_network.apply_design_rules(anm)



	try:
		from websocket import create_connection
	except ImportError:
		print "websocket-client package not installed"
	else:
		autonetkit.update_http(anm)

		ws = create_connection("ws://localhost:8000/ws")
		ws.send("overlay_list")
		result =  ws.recv()
		expected = '{"overlay_list": ["bgp", "ebgp", "ebgp_v4", "ebgp_v6", "eigrp", graphics", "ibgp_v4", "ibgp_v6", "ibgp_vpn_v4", "input", "input_directed", "ip", "ipv4", "ipv6", "isis", "l3_conn", "ospf", "phy", "vrf"]}'
		assert(result == expected)

		overlay_id = "phy"
		ws.send("overlay_id=" + overlay_id)
		result =  ws.recv()
		with open(os.path.join(dirname, "expected_phy.json"), "r") as fh:
			expected = fh.read()

		assert(result == expected)
		ws.close()

		import autonetkit.console_script as console_script
		render_hostname = "localhost"

		nidb = console_script.create_nidb(anm)
		nidb._graph.graph['timestamp'] = "123456"

		import autonetkit.compilers.platform.netkit as pl_netkit
		nk_compiler = pl_netkit.NetkitCompiler(nidb, anm, render_hostname)
		nk_compiler.compile()
		autonetkit.update_http(anm, nidb)

		ws = create_connection("ws://localhost:8000/ws")
		ws.send("overlay_list")
		result =  ws.recv()
		expected = '{"overlay_list": ["bgp", "ebgp", "ebgp_v4", "ebgp_v6", "eigrp", graphics", "ibgp_v4", "ibgp_v6", "ibgp_vpn_v4", "input", "input_directed", "ip", "ipv4", "ipv6", "isis", "l3_conn", "nidb", "ospf", "phy", "vrf"]}'
		assert(result == expected)

		overlay_id = "nidb"
		ws.send("overlay_id=" + overlay_id)
		result =  ws.recv()
		with open(os.path.join(dirname, "expected_nidb.json"), "r") as fh:
			expected = fh.read()

		assert(result == expected)
		ws.close()
def test():

    anm = autonetkit.NetworkModel()
    g_phy = anm['phy']
    g_phy.add_nodes_from(["r1", "r2", "r3", "r4", "r5"])
    for node in g_phy:
        node.device_type = "router"

    g_phy.node("r1").x = 100
    g_phy.node("r1").y = 100
    g_phy.node("r2").x = 250
    g_phy.node("r2").y = 250
    g_phy.node("r3").x = 100
    g_phy.node("r3").y = 300
    g_phy.node("r4").x = 600
    g_phy.node("r4").y = 600
    g_phy.node("r5").x = 600
    g_phy.node("r5").y = 300

    g_phy.add_edges_from(([("r1", "r2")]))
    g_phy.add_edges_from(([("r1", "r3")]))
    #g_phy.add_edges_from(([("r2", "r3")]))
    #g_phy.add_edges_from(([("r2", "r4")]))
    #g_phy.add_edges_from(([("r4", "r3")]))
    #g_phy.add_edges_from(([("r4", "r5")]))

    g_simple = anm.add_overlay("simple")
    g_simple.add_nodes_from(g_phy)
    g_simple.add_edges_from(([("r1", "r2")]))
    g_simple.add_edges_from(([("r4", "r3")]))


    g_me = anm.add_overlay("multi", multi_edge = True)
    graph = g_me._graph

    g_me.add_nodes_from(g_phy)

    # add two edges
    g_me.add_edges_from(([("r1", "r2")]))
    g_me.add_edges_from(([("r1", "r2")]))
    g_me.add_edges_from(([("r1", "r2")]))
    g_me.add_edges_from(([("r1", "r2")]))
    g_me.add_edges_from(([("r1", "r2")]))
    g_me.add_edges_from(([("r1", "r3")]))
    g_me.add_edges_from(([("r2", "r3")]))
    g_me.add_edges_from(([("r2", "r3")]))

    r1 = g_me.node("r1")

    for index, edge in enumerate(g_me.edges()):
        #print index, edge
        edge.index = "i_%s" % index

    for edge in r1.edges():
        #print edge, edge.index
        pass


    """
    e1 = r1.edges()[0]
    e1a = g_me.edge(e1)
    assert(e1 == e1a)
    e2 = r1.edges()[1]
    assert(e1 != e2)
    #TODO: check why neq != also returns true for e1 != e1a
    """

    #print g_me.edge("r1", "r2", 0).index
    #print g_me.edge("r1", "r2", 1).index

    print "edges"
    for edge in g_me.edges():
        print edge

    out_of_order = [g_me.edge("r1", "r2", x) for x in [4, 1, 3, 2, 0]]
    #print [e.index for e in out_of_order]
    in_order = sorted(out_of_order)
    #print in_order
    #print [e.index for e in in_order]

    # test adding to another mutli edge graph
    print "adding"
    g_me2 = anm.add_overlay("multi2", multi_edge = True)
    g_me2.add_nodes_from(g_me)
    print "add", len(g_me.edges())
    g_me2.add_edges_from(g_me.edges(), retain = "index")
    for edge in g_me2.edges():
        print edge, edge.index

    # examine underlying nx structure


    #print graph
    #print type(graph)

    for u, v, k in graph.edges(keys=True):
        pass
        #print u, v, k
        #print graph[u][v][k].items()
        #graph[u][v][k]['test'] = 123

    g_dir = anm.add_overlay("dir", directed=True)
    g_dir.add_nodes_from(g_phy)
    g_dir.add_edges_from(([("r1", "r2")]))
    g_dir.add_edges_from(([("r2", "r1")]))
    g_dir.add_edges_from(([("r1", "r3")]))

    g_dir_multi = anm.add_overlay("dir_multi", directed = True, multi_edge = True)
    g_dir_multi.add_nodes_from(g_phy)
    g_dir_multi.add_edges_from(([("r1", "r2")]))
    g_dir_multi.add_edges_from(([("r1", "r2")]))
    g_dir_multi.add_edges_from(([("r1", "r2")]))
    g_dir_multi.add_edges_from(([("r1", "r2")]))
    g_dir_multi.add_edges_from(([("r2", "r1")]))
    g_dir_multi.add_edges_from(([("r2", "r1")]))
    g_dir_multi.add_edges_from(([("r2", "r1")]))
    g_dir_multi.add_edges_from(([("r2", "r1")]))
    g_dir_multi.add_edges_from(([("r2", "r1")]))
    g_dir_multi.add_edges_from(([("r1", "r3")]))

    for index, edge in enumerate(g_dir_multi.edges()):
        #print index, edge
        edge.index = "i_%s" % index

    from networkx.readwrite import json_graph
    import json
    data =  json_graph.node_link_data(graph)
    with open("multi.json", "w") as fh:
        fh.write(json.dumps(data, indent=2))

    autonetkit.update_http(anm)
Example #22
0
# test overlays

# test ANM
test_node = g_phy.node("r1")
assert test_node.asn == 1
assert test_node.device_type == "router"
# TODO: also need to test for servers
assert test_node.is_l3device()
assert test_node.is_router()
assert not test_node.is_switch()
assert not test_node.is_server()
assert str(list(test_node.neighbors())) == "[r2, r3]"
assert str(list(test_node.neighbor_interfaces())) == "[eth0.r2, eth0.r3]"
# Test getting from another overlay
assert test_node["input"].asn == 1

assert str(sorted(g_phy.nodes())) == "[r1, r2, r3, r4, r5]"

assert test_node.label == "r1"


"""
g_in.update("r4", asn = 2)
g_in.update(["r1", "r2", "r3"], asn = 1)

test = g_in.node("r5")
"""

autonetkit.update_http(anm)
Example #23
0
def build(input_graph):
    """Main function to build network overlay topologies"""
    anm = autonetkit.anm.AbstractNetworkModel()

    input_undirected = nx.Graph(input_graph)
    g_in = anm.add_overlay("input", graph=input_undirected)
    anm.add_overlay("input_directed", graph=input_graph, directed=True)

    # set defaults
    if not g_in.data.specified_int_names:
        # if not specified then automatically assign interface names
        g_in.data.specified_int_names = False

    import autonetkit.plugins.graph_product as graph_product

    graph_product.expand(g_in)  # apply graph products if relevant

    expand_fqdn = False
    # TODO: make this set from config and also in the input file
    if expand_fqdn and len(ank_utils.unique_attr(g_in, "asn")) > 1:
        # Multiple ASNs set, use label format device.asn
        anm.set_node_label(".", ["label", "pop", "asn"])

    g_in.update(g_in.nodes("is_router", platform="junosphere"), syntax="junos")
    g_in.update(g_in.nodes("is_router", platform="dynagen"), syntax="ios")
    g_in.update(g_in.nodes("is_router", platform="netkit"), syntax="quagga")

    g_graphics = anm.add_overlay("graphics")  # plotting data
    g_graphics.add_nodes_from(g_in, retain=["x", "y", "device_type", "device_subtype", "pop", "asn"])

    build_phy(anm)
    autonetkit.update_http(anm)
    g_phy = anm["phy"]

    build_vrf(anm)  # need to do before to add loopbacks before ip allocations
    build_ip(anm)  # ip infrastructure topology
    autonetkit.update_http(anm)

    address_family = g_in.data.address_family or "v4"  # default is v4
    # TODO: can remove the infrastructure now create g_ip seperately
    if address_family in ("v4", "dual_stack"):
        build_ipv4(anm, infrastructure=True)
        g_phy.update(g_phy, use_ipv4=True)
    else:
        build_ipv4(anm, infrastructure=False)

    # TODO: Create a collision domain overlay for ip addressing - l2 overlay?
    if address_family in ("v6", "dual_stack"):
        build_ipv6(anm)
        g_phy.update(g_phy, use_ipv6=True)

    default_igp = g_in.data.igp or "ospf"
    non_igp_nodes = [n for n in g_in if not n.igp]
    # TODO: should this be modifying g_in?
    g_in.update(non_igp_nodes, igp=default_igp)  # store igp onto each node

    anm.add_overlay("ospf")
    anm.add_overlay("isis")

    ank_utils.copy_attr_from(g_in, g_phy, "include_csr")

    build_ospf(anm)
    build_isis(anm)
    build_bgp(anm)
    autonetkit.update_http(anm)

    return anm
Example #24
0
def test():

    anm = autonetkit.NetworkModel()
    g_phy = anm['phy']
    g_phy.add_nodes_from(["r1", "r2", "r3", "r4", "r5"])
    for node in g_phy:
        node.device_type = "router"

    g_phy.node("r1").x = 100
    g_phy.node("r1").y = 100
    g_phy.node("r2").x = 250
    g_phy.node("r2").y = 250
    g_phy.node("r3").x = 100
    g_phy.node("r3").y = 300
    g_phy.node("r4").x = 600
    g_phy.node("r4").y = 600
    g_phy.node("r5").x = 600
    g_phy.node("r5").y = 300

    g_phy.add_edges_from(([("r1", "r2")]))
    g_phy.add_edges_from(([("r1", "r3")]))
    #g_phy.add_edges_from(([("r2", "r3")]))
    #g_phy.add_edges_from(([("r2", "r4")]))
    #g_phy.add_edges_from(([("r4", "r3")]))
    #g_phy.add_edges_from(([("r4", "r5")]))

    g_simple = anm.add_overlay("simple")
    g_simple.add_nodes_from(g_phy)
    g_simple.add_edges_from(([("r1", "r2")]))
    g_simple.add_edges_from(([("r4", "r3")]))

    g_me = anm.add_overlay("multi", multi_edge=True)
    graph = g_me._graph

    g_me.add_nodes_from(g_phy)

    # add two edges
    g_me.add_edges_from(([("r1", "r2")]))
    g_me.add_edges_from(([("r1", "r2")]))
    g_me.add_edges_from(([("r1", "r2")]))
    g_me.add_edges_from(([("r1", "r2")]))
    g_me.add_edges_from(([("r1", "r2")]))
    g_me.add_edges_from(([("r1", "r3")]))
    g_me.add_edges_from(([("r2", "r3")]))
    g_me.add_edges_from(([("r2", "r3")]))

    r1 = g_me.node("r1")

    for index, edge in enumerate(g_me.edges()):
        #print index, edge
        edge.index = "i_%s" % index

    for edge in r1.edges():
        #print edge, edge.index
        pass
    """
    e1 = r1.edges()[0]
    e1a = g_me.edge(e1)
    assert(e1 == e1a)
    e2 = r1.edges()[1]
    assert(e1 != e2)
    #TODO: check why neq != also returns true for e1 != e1a
    """

    #print g_me.edge("r1", "r2", 0).index
    #print g_me.edge("r1", "r2", 1).index

    print "edges"
    for edge in g_me.edges():
        print edge

    out_of_order = [g_me.edge("r1", "r2", x) for x in [4, 1, 3, 2, 0]]
    #print [e.index for e in out_of_order]
    in_order = sorted(out_of_order)
    #print in_order
    #print [e.index for e in in_order]

    # test adding to another mutli edge graph
    print "adding"
    g_me2 = anm.add_overlay("multi2", multi_edge=True)
    g_me2.add_nodes_from(g_me)
    print "add", len(g_me.edges())
    g_me2.add_edges_from(g_me.edges(), retain="index")
    for edge in g_me2.edges():
        print edge, edge.index

    # examine underlying nx structure

    #print graph
    #print type(graph)

    for u, v, k in graph.edges(keys=True):
        pass
        #print u, v, k
        #print graph[u][v][k].items()
        #graph[u][v][k]['test'] = 123

    g_dir = anm.add_overlay("dir", directed=True)
    g_dir.add_nodes_from(g_phy)
    g_dir.add_edges_from(([("r1", "r2")]))
    g_dir.add_edges_from(([("r2", "r1")]))
    g_dir.add_edges_from(([("r1", "r3")]))

    g_dir_multi = anm.add_overlay("dir_multi", directed=True, multi_edge=True)
    g_dir_multi.add_nodes_from(g_phy)
    g_dir_multi.add_edges_from(([("r1", "r2")]))
    g_dir_multi.add_edges_from(([("r1", "r2")]))
    g_dir_multi.add_edges_from(([("r1", "r2")]))
    g_dir_multi.add_edges_from(([("r1", "r2")]))
    g_dir_multi.add_edges_from(([("r2", "r1")]))
    g_dir_multi.add_edges_from(([("r2", "r1")]))
    g_dir_multi.add_edges_from(([("r2", "r1")]))
    g_dir_multi.add_edges_from(([("r2", "r1")]))
    g_dir_multi.add_edges_from(([("r2", "r1")]))
    g_dir_multi.add_edges_from(([("r1", "r3")]))

    for index, edge in enumerate(g_dir_multi.edges()):
        #print index, edge
        edge.index = "i_%s" % index

    from networkx.readwrite import json_graph
    import json
    data = json_graph.node_link_data(graph)
    with open("multi.json", "w") as fh:
        fh.write(json.dumps(data, indent=2))

    autonetkit.update_http(anm)
Example #25
0
def manage_network(input_graph_string,
                   timestamp,
                   build_options,
                   reload_build=False,
                   grid=None):
    """Build, compile, render network as appropriate"""
    # import build_network_simple as build_network
    import autonetkit.build_network as build_network
    if reload_build:
        # remap?
        build_network = reload(build_network)

    if build_options['build']:
        if input_graph_string:
            graph = build_network.load(input_graph_string)
        elif grid:
            graph = build_network.grid_2d(grid)

        anm = build_network.build(graph)
        if not build_options['compile']:
            update_http(anm)

        if build_options['validate']:
            import ank_validate
            ank_validate.validate(anm)

    if build_options['compile']:
        if build_options['archive']:
            anm.save()
        nidb = compile_network(anm)

        update_http(anm, nidb)
        log.debug("Sent ANM to web server")
        if build_options['archive']:
            nidb.save()
        # render.remove_dirs(["rendered"])
        if build_options['render']:
            render.render(nidb)

    if not (build_options['build'] or build_options['compile']):
        # Load from last run
        import autonetkit.anm
        anm = autonetkit.anm.AbstractNetworkModel()
        anm.restore_latest()
        nidb = NIDB()
        nidb.restore_latest()
        update_http(anm, nidb)

    if build_options['diff']:
        import autonetkit.diff
        nidb_diff = autonetkit.diff.nidb_diff()
        import json
        data = json.dumps(nidb_diff, cls=ank_json.AnkEncoder, indent=4)
        log.info("Wrote diff to diff.json")
        with open("diff.json",
                  "w") as fh:  # TODO: make file specified in config
            fh.write(data)

    # Note: this clobbers command line options
    # build_options.update(settings['General']) # update in case build has updated, eg for deploy
    # build_options.update(settings['General']) # update in case build has
    # updated, eg for deploy

    if build_options['deploy']:
        deploy_network(anm, nidb, input_graph_string)

    if build_options['measure']:
        measure_network(anm, nidb)

    log.info("Finished")
Example #26
0
import autonetkit.ank_messaging as ank_messaging
import autonetkit
import json
import random

import pkg_resources
parse_template = pkg_resources.resource_filename("autonetkit", "textfsm/quagga/sh_ip_route")

anm = autonetkit.ANM()
anm.restore_latest()

nidb = autonetkit.DeviceModel()
nidb.restore_latest()
print list(nidb.nodes())

autonetkit.update_http(anm, nidb)

emulation_server = "115.146.93.18"
command_list = []

import autonetkit.collection.process as ank_process
reverse_mappings = ank_process.build_reverse_mappings_from_nidb(nidb)

print reverse_mappings

command = "show ip route"

node = nidb.node("5")
#node = random.choice(list(nidb.routers()))
while True:
#for node in nidb.routers():
Example #27
0
def build(input_graph):
    """Main function to build network overlay topologies"""
    anm = autonetkit.anm.AbstractNetworkModel()

    input_undirected = nx.Graph(input_graph)
    g_in = anm.add_overlay("input", graph=input_undirected)
    anm.add_overlay("input_directed", graph=input_graph, directed=True)

# set defaults
    if not g_in.data.specified_int_names:
        # if not specified then automatically assign interface names
        g_in.data.specified_int_names = False

    import autonetkit.plugins.graph_product as graph_product
    graph_product.expand(g_in)  # apply graph products if relevant

    expand_fqdn = False
    # TODO: make this set from config and also in the input file
    if expand_fqdn and len(ank_utils.unique_attr(g_in, "asn")) > 1:
        # Multiple ASNs set, use label format device.asn
        anm.set_node_label(".", ['label', 'pop', 'asn'])

    g_in.update(
        g_in.nodes("is_router", platform="junosphere"), syntax="junos")
    g_in.update(g_in.nodes("is_router", platform="dynagen"), syntax="ios")
    g_in.update(g_in.nodes("is_router", platform="netkit"), syntax="quagga")

    g_graphics = anm.add_overlay("graphics")  # plotting data
    g_graphics.add_nodes_from(g_in, retain=['x', 'y', 'device_type',
                              'device_subtype', 'pop', 'asn'])

    build_phy(anm)
    autonetkit.update_http(anm)
    g_phy = anm['phy']

    build_vrf(anm)

    address_family = g_in.data.address_family or "v4"
    allocate_ipv4_infrastructure = False
    if address_family in ("v4", "dual_stack"):
        allocate_ipv4_infrastructure = True
    build_ipv4(anm, infrastructure=allocate_ipv4_infrastructure)

    #TODO: Create a collision domain overlay for ip addressing - l2 overlay?
    allocate_ipv6 = False
    if address_family in ("v6", "dual_stack"):
        allocate_ipv6 = True
        build_ipv4(anm, infrastructure=True)

    build_ip6(anm)
    for node in g_phy:
        node.use_ipv4 = allocate_ipv4_infrastructure
        node.use_ipv6 = allocate_ipv6

    default_igp = g_in.data.igp or "ospf" 
    non_igp_nodes = [n for n in g_in if not node.igp]
    g_in.update(non_igp_nodes, igp=default_igp)

    anm.add_overlay("ospf")
    anm.add_overlay("isis")

    ank_utils.copy_attr_from(g_in, g_phy, "include_csr")

    build_ospf(anm)
    build_isis(anm)
    build_bgp(anm)
    autonetkit.update_http(anm)

    return anm