def _get_communicated_pairs(simulation):
''' Return pairs that have recently communicated; also remove outdated entries '''
from config_parser.openflow_parser import get_uniq_port_id
interface_pair_map = InvariantChecker.interface_pair_map
pair_timeout = InvariantChecker.pair_timeout
communicated_pairs = set()
for (src_addr, dst_addr), timestamp in interface_pair_map.items():
if (time.time() - timestamp < pair_timeout):
interface2access_links = simulation.topology.link_tracker.interface2access_link
src_interface, dst_interface = None, None
for interface in interface2access_links.keys():
if interface.hw_addr == src_addr:
src_interface = interface
if interface.hw_addr == dst_addr:
dst_interface = interface
if src_interface is not None and dst_interface is not None:
l1 = interface2access_links[src_interface]
l2 = interface2access_links[dst_interface]
communicated_pair = (get_uniq_port_id(
l1.switch, l1.switch_port),
get_uniq_port_id(
l2.switch, l2.switch_port))
communicated_pairs.add(communicated_pair)
else:
del interface_pair_map[(src_addr, dst_addr)]
return communicated_pairs
def _get_all_pairs(simulation):
# TODO(cs): translate HSA port numbers to ofp_phy_ports in the
# headerspace/ module instead of computing uniq_port_id here
from config_parser.openflow_parser import get_uniq_port_id
access_links = simulation.topology.access_links
all_pairs = [ (get_uniq_port_id(l1.switch, l1.switch_port), get_uniq_port_id(l2.switch, l2.switch_port))
for l1 in access_links
for l2 in access_links if l1 != l2 ]
all_pairs = set(all_pairs)
return all_pairs
def _get_all_pairs(simulation):
# TODO(cs): translate HSA port numbers to ofp_phy_ports in the
# headerspace/ module instead of computing uniq_port_id here
from config_parser.openflow_parser import get_uniq_port_id
access_links = simulation.topology.access_links
all_pairs = [(get_uniq_port_id(l1.switch, l1.switch_port),
get_uniq_port_id(l2.switch, l2.switch_port))
for l1 in access_links for l2 in access_links if l1 != l2]
all_pairs = set(all_pairs)
return all_pairs
def _get_communicated_pairs(simulation):
''' Return pairs that have recently communicated; also remove outdated entries '''
from config_parser.openflow_parser import get_uniq_port_id
interface_pair_map = InvariantChecker.interface_pair_map
pair_timeout = InvariantChecker.pair_timeout
communicated_pairs = set()
for (src_addr, dst_addr), timestamp in interface_pair_map.items():
if (time.time() - timestamp < pair_timeout):
interface2access_links = simulation.topology.link_tracker.interface2access_link
src_interface, dst_interface = None, None
for interface in interface2access_links.keys():
if interface.hw_addr == src_addr:
src_interface = interface
if interface.hw_addr == dst_addr:
dst_interface = interface
if src_interface is not None and dst_interface is not None:
l1 = interface2access_links[src_interface]
l2 = interface2access_links[dst_interface]
communicated_pair = (get_uniq_port_id(l1.switch, l1.switch_port),
get_uniq_port_id(l2.switch, l2.switch_port))
communicated_pairs.add(communicated_pair)
else:
del interface_pair_map[(src_addr, dst_addr)]
return communicated_pairs
def check_partitions(switches, live_links, access_links):
# TODO(cs): lifted directly from pox.forwarding.l2_multi. Highly
# redundant!
from config_parser.openflow_parser import get_uniq_port_id
# Adjacency map. [sw1][sw2] -> port from sw1 to sw2
adjacency = defaultdict(lambda:defaultdict(lambda:None))
for link in live_links:
# Make sure to disregard links that are adjacent to down switches
# (technically those links are still `live', but it's easier to treat it
# this way)
if not (link.start_software_switch.failed or
link.end_software_switch.failed):
adjacency[link.start_software_switch][link.end_software_switch] = link
# Switches we know of. [dpid] -> Switch
switches = { sw.dpid : sw for sw in switches }
# [sw1][sw2] -> (distance, intermediate)
path_map = defaultdict(lambda:defaultdict(lambda:(None,None)))
def _calc_paths ():
"""
Essentially Floyd-Warshall algorithm
"""
sws = switches.values()
path_map.clear()
for k in sws:
for j,port in adjacency[k].iteritems():
if port is None: continue
path_map[k][j] = (1,None)
path_map[k][k] = (0,None) # distance, intermediate
"""
for i in sws:
for j in sws:
a = path_map[i][j][0]
#a = adjacency[i][j]
if a is None: a = "*"
print a,
print
"""
for k in sws:
for i in sws:
for j in sws:
if path_map[i][k][0] is not None:
if path_map[k][j][0] is not None:
# i -> k -> j exists
ikj_dist = path_map[i][k][0]+path_map[k][j][0]
if path_map[i][j][0] is None or ikj_dist < path_map[i][j][0]:
# i -> k -> j is better than existing
path_map[i][j] = (ikj_dist, k)
"""
print "--------------------"
for i in sws:
for j in sws:
print path_map[i][j][0],
print
"""
all_link_pairs = [ (l1,l2) for l1 in access_links
for l2 in access_links if l1 != l2 ]
_calc_paths()
partioned_pairs = set()
for link_pair in all_link_pairs:
if path_map[link_pair[0].switch][link_pair[1].switch] == (None,None):
id1 = get_uniq_port_id(link_pair[0].switch, link_pair[0].switch_port)
id2 = get_uniq_port_id(link_pair[1].switch, link_pair[1].switch_port)
partioned_pairs.add((id1,id2))
return partioned_pairs
def check_partitions(switches, live_links, access_links):
# TODO(cs): lifted directly from pox.forwarding.l2_multi. Highly
# redundant!
from config_parser.openflow_parser import get_uniq_port_id
# Adjacency map. [sw1][sw2] -> port from sw1 to sw2
adjacency = defaultdict(lambda: defaultdict(lambda: None))
for link in live_links:
# Make sure to disregard links that are adjacent to down switches
# (technically those links are still `live', but it's easier to treat it
# this way)
if not (link.start_software_switch.failed
or link.end_software_switch.failed):
adjacency[link.start_software_switch][
link.end_software_switch] = link
# Switches we know of. [dpid] -> Switch
switches = {sw.dpid: sw for sw in switches}
# [sw1][sw2] -> (distance, intermediate)
path_map = defaultdict(lambda: defaultdict(lambda: (None, None)))
def _calc_paths():
"""
Essentially Floyd-Warshall algorithm
"""
sws = switches.values()
path_map.clear()
for k in sws:
for j, port in adjacency[k].iteritems():
if port is None: continue
path_map[k][j] = (1, None)
path_map[k][k] = (0, None) # distance, intermediate
"""
for i in sws:
for j in sws:
a = path_map[i][j][0]
#a = adjacency[i][j]
if a is None: a = "*"
print a,
print
"""
for k in sws:
for i in sws:
for j in sws:
if path_map[i][k][0] is not None:
if path_map[k][j][0] is not None:
# i -> k -> j exists
ikj_dist = path_map[i][k][0] + path_map[k][j][0]
if path_map[i][j][
0] is None or ikj_dist < path_map[i][j][0]:
# i -> k -> j is better than existing
path_map[i][j] = (ikj_dist, k)
"""
print "--------------------"
for i in sws:
for j in sws:
print path_map[i][j][0],
print
"""
all_link_pairs = [(l1, l2) for l1 in access_links for l2 in access_links
if l1 != l2]
_calc_paths()
partioned_pairs = set()
for link_pair in all_link_pairs:
if path_map[link_pair[0].switch][link_pair[1].switch] == (None, None):
id1 = get_uniq_port_id(link_pair[0].switch,
link_pair[0].switch_port)
id2 = get_uniq_port_id(link_pair[1].switch,
link_pair[1].switch_port)
partioned_pairs.add((id1, id2))
return partioned_pairs
