def build_anm(topology_name):
print "Building anm for %s" % topology_name
dirname, filename = os.path.split(os.path.abspath(__file__))
input_filename = os.path.join(dirname, "%s.graphml" % topology_name)
anm = autonetkit.NetworkModel()
input_graph = graphml.load_graphml(input_filename)
import autonetkit.build_network as build_network
anm = build_network.initialise(input_graph)
anm = build_network.apply_design_rules(anm)
return anm
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__))
anm = autonetkit.NetworkModel()
input_file = os.path.join(dirname, "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)
anm.save()
anm_restored = autonetkit.NetworkModel()
anm_restored.restore_latest()
g_phy_original = anm['phy']
g_phy_restored = anm_restored['phy']
assert(all(n in g_phy_restored for n in g_phy_original))
#TODO: do more extensive deep check of parameters
import autonetkit.workflow as workflow
render_hostname = "localhost"
nidb = workflow.create_nidb(anm)
import autonetkit.compilers.platform.netkit as pl_netkit
nk_compiler = pl_netkit.NetkitCompiler(nidb, anm, render_hostname)
nk_compiler.compile()
nidb.save()
nidb_restored = autonetkit.DeviceModel()
nidb_restored.restore_latest()
assert(all(n in nidb_restored for n in nidb))
# cleanup
shutil.rmtree("versions")
def four_chain():
"""Returns anm with input and physical as house graph"""
import autonetkit
anm = autonetkit.NetworkModel()
g_in = anm.add_overlay("input")
router_ids = ["r1", "r2", "r3", "r4"]
g_in.add_nodes_from(router_ids)
g_in.update(device_type="router")
g_in.update(asn=1)
positions = {
'r1': (101, 250),
'r2': (100, 500),
'r3': (100, 750),
'r4': (100, 1000)
}
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")]
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())
return anm
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)
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)
import autonetkit
import autonetkit.log as log
anm = autonetkit.NetworkModel()
g_phy = anm.add_overlay("phy")
for index in range(5):
node_id = "r_%s" % index
g_phy.add_node(node_id)
print g_phy.nodes()
for node in g_phy:
print node
print node._ports
for interface in range(3):
node.add_interface()
sw = g_phy.add_node("sw1")
sw.device_type = "switch"
for node in g_phy:
for iface in node:
g_phy.add_edge(sw, iface)
print sw.edges()
for edge in g_phy.edges():
print edge._ports
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()