def query_link(self, switch1=None, port1=None, switch2=None, host=None):
if switch1:
found = None
if switch2:
def ss_match(port):
return port.src.dpid == switch1.dpid and port.dst.dpid == switch2.dpid
found = list(filter(ss_match, get_all_link(self.app)))
elif port1:
def sp_match(port):
return port.src.dpid == switch1.dpid and port.src.port_no == port1
found = list(filter(sp_match, get_all_link(self.app)))
elif host:
if host.mac:
r = host_mgr.query_host(mac=host.mac)
elif host.ipv4:
r = host_mgr.query_host(ipv4=host.ipv4)
elif host.ipv6:
r = host_mgr.query_host(ipv6=host.ipv6)
else:
return None, None, None, None
if r:
found_dpid, found_port = r
else:
return None, None, None, None
return found_dpid, found_port, None, None
if found:
return switch1.dpid, found[0].src.port_no, found[0].dst.dpid, found[0].dst.port_no
return None, None, None, None
def get_topology_delay(self):
hub.sleep(2)
switch_list = get_all_switch(self)
switches = [switch.dp.id for switch in switch_list]
self.graph.add_nodes_from(switches)
# get edges
link_list = get_all_link(self)
for link in link_list:
try:
lldp_delay1 = self.lldp_delay[(link.src.dpid, link.dst.dpid)]
lldp_delay2 = self.lldp_delay[(link.dst.dpid, link.src.dpid)]
echo_delay1 = self.echo_delay[link.src.dpid]
echo_delay2 = self.echo_delay[link.dst.dpid]
delay = (lldp_delay1 + lldp_delay2 - echo_delay1 -
echo_delay2) / 2
w = max(delay, 0)
except:
w = float('inf')
self.logger.info('lldp_delay: %s %s echo_delay: %s %s',
lldp_delay1, lldp_delay2, echo_delay1,
echo_delay2)
self.logger.info('delay between %s and %s = %s ms', link.src.dpid,
link.dst.dpid, delay * 1000)
self.graph.add_edge(link.src.dpid,
link.dst.dpid,
weight=w,
port=link.src.port_no)
self.graph.add_edge(link.dst.dpid,
link.src.dpid,
weight=w,
port=link.dst.port_no)
def obtain_topology(self, ev):
self.switches = get_all_switch(self.app)
self.links = get_all_link(self.app)
self.hosts = get_all_host(self.app)
# handle switches
for switch in self.switches:
#print "[INFO]", switch
dpid = switch.dp.id
self.switch_dict[dpid] = switch.dp
self.switch_dp2ports_table.setdefault(dpid, set())
for port in switch.ports:
self.switch_dp2ports_table[dpid].add(port)
# handle links
for link in self.links:
#print "[INFO]", link
src_port = link.src
dst_port = link.dst
self.link_dp2port_table[(src_port.dpid,
dst_port.dpid)] = (src_port, dst_port)
# handle hosts
for host in self.hosts:
#print "[INFO]", host
host_ip = host.ipv4
host_mac = host.mac
host_port = host.port
if len(host_ip) == 0:
pass
else:
self.host_ip2mac_table[host_ip[0]] = host_mac
self.host_ip2port_table[host_ip[0]] = host_port
self.process_topo_graph_and_paths()
def _packet_out_to(self, msg, dst_dpid, dst_out_port):
dp = msg.datapath
src_dpid = dp.id
# same dp
if src_dpid == dst_dpid:
self._packet_out(msg, dst_out_port)
else:
g = nx.Graph()
links = api.get_all_link(self)
for link in links:
src = link.src.dpid
dst = link.dst.dpid
g.add_edge(src, dst)
src = src_dpid
dst = dst_dpid
path = None
if nx.has_path(g, src, dst):
path = nx.shortest_path(g, src, dst)
if path == None:
return
out_port = self._get_out_port(path[0], path[1])
self._packet_out(msg, out_port)
def _packet_out_to(self, msg, dst_dpid, dst_out_port):
dp = msg.datapath
src_dpid = dp.id
# same dp
if src_dpid == dst_dpid:
self._packet_out(msg, dst_out_port)
else:
g = nx.Graph()
links = api.get_all_link(self)
for link in links:
src = link.src.dpid
dst = link.dst.dpid
g.add_edge(src, dst)
src = src_dpid
dst = dst_dpid
path = None
if nx.has_path(g, src, dst):
path = nx.shortest_path(g, src, dst)
if path == None:
return
out_port = self._get_out_port(path[0], path[1])
self._packet_out(msg, out_port)
def process_switch_enter(self, ev):
print "--switch enter--"
link_list = get_all_link(self.topology_api_app)
links = list()
for link in link_list:
links.append((link.src.dpid, link.dst.dpid, {
'port': link.src.port_no,
link.src.dpid: link.src.port_no,
link.dst.dpid: link.dst.port_no
}))
links.append((link.dst.dpid, link.src.dpid, {
'port': link.dst.port_no,
link.src.dpid: link.src.port_no,
link.dst.dpid: link.dst.port_no
}))
print "links %s %s: " % (link.src.dpid,
link.dst.dpid), link.src.port_no
self.network.add_node(link.src.dpid, connected=dict())
self.network.add_node(link.dst.dpid, connected=dict())
# print self.network.nodes
self.network.node[link.src.dpid]['connected'][
link.src.port_no] = link.dst.dpid
self.network.node[link.dst.dpid]['connected'][
link.dst.port_no] = link.src.dpid
print "links: ", links
self.network.add_edges_from(links)
def port_status_handler(self,ev):
"""Handler used to handle port status
Displays the topology and port information in case of Port modfictation event
"""
msg=ev.msg
reason=msg.reason
dp=msg.datapath
ofpport = msg.desc
port_no = msg.desc.port_no
ofproto = dp.ofproto
if reason == ofproto.OFPPR_ADD:
self.logger.info("port added %s", port_no)
pass
elif reason == ofproto.OFPPR_DELETE:
self.logger.info("port deleted %s", port_no)
pass
elif reason == ofproto.OFPPR_MODIFY:
self.logger.info("port modified %s", port_no)
else:
self.logger.info("Illeagal port state %s %s", port_no, reason)
pass
sw_list = api.get_all_switch(self)
sw_list_body =json.dumps([ switch.to_dict() for switch in sw_list])
print('sw_list_body {}'.format(sw_list_body))
link_list = api.get_all_link(self)
link_list_body = json.dumps([ link.to_dict() for link in link_list ])
print('link_list_body {}'.format(link_list_body))
def new_link_handler(self, ev):
pr,start = self.enableProf()
links = api.get_all_link(self)
switches = api.get_all_switch(self)
self.next_array = self.FloydWarshall(switches, links)
self.disableProf(pr,start,"FW")
def promptFW(self):
pr, start = self.enableProf()
links = api.get_all_link(self)
switches = api.get_all_switch(self)
self.next_array = self.FloydWarshall(switches, links)
self.disableProf(pr, start, "FW")
def get_switch_port_to_switch_mapping(self):
for link in get_all_link(self):
if link.src.port_no != 4294967294:
# print 'link.src.dpid = ' + str(link.src.dpid) + ',link.src.port = ' + str(link.src.port_no) + 'link.dst.dpid = ' + str(link.dst.dpid)
self.switch_port_to_switch[link.src.dpid][
link.src.port_no] = link.dst.dpid
self.switch_port_to_switch[link.dst.dpid][
link.dst.port_no] = link.src.dpid
def is_edge_port(self, dpid, port_no):
links = ryu_api.get_all_link(self)
for link in links:
if link.src.dpid == dpid and link.src.port_no == port_no:
return False
return True
def is_edge_port(self, dpid, port_no):
links = ryu_api.get_all_link(self)
for link in links:
if link.src.dpid == dpid and link.src.port_no == port_no:
return False
return True
def get_topology_data(self):
# Call get_switch() to get the list of objects Switch.
self.topo_shape.topo_raw_switches = copy.copy(get_all_switch(self))
# Call get_link() to get the list of objects Link.
self.topo_shape.topo_raw_links = copy.copy(get_all_link(self))
self.topo_shape.print_links("get_topology_data")
self.topo_shape.print_switches("get_topology_data")
def update_topology(self, app):
self._topo_raw_switches = get_all_switch(app)
self._topo_raw_links = get_all_link(app)
switch_dpids = [switch.dp.id for switch in self._topo_raw_switches]
links = [(link.src.dpid,link.dst.dpid) for link in self._topo_raw_links]
self.topology.add_nodes_from(switch_dpids)
self.topology.add_edges_from(links)
ookm_log.debug("Topology updated")
def get_link_between_switches(self):
AllLink = api.get_all_link(self)
for Link in AllLink:
src_port = Link.src
dst_port = Link.dst
src_sw_dpid = src_port.dpid
dst_sw_dpid = dst_port.dpid
self.LinkBetweenSwitches[(src_sw_dpid,
dst_sw_dpid)] = (src_port.port_no,
dst_port.port_no)
def _is_switch_port_to_port(self, dpid, port):
links = api.get_all_link(self)
for link in links:
if link.src.dpid == dpid and \
link.src.port_no == port:
return True
return False
def get_nx_graph(self):
links = ryu_api.get_all_link(self)
g = nx.DiGraph()
for link in links:
src = link.src
dst = link.dst
g.add_edge(src.dpid, dst.dpid, src_port=src.port_no, dst_port=dst.port_no)
return g
def _is_switch_port_to_port(self, dpid, port):
links = api.get_all_link(self)
for link in links:
if link.src.dpid == dpid and \
link.src.port_no == port:
return True
return False
def _update_topology(self):
switch_list = get_all_switch(self)
if len(switch_list) != 0:
self.dpids_port_to_mac = self._get_dpids_port_to_mac(switch_list)
self.dpids = self._get_dpids(switch_list) #[dpid,dpid,dpid,...]
link_dict = get_all_link(self)
if len(link_dict) != 0:
self.links_dpid_to_port = self._get_links_dpid_to_port(link_dict)
self.links = self._get_links(self.links_dpid_to_port) #[(src.dpid,dst.dpid),(src.dpid,dst.dpid),...]
if self.dpids and self.links:
self.adjacency_matrix = self._get_adjacency_matrix(self.dpids, self.links)
def get_graph(self):
link_list = get_all_link(self)
for link in link_list:
src_dpid = link.src.dpid
dst_dpid = link.dst.dpid
src_port = link.src.port_no
dst_port = link.dst.port_no
self.graph.add_edge(src_dpid, dst_dpid,
src_port=src_port,
dst_port=dst_port)
return self.graph
def get_topology_data(self):
"""Get Topology Data
"""
switch_list = get_all_switch(self)
switches = [switch.to_dict() for switch in switch_list]
links_list = get_all_link(self)
links = [link.to_dict() for link in links_list]
host_list = get_all_host(self)
hosts = [h.to_dict() for h in host_list]
return {"switches": switches, "links": links, "hosts": hosts}
def get_topology_data(self, ev):
switchList = api.get_all_switch(self)
linkList = api.get_all_link(self)
self.switches = [switch.dp.id for switch in switchList]
self.srcLinks = [(link.src.dpid, link.dst.dpid, {
'port': link.src.port_no
}) for link in linkList]
self.dstLinks = [(link.dst.dpid, link.src.dpid, {
'port': link.dst.port_no
}) for link in linkList]
self.constructGraph()
def find_next_hop_to_destination(self, source_id, destination_id):
link_list = get_all_link(self)
net = nx.DiGraph()
for link in link_list:
net.add_edge(link.src.dpid, link.dst.dpid, port=link.src.port_no)
path = nx.shortest_path(net, source_id, destination_id)
first_link = net[path[0]][path[1]]
return first_link['port']
def _get_out_port(self, src, dst):
'''
get output port from src switch to dst switch
return
'''
links = api.get_all_link(self)
for link in links:
if link.src.dpid == src and \
link.dst.dpid == dst:
return link.src.port_no
def _get_topology(self):
while True:
self.logger.info('\n')
hosts = get_all_host(self)
switch_list = get_all_switch(self)
links_list = get_all_link(self)
switches =[switch.dp.id for switch in switch_list]
self.net.add_nodes_from(switches)
links=[(link.src.dpid,link.dst.dpid,{'port':link.src.port_no}) for link in links_list]
self.net.add_edges_from(links)
hub.sleep(2)
def get_all_edge_port(self):
edge_ports = set()
not_edge_port = set()
for link in topo_api.get_all_link(self):
not_edge_port.add(link.src)
not_edge_port.add(link.dst)
for switch in topo_api.get_all_switch(self)
for port in switch.ports:
if port not in not_edge_port:
edge_ports.add(port)
def get_links(self):
result = {}
links = topology_api.get_all_link(self)
if links:
for s in links:
dst = s.dst
if not result.has_key(str(dst.dpid)):
result.setdefault(str(dst.dpid), dst.port_no)
src = s.src
if not result.has_key(str(src.dpid)):
result.setdefault(str(src.dpid), src.port_no)
return result
def _get_out_port(self, src, dst):
'''
get output port from src switch to dst switch
return
'''
links = api.get_all_link(self)
for link in links:
if link.src.dpid == src and \
link.dst.dpid == dst:
return link.src.port_no
def get_nx_graph(self):
links = ryu_api.get_all_link(self)
g = nx.DiGraph()
for link in links:
src = link.src
dst = link.dst
g.add_edge(src.dpid,
dst.dpid,
src_port=src.port_no,
dst_port=dst.port_no)
return g
def getTopo(self,ev):
# 得到所有的交换机对象
# Switch对象
# 属性： self.dp = dp
# self.ports = [Port实例]，有port_no,dpid
#self.logger.info("update")
self.switches = api.get_all_switch(self)
# AllLink
AllLink = api.get_all_link(self)
self.creat_link_between_switches(AllLink)
self.creat_port_of_switches(self.switches)
#self.logger.info(self.port_of_switches)
self.creat_access_ports()
def state_change_handler(self, ev):
dp=ev.datapath
assert dp is not None
LOG.debug(dp)
sw_list = api.get_all_switch(self)
sw_list_body =json.dumps([ switch.to_dict() for switch in sw_list])
print('sw_list_body {}'.format(sw_list_body))
link_list = api.get_all_link(self)
link_list_body =json.dumps([link.to_dict() for link in link_list])
print ('link_list_body {}' .format(link_list_body))
Switches.state_change_handler
def get_graph(self):
link_list = topo_api.get_all_link(self)
for link in link_list:
src_dpid = link.src.dpid
dst_dpid = link.dst.dpid
src_port = link.src.port_no
dst_port = link.dst.port_no
if (src_dpid, dst_dpid) not in self.link_delay.keys():
x = random.randint(1, 501)
self.link_delay[(src_dpid, dst_dpid)] = x
self.link_delay[(dst_dpid, src_dpid)] = x
self.graph.add_edge(src_dpid,
dst_dpid,
src_port=src_port,
dst_port=dst_port,
delay=self.link_delay[(src_dpid, dst_dpid)])
return self.graph
def port_status_handler(self,ev):
msg=ev.msg
reason=msg.reason
dp=msg.datapath
ofpport = msg.desc
Switches.port_status_handler
print('yes')
#sw_list = get_switch(self, 1)
sw_list = api.get_all_switch(self)
sw_list_body =json.dumps([ switch.to_dict() for switch in sw_list])
print('sw_list_body {}'.format(sw_list_body))
link_list = api.get_all_link(self)
link_list_body = json.dumps([ link.to_dict() for link in link_list ])
print('link_list_body {}'.format(link_list_body))
def _get_topology(self):
hub.sleep(10)
self.logger.info('\n\n\n')
#hosts = get_all_host(self)
switches = get_all_switch(self)
links = get_all_link(self)
self.logger.info('switches:')
for switch in switches:
self.logger.info(switch.to_dict())
#self.logger.info(switch)
self.graph.add_node(switch.dp.id)
self.logger.info('links:')
for link in links:
self.logger.info(link.to_dict())
#self.logger.info('src='+str(link.src.dpid)+', dst='+str(link.dst.dpid))
self.graph.add_edge(link.src.dpid, link.dst.dpid, port=link.src.port_no)
def get_topology_data(self):
"""Get Topology Data
"""
switch_list = get_all_switch(self.app)
switches = [switch.to_dict() for switch in switch_list]
links_list = get_all_link(self.app)
links = [link.to_dict() for link in links_list]
host_list = get_all_host(self.app)
# To remove hosts that are not removed by controller
ports = []
for switch in switch_list:
ports += switch.ports
port_macs = [p.hw_addr for p in ports]
n_host_list = [h for h in host_list if h.port.hw_addr in port_macs]
hosts = [h.to_dict() for h in n_host_list]
return {"switches": switches, "links": links, "hosts": hosts}
def get_nx_graph(self):
graph = nx.DiGraph()
switches = topo_api.get_all_switch(self)
links = topo_api.get_all_link(self)
for switch in switches:
dpid = switch.dp.id
graph.add_node(dpid)
for link in links:
src_dpid = link.src.dpid
dst_dpid = link.dst.dpid
src_port = link.src.port_no
dst_port = link.dst.port_no
graph.add_edge(src_dpid,
dst_dpid,
src_port=src_port,
dst_port=dst_port)
return graph
def get_nx_graph(self):
graph = nx.DiGraph()
switches = topo_api.get_all_switch(self)
links = topo_api.get_all_link(self)
for switch in switches:
dpid = switch.dp.id
graph.add_node(dpid)
for link in links:
src_dpid = link.src.dpid
dst_dpid = link.dst.dpid
src_port = link.src.port_no
dst_port = link.dst.port_no
graph.add_edge(src_dpid,
dst_dpid,
src_port=src_port,
dst_port=dst_port)
return graph
def switch_enter_handler(self, ev):
"""Automatically create global view"""
sw_list = get_all_switch(self.topology_api_app)
link_list = get_all_link(self.topology_api_app)
# create dpid to datapath mapping
# for sw in sw_list:
# if sw.dp.id not in self.dpset:
# print 'Enter sw %d' % sw.dp.id
# self.dpset[sw.dp.id] = sw
for link in link_list:
if link.src.dpid not in self.links:
self.links[link.src.dpid] = {}
self.links[link.src.dpid][str(link.dst.dpid)] = link.src.port_no
if link.dst.dpid not in self.links:
self.links[link.dst.dpid] = {}
self.links[link.dst.dpid][str(link.src.dpid)] = link.dst.port_no
print self.links
def _get_topology(self):
while True:
self.logger.info('\n\n\n')
hosts = get_all_host(self)
switches = get_all_switch(self)
links = get_all_link(self)
self.logger.info('hosts:')
for hosts in hosts:
self.logger.info(hosts.to_dict())
self.logger.info('switches:')
for switch in switches:
self.logger.info(switch.to_dict())
self.logger.info('links:')
for link in links:
self.logger.info(link.to_dict())
hub.sleep(2)
def get_topology_data(self, ev):
print "get_topology_data() is called"
global myswitches, adjacency, datapath_list
switch_list = get_all_switch(self.topology_api_app)#, None)
#print colored('get_switch','green')
#print (switch_list)
myswitches = [switch.dp.id for switch in switch_list]
for switch in switch_list:
datapath_list[switch.dp.id] = switch.dp
# print "datapath_list=", datapath_list
print "myswitches=", myswitches
links_list = get_all_link(self.topology_api_app)#, None)
#print colored('get_link','green')
#print (links_list)
# print "links_list=", links_list
mylinks = [(link.src.dpid, link.dst.dpid, link.src.port_no, link.dst.port_no) for link in links_list]
for s1, s2, port1, port2 in mylinks:
# print "type(s1)=", type(s1), " type(port1)=", type(port1)
adjacency[s1][s2] = port1
adjacency[s2][s1] = port2
print s1, ":", port1, "<--->", s2, ":", port2
def get_topology(self, ev):
"""
Get topology info.
"""
# print('----------------')
# print('get_topology')
neighbors = {}
port_no_to_neighbor_id = {}
switch_list = get_all_switch(self.topology_api_app)
for sw in switch_list:
#print (sw.dp.id) #int
neighbors[sw.dp.id] = set()
port_no_to_neighbor_id[sw.dp.id] = {}
links = get_all_link(self.topology_api_app)
for link in links:
# print(link)
# print(link.src.port_no, link.dst.dpid)#int int
neighbors[link.src.dpid].add(link.dst.dpid)
port_no_to_neighbor_id[link.src.dpid][link.src.port_no] = link.dst.dpid
#print(neighbors)
self.neighbors = neighbors
self.port_no_to_neighbor_id = port_no_to_neighbor_id
#print(self.neighbors)
hosts = get_all_host(self.topology_api_app)
# print(type(hosts))
for host in hosts:
# print('host')
# print(host.mac, type(host.mac))#str
# print(host.port.dpid, type(host.port.dpid))#int
if host.ipv4:
self.host2switch[host.ipv4[0]] = host.port.dpid
# XXX 上面如果host有ipv4地址，则按第一个ipv4地址录入其连接的交换机，否则按ipv6地址，都没有就不录入(ip存的是点分十进制字符串)
elif host.ipv6:
self.host2switch[host.ipv6[0]] = host.port.dpid
else:
pass
def get_all_links(self):
'''
link form format:
[(a.1, b.1), (b.2, c.1), (b.3, d.1)]
x.k means dpid x and port no k
a.1 means first port in switch "a"
this topology should looks like:
a.1 - 1.b.2 - 1.c
3
|
1
d
'''
all_links = ryu_api.get_all_link(self)
result = []
for link in all_links:
src = '{}.{}'.format(link.src.dpid, link.src.port_no)
dst = '{}.{}'.format(link.dst.dpid, link.dst.port_no)
result.append((src, dst))
# internal switch links
all_switches = ryu_api.get_all_switch(self)
link_to_add = []
# O(n^3), such dirty!!
for switch in all_switches:
ports = switch.ports
for port in ports:
for _port in ports:
if port != _port:
src = '{}.{}'.format(port.dpid, port.port_no)
dst = '{}.{}'.format(_port.dpid, _port.port_no)
link_to_add.append((src, dst))
result.extend(link_to_add)
return result
def _get_topology(self):
hub.sleep(10)
self.logger.info('\n\n\n')
#hosts = get_all_host(self)
switches = get_all_switch(self)
links = get_all_link(self)
self.logger.info('switches:')
for switch in switches:
self.logger.info(switch.to_dict())
#self.logger.info(switch)
self.graph.add_node(switch.dp.id)
self.logger.info('links:')
for link in links:
try:
lldp_delay1 = self.lldp_delay[(link.src.dpid, link.dst.dpid)]
lldp_delay2 = self.lldp_delay[(link.dst.dpid, link.src.dpid)]
echo_delay1 = self.echo_delay[link.src.dpid]
echo_delay2 = self.echo_delay[link.dst.dpid]
delay = (lldp_delay1 + lldp_delay2 - echo_delay1 - echo_delay2) / 2
w = max(delay, 0)
def create_spanning_tree(self):
"""Builds and display topology graph and that run minimum spanning tree algorithm
important fields:
self.switch_list: Nodes are extracted and stored in dictionary from the LLDP based topology
self.links: links are extracted and stored in dictionary from the LLDP based topology
self.add_switch: function is called to build topology graph and add nodes
self.add_link: function is called to add link to the topology
self.mst : minimum spanning tree is created and path is stored in the dictionary"""
self.switch_list = api.get_all_switch(self)
self.links = api.get_all_link(self)
self.sw_list_body =json.dumps([ switch.to_dict() for switch in self.switch_list])
self.add_switch()
self.add_link()
nx.draw(self.graph)
plt.show()
self.mst = nx.minimum_spanning_tree(self.graph)
print self.mst
print(self.mst.nodes())
print(self.mst.edges())
nx.draw(self.mst)
plt.show()
x = nx.connected_components(self.mst)
print x
# shortest_path1=nx.shortest_path(self.mst,2)
# print shortest_path1
# shortest_path2=nx.shortest_path(self.mst,1,3)
# print shortest_path2
# shortest_path3 = nx.shortest_path(self.mst,1,2)
# print shortest_path3
return self.mst
def port_modify_handler(self, ev):
dp = ev.dp
port_attr = ev.port
dp_str = dpid_lib.dpid_to_str(dp.id)
self.logger.info("\t ***switch dpid=%s"
"\n \t port_no=%d hw_addr=%s name=%s config=0x%08x "
"\n \t state=0x%08x curr=0x%08x advertised=0x%08x "
"\n \t supported=0x%08x peer=0x%08x curr_speed=%d max_speed=%d" %
(dp_str, port_attr.port_no, port_attr.hw_addr,
port_attr.name, port_attr.config,
port_attr.state, port_attr.curr, port_attr.advertised,
port_attr.supported, port_attr.peer, port_attr.curr_speed,
port_attr.max_speed))
if port_attr.state == 1:
self.topo_shape.print_links("Link Down")
out = self.topo_shape.link_with_src_port(port_attr.port_no, dp.id)
print("out" + str(out))
if out is not None:
print(self.topo_shape.find_shortest_path(out.src.dpid))
elif port_attr.state == 0:
self.topo_shape.topo_raw_links = get_all_link(self) ### HERE ###
print("Link count: " + str(len(self.topo_shape.topo_raw_links)))
self.topo_shape.print_links("Link Up")
def list_links(self):
links = topo_api.get_all_link(self)
return [link.to_dict() for link in links]
def create_topology_vertices(self):
self.switch_list = api.get_all_switch(self)
self.links = api.get_all_link(self)
self.create_switch()
self.create_switch_to_switch_links()
def _packet_in_handler(self, ev):
# If you hit this you might want to increase
# the "miss_send_length" of your switch
if ev.msg.msg_len < ev.msg.total_len:
self.logger.debug("packet truncated: only %s of %s bytes",
ev.msg.msg_len, ev.msg.total_len)
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
in_port = msg.match['in_port']
pkt = packet.Packet(msg.data)
eth = pkt.get_protocols(ethernet.ethernet)[0]
if eth.ethertype == ether_types.ETH_TYPE_LLDP:
# ignore lldp packet
return
dst = eth.dst
src = eth.src
dpid = datapath.id
# Figure out environment
links = api.get_all_link(self)
switches = api.get_all_switch(self)
hosts = api.get_all_host(self)
arp_pkt = None
if eth.ethertype == ether_types.ETH_TYPE_ARP:
arp_pkt = pkt.get_protocols(arp.arp)[0]
if arp_pkt.opcode == arp.ARP_REQUEST:
# Send to ARP proxy. Cannot perform NIx routing until both hosts
# are known by the controller
self.ArpProxy (msg.data, datapath, in_port, links, switches, hosts)
return
elif arp_pkt.opcode == arp.ARP_REPLY:
self.ArpReply (msg.data, datapath, arp_pkt.dst_ip, links, switches, hosts)
return
self.logger.info("%s: packet in %s %s %s %s %s", time.time(), dpid, src, dst, in_port, eth.ethertype)
# Start nix vector code
numNodes = len(switches) + len(hosts)
src_ip = ''
dst_ip = ''
srcNode = ''
dstNode = ''
if eth.ethertype == ether_types.ETH_TYPE_ARP:
arp_pkt = pkt.get_protocols(arp.arp)[0]
src_ip = arp_pkt.src_ip
dst_ip = arp_pkt.dst_ip
elif eth.ethertype == ether_types.ETH_TYPE_IP:
ipv4_pkt = pkt.get_protocols(ipv4.ipv4)[0]
src_ip = ipv4_pkt.src
dst_ip = ipv4_pkt.dst
for host in hosts:
if src_ip == host.ipv4[0]:
srcNode = host
if dst_ip == host.ipv4[0]:
dstNode = host
srcSwitch = [switch for switch in switches if switch.dp.id == srcNode.port.dpid][0]
dstSwitch = [switch for switch in switches if switch.dp.id == dstNode.port.dpid][0]
parentVec = {}
foundIt = self.BFS (numNodes, srcSwitch, dstSwitch,
links, switches, hosts, parentVec)
sdnNix = []
nixVector = []
if foundIt:
self.BuildNixVector (parentVec, srcSwitch, dstSwitch, links, switches, hosts, nixVector, sdnNix)
sdnNix.insert(0, (dstSwitch, dstNode.port.port_no))
self.sendNixPacket (ofproto, parser, srcSwitch, sdnNix, msg)
self.modLastHop (ofproto, parser, dstSwitch, dstNode.port.port_no, msg)
def get_all_links(self):
return get_all_link(self)
def get_topology_data(self, ev):
switch_list = get_all_switch(self)
self.qos.add_switches(switch_list)
links_list = get_all_link(self)
self.qos.add_links(links_list)