def test_p_median(self):
"""
Test topology:
A ---- B ---- C ----[HIGH DIST] --- D --- E --- F
Expected facilities: 1, 4
"""
t = fnss.Topology()
nx.add_path(t, "ABCDEF")
fnss.set_weights_constant(t, 1)
fnss.set_weights_constant(t, 2, [("C", "D")])
distances = dict(nx.all_pairs_dijkstra_path_length(t, weight='weight'))
allocation, facilities, cost = algorithms.compute_p_median(
distances, 2)
self.assertDictEqual(
{
"A": "B",
"B": "B",
"C": "B",
"D": "E",
"E": "E",
"F": "E",
}, allocation)
self.assertSetEqual(set("BE"), facilities)
self.assertEqual(4, cost)
def setUp(self):
#
# -- s1 --
# / | \
# c1-----c2----c3
# / \ / | \ \
# r1 r2 r3 r4 r5 r6
#
topo = fnss.Topology()
icr_candidates = ["c1", "c2", "c3"]
topo.add_path(icr_candidates)
topo.add_edge("c1", "s1")
topo.add_edge("c2", "s1")
topo.add_edge("c3", "s1")
topo.add_edge("c1", "r1")
topo.add_edge("c1", "r2")
topo.add_edge("c2", "r3")
topo.add_edge("c2", "r4")
topo.add_edge("c2", "r5")
topo.add_edge("c3", "r6")
topo.graph['icr_candidates'] = set(icr_candidates)
for router in icr_candidates:
fnss.add_stack(topo, router, 'router')
for src in ['s1']:
fnss.add_stack(topo, src, 'source')
for rcv in ['r1', 'r2', 'r3', 'r4', 'r5', 'r6']:
fnss.add_stack(topo, rcv, 'receiver')
self.topo = cacheplacement.IcnTopology(topo)
def test_to_mininet(self):
t = fnss.Topology()
t.add_path([1, 2, 3, 4])
for n in (1, 4):
t.node[n]['type'] = 'host'
for n in (2, 3):
t.node[n]['type'] = 'switch'
fnss.set_capacities_constant(t, 10, 'Mbps')
fnss.set_delays_constant(t, 10, 'ms')
mn_topo = fnss.to_mininet(t, relabel_nodes=False)
self.assertIsNotNone(mn_topo)
hosts = mn_topo.hosts()
switches = mn_topo.switches()
for h in '1', '4':
self.assertIn(h, hosts)
for s in '2', '3':
self.assertIn(s, switches)
mn_topo = fnss.to_mininet(t, relabel_nodes=True)
# Relabeling should be:
# 1 -> h1
# 2 -> s1
# 3 -> s2
# 4 -> h2
self.assertIsNotNone(mn_topo)
hosts = mn_topo.hosts()
switches = mn_topo.switches()
for h in 'h1', 'h2':
self.assertIn(h, hosts)
for s in 's1', 's2':
self.assertIn(s, switches)
def test_to_omnetpp_undirected(self):
t = fnss.Topology()
t.add_path([1, 2, 3, 4])
fnss.set_capacities_constant(t, 10, 'Gbps')
fnss.set_delays_constant(t, 2, 'us')
fnss.set_buffer_sizes_constant(t, 20, 'packets')
fnss.to_omnetpp(t, path.join(TMP_DIR, 'omnetpp-undir.ned'))
def setup_method(self):
#
# s1 s2
# | |
# c1-----c2----c3
# / \ / | \ \
# r1 r2 r3 r4 r5 r6
#
topo = fnss.Topology()
icr_candidates = ["c1", "c2", "c3"]
nx.add_path(topo, icr_candidates)
topo.add_edge("c2", "s1")
topo.add_edge("c2", "s2")
topo.add_edge("c1", "r1")
topo.add_edge("c1", "r2")
topo.add_edge("c2", "r3")
topo.add_edge("c2", "r4")
topo.add_edge("c2", "r5")
topo.add_edge("c3", "r6")
topo.graph["icr_candidates"] = set(icr_candidates)
for router in icr_candidates:
fnss.add_stack(topo, router, "router")
for src in ["s1"]:
fnss.add_stack(topo, src, "source")
for rcv in ["r1", "r2", "r3", "r4", "r5", "r6"]:
fnss.add_stack(topo, rcv, "receiver")
self.topo = cacheplacement.IcnTopology(topo)
def nrr_topology(cls):
"""Return topology for testing NRR caching strategies
"""
# Topology sketch
#
# 0 ---- 2----- 4
# | \
# | s
# | /
# 1 ---- 3 ---- 5
#
topology = IcnTopology(fnss.Topology())
nx.add_path(topology, [0, 2, 4, "s", 5, 3, 1])
topology.add_edge(2, 3)
receivers = (0, 1)
source = "s"
caches = (2, 3, 4, 5)
contents = (1, 2, 3, 4)
fnss.add_stack(topology, source, 'source', {'contents': contents})
for v in caches:
fnss.add_stack(topology, v, 'router', {'cache_size': 1})
for v in receivers:
fnss.add_stack(topology, v, 'receiver', {})
fnss.set_delays_constant(topology, 1, 'ms')
return topology
def partition_topology(cls):
#
# +-- s1 --+
# / | \
# c1-----[]----c2
# / \
# r1 r2
#
topo = fnss.Topology()
icr_candidates = ["c1", "router", "c2"]
nx.add_path(topo, icr_candidates)
topo.add_edge("r1", "router")
topo.add_edge("r2", "router")
topo.add_edge("c1", "s1")
topo.add_edge("c2", "s1")
topo.graph['icr_candidates'] = set(icr_candidates)
contents = (1, 2, 3, 4)
for router in icr_candidates:
if router in ("c1", "c2"):
props = {'cache_size': 1}
fnss.add_stack(topo, router, 'router', **props)
for src in ['s1']:
fnss.add_stack(topo, src, 'source', {'contents': contents})
for rcv in ['r1', 'r2']:
fnss.add_stack(topo, rcv, 'receiver')
topo.graph['cache_assignment'] = {"r1": "c1", "r2": "c2"}
return IcnTopology(topo)
def parse_ashiip(path):
"""
Parse a topology from an output file generated by the aShiip topology
generator
Parameters
----------
path : str
The path to the aShiip output file
Returns
-------
topology : Topology
"""
topology = fnss.Topology(type='ashiip')
for line in open(path, "r").readlines():
# There is no documented aShiip format but we assume that if the line
# does not start with a number it is not part of the topology
if line[0].isdigit():
node_ids = re.findall("\d+", line)
if len(node_ids) < 2:
raise ValueError('Invalid input file. Parsing failed while ' \
'trying to parse a line')
node = int(node_ids[0])
# level = int(node_ids[1])
topology.add_node(node)
for i in range(1, len(node_ids)):
topology.add_edge(node, int(node_ids[i]))
paths = dict(nx.all_pairs_dijkstra_path(topology))
for u in paths:
for v in paths[u]:
paths[u][v] = len(paths[u][v])
return paths
def test_to_ns2_undirected(self):
t = fnss.Topology()
t.add_path([1, 2, 3, 4])
fnss.set_capacities_constant(t, 10, 'Gbps')
fnss.set_delays_constant(t, 2, 'us')
fnss.set_buffer_sizes_constant(t, 20, 'packets')
fnss.to_ns2(t, path.join(TMP_DIR, 'ns2-undir.tcl'), stacks=False)
def test_p_median_unsorted(self):
"""
Test topology:
A ---- C ---- B ----[HIGH DIST] --- E --- D --- F
Expected facilities: 1, 4
"""
t = fnss.Topology()
nx.add_path(t, "ACBEDF")
fnss.set_weights_constant(t, 1)
fnss.set_weights_constant(t, 2, [("B", "E")])
distances = dict(nx.all_pairs_dijkstra_path_length(t, weight='weight'))
allocation, facilities, cost = algorithms.compute_p_median(
distances, 2)
assert {
"A": "C",
"B": "C",
"C": "C",
"D": "D",
"E": "D",
"F": "D",
} == allocation
assert set("CD") == facilities
assert 4 == cost
def test_symmetric_paths(self):
topology = fnss.Topology()
topology.add_path([1, 2, 4, 5, 3, 6, 1])
path = nx.all_pairs_shortest_path(topology)
self.assertNotEqual(list(path[1][5]), list(reversed(path[5][1])))
network.symmetrify_paths(path)
self.assertEqual(list(path[1][5]), list(reversed(path[5][1])))
def topology_ds2os(**kwargs):
# pass edge list to create topology (alternatively pass NetworkX object)
agents = ['agent' + str(id)
for id in range(1, 7)] # [agent1, agent2, ..., agent6]
edges = [
# main edges between KAs/rooms
('agent1', 'agent2'), # BedroomChildren, BedroomParents
('agent2', 'agent6'), # BedroomParents, Bathroom
('agent2', 'agent4'), # BedroomParents, Kitchen
# ('agent3', 'agent6'), # Dinningroom, Bathroom
('agent4', 'agent5'), # Kitchen, Garage
('agent4', 'agent3'), # Kitchen, Dinningroom
]
rooms = [
['movement1', 'questioningservice1', 'tempin1',
'lightcontrol1'], # ka1, BedroomChildren
['movement2', 'questioningservice2', 'tempin2',
'lightcontrol2'], # ka2, BedroomParents
[
'heatingcontrol1', 'doorlock1', 'questioningservice3', 'movement3',
'tempin3', 'lightcontrol3'
], # ka3, Dinningroom
['tempin4', 'lightcontrol4', 'movement4', 'battery3'], # ka4, Kitchen
['tempin5', 'battery1', 'movement5', 'lightcontrol5',
'battery2'], # ka5, Garage
['tempin6', 'washingmachine1', 'lightcontrol6',
'movement6'], # ka6, Bathroom
]
for i, agent in enumerate(agents):
connectedServices = rooms[i]
# print(agent, 'is connected to', connectedServices)
for service in connectedServices:
edges.append((agent, service)) # e.g. ('agent1', 'movement1')
if not service.startswith('questioningservice'
): # questioningservices only read data
edges.append(
(service, service +
'/source')) # e.g. ('movement1', 'movement1/source')
edges.append(
(service, service +
'/receiver')) # e.g. ('movement1', 'movement1/receiver')
topology = fnss.Topology(data=edges)
for node in topology.nodes():
stack = 'source' if node.endswith('source') else (
'receiver' if node.endswith('receiver') else 'router')
fnss.add_stack(topology, node, stack)
topology.graph['icr_candidates'] = set(agents) # only cache at agents
fnss.set_weights_constant(topology, 1.0)
fnss.set_delays_constant(topology, INTERNAL_LINK_DELAY, 'ms')
return IcnTopology(topology)
def test_topology_class(self):
topology = fnss.Topology()
topology.add_edge(1, 2)
self.assertEqual(1, topology.number_of_edges())
topology.add_edge(2, 1)
self.assertEqual(1, topology.number_of_edges())
topology.add_edge('1', '2')
topology.add_edge('2', '1')
self.assertEqual(2, topology.number_of_edges())
def test_delays_geo_distance_conversions(self):
topology = fnss.Topology(distance_unit='m')
topology.add_edge(1, 2, length=2000)
specific_delay = 1.2
fnss.set_delays_geo_distance(topology, specific_delay, None, 'us')
self.assertAlmostEqual(topology.edge[1][2]['delay'], 2400)
fnss.clear_delays(topology)
fnss.set_delays_geo_distance(topology, specific_delay, None, 's')
self.assertAlmostEqual(topology.edge[1][2]['delay'], 0.0024)
def test_buffer_sizes_bw_delay_prod_unused_links(self):
topo = fnss.Topology()
topo.add_edge(1, 2, weight=100)
topo.add_edge(2, 3, weight=1)
topo.add_edge(3, 1, weight=1)
fnss.set_capacities_constant(topo, 10)
fnss.set_delays_constant(topo, 2)
fnss.set_buffer_sizes_bw_delay_prod(topo)
self.assertTrue(all((topo.adj[u][v]['buffer'] is not None
for (u, v) in topo.edges())))
def test_to_from(self):
f = path.join(TMP_DIR, 'jfed-tofrom.rspec')
t_in = fnss.Topology()
t_in.add_path([1, 2, 3, 4])
fnss.to_jfed(t_in, f)
t_out = fnss.from_jfed(f)
self.assertEqual(t_in.number_of_nodes(), t_out.number_of_nodes())
self.assertEqual(t_in.number_of_edges(), t_out.number_of_edges())
self.assertEqual(set(t_in.degree().values()),
set(t_out.degree().values()))
def test_delays_geo_distance_conversions_defaults(self):
topology = fnss.Topology(distance_unit='m')
topology.add_edge(1, 2, length=2000)
topology.add_edge(2, 3, length=3000)
topology.add_edge(3, 4)
specific_delay = 1.2
fnss.set_delays_geo_distance(topology, specific_delay, 3, 's', None)
self.assertEquals(topology.graph['distance_unit'], 'm')
self.assertEquals(topology.graph['delay_unit'], 's')
self.assertAlmostEqual(topology.edge[1][2]['delay'], 0.0024)
self.assertAlmostEqual(topology.edge[2][3]['delay'], 0.0036)
self.assertAlmostEqual(topology.edge[3][4]['delay'], 3)
def test_p_median_3(self):
# Test topology:
#
# A ---- C ---- B ----[HIGH DIST] --- E --- D --- F
#
# Expected facilities: 1, 4
t = fnss.Topology()
nx.add_path(t, "ACBEDF")
fnss.set_weights_constant(t, 1)
fnss.set_weights_constant(t, 2, [("B", "E")])
distances = dict(nx.all_pairs_dijkstra_path_length(t, weight='weight'))
allocation, facilities, cost = algorithms.compute_p_median(
distances, 3)
assert cost == 3
def to_fnss_topology(self):
""" Creates a FNSS topology from object.
Returns:
topo (fnss.Topology): Representation of network in FNSS.
"""
topo = fnss.Topology()
topo.graph = self.todict()
for node in self.nodes.itervalues():
topo.add_node(node.label, node.todict())
for edge in self.edges.itervalues():
topo.add_edge(edge.node_one_id, edge.node_two_id, edge.todict())
return topo
def test_p_median_4(self):
"""
Test topology:
A ---- C ---- B ----[HIGH DIST] --- E --- D --- F
Expected facilities: 1, 4
"""
t = fnss.Topology()
t.add_path("ACBEDF")
fnss.set_weights_constant(t, 1)
fnss.set_weights_constant(t, 2, [("B", "E")])
distances = dict(nx.all_pairs_dijkstra_path_length(t, weight='weight'))
allocation, facilities, cost = algorithms.compute_p_median(distances, 4)
self.assertEqual(2, cost)
def test_delays_geo_distance_conversions_partial_assignments(self):
topology = fnss.Topology(distance_unit='m')
topology.add_edge(1, 2, length=2000)
topology.add_edge(2, 3, length=3000)
topology.add_edge(3, 4)
specific_delay=1.2
fnss.set_delays_geo_distance(topology, specific_delay,
None, 'us', links=[(1, 2)])
fnss.set_delays_geo_distance(topology, specific_delay,
3, 's', links=[(2, 3), (3, 4)])
self.assertEquals(topology.graph['distance_unit'], 'm')
self.assertEquals(topology.graph['delay_unit'], 'us')
self.assertAlmostEqual(topology.edge[1][2]['delay'], 2400)
self.assertAlmostEqual(topology.edge[2][3]['delay'], 3600)
self.assertAlmostEqual(topology.edge[3][4]['delay'], 3000000)
def test_p_median_6(self):
"""
Test topology:
A ---- C ---- B ----[HIGH DIST] --- E --- D --- F
Expected facilities: 1, 4
"""
t = fnss.Topology()
t.add_path("ACBEDF")
fnss.set_weights_constant(t, 1)
fnss.set_weights_constant(t, 2, [("B", "E")])
distances = nx.all_pairs_dijkstra_path_length(t, weight='weight')
allocation, facilities, cost = algorithms.compute_p_median(
distances, 6)
self.assertDictEqual({i: i for i in "ABCDEF"}, allocation)
self.assertSetEqual(set("ABCDEF"), facilities)
self.assertEqual(0, cost)
def test_p_median_6(self):
"""
Test topology:
A ---- C ---- B ----[HIGH DIST] --- E --- D --- F
Expected facilities: 1, 4
"""
t = fnss.Topology()
nx.add_path(t, "ACBEDF")
fnss.set_weights_constant(t, 1)
fnss.set_weights_constant(t, 2, [("B", "E")])
distances = dict(nx.all_pairs_dijkstra_path_length(t, weight='weight'))
allocation, facilities, cost = algorithms.compute_p_median(
distances, 6)
assert {i: i for i in "ABCDEF"} == allocation
assert set("ABCDEF") == facilities
assert 0 == cost
def test_base_topology_class(self):
weight = 2
capacity = 3
delay = 4
buffer_size = 5
topology = fnss.Topology()
topology.add_path([1, 2, 3])
fnss.set_weights_constant(topology, weight)
fnss.set_capacities_constant(topology, capacity)
fnss.set_delays_constant(topology, delay)
fnss.set_buffer_sizes_constant(topology, buffer_size)
weights = topology.weights()
capacities = topology.capacities()
delays = topology.delays()
buffer_sizes = topology.buffers()
for e in topology.edges():
self.assertEqual(weight, weights[e])
self.assertEqual(capacity, capacities[e])
self.assertEqual(delay, delays[e])
self.assertEqual(buffer_size, buffer_sizes[e])
def extract_cluster_level_topology(topology):
"""Build a cluster-level topology.
Each node in the topology must be have the 'cluster' attribute
Parameters
----------
topology : Topology
The router-level topology
Returns
-------
topology : Topology
The cluster-level topology
Notes
-----
* Each router must have a cache deployed
* All sources and receiver must have one single attachment point with a
cache
* Each node must be labelled with cluster
"""
cluster_map = nx.get_node_attributes(topology, 'cluster')
if len(cluster_map) < topology.number_of_nodes():
raise ValueError(
'There are nodes not labelled with cluster information')
if nx.number_connected_components(topology) > 1:
raise ValueError('There is more than one connected component')
cluster_topology = fnss.Topology()
cluster_set = set(cluster_map.values())
if len(cluster_set) == 1:
# There is only one huge cluster
cluster_topology.add_node(cluster_set.pop())
return cluster_topology
for u, v in topology.edges():
cluster_u = cluster_map[u]
cluster_v = cluster_map[v]
if cluster_u != cluster_v:
cluster_topology.add_edge(cluster_u, cluster_v)
return cluster_topology
def test_p_median(self):
# Test topology:
#
# A ---- B ---- C ----[HIGH DIST] --- D --- E --- F
#
# Expected facilities: 1, 4
t = fnss.Topology()
nx.add_path(t, "ABCDEF")
fnss.set_weights_constant(t, 1)
fnss.set_weights_constant(t, 2, [("C", "D")])
distances = dict(nx.all_pairs_dijkstra_path_length(t, weight='weight'))
allocation, facilities, cost = algorithms.compute_p_median(
distances, 2)
assert allocation == {
"A": "B",
"B": "B",
"C": "B",
"D": "E",
"E": "E",
"F": "E",
}
assert facilities == set("BE")
assert cost == 4
def nrr_topology():
"""Return topology for testing NRR caching strategies
"""
# Topology sketch
#
# 0 ---- 2----- 4
# | \
# | 6
# | /
# 1 ---- 3 ---- 5
#
topology = fnss.Topology()
topology.add_path([0, 2, 4, 6, 5, 3, 1])
topology.add_edge(2, 3)
receivers = (0, 1)
source = (6)
caches = (2, 3, 4, 5)
contents = (1, 2, 3, 4)
fnss.add_stack(topology, source, 'source', {'contents': contents})
for v in caches:
fnss.add_stack(topology, v, 'router', {'cache_size': 1})
for v in receivers:
fnss.add_stack(topology, v, 'receiver', {})
return topology
def test_multicast_tree(self):
topo = fnss.Topology()
nx.add_path(topo, [2, 1, 3, 4])
sp = dict(nx.all_pairs_shortest_path(topo))
tree = util.multicast_tree(sp, 1, [2, 3])
assert set(tree) == {(1, 2), (1, 3)}
def test_multicast_tree(self):
topo = fnss.Topology()
topo.add_path([2, 1, 3, 4])
sp = nx.all_pairs_shortest_path(topo)
tree = util.multicast_tree(sp, 1, [2, 3])
self.assertSetEqual(set(tree), set([(1, 2), (1, 3)]))
def test_to_jfed(self):
t = fnss.Topology()
t.add_path([1, 2, 3, 4])
fnss.to_jfed(t, path.join(TMP_DIR, 'jfed-to.rspec'))
pass
