def __init__(self, *args, **kwargs):
super(QoS, self).__init__(*args, **kwargs)
self.name = 'qos'
self.datapaths = {}
self.port_stats = {}
self.port_speed = {}
self.flow_stats = {}
self.flow_speed = {}
self.stats = {}
self.port_features = {}
self.free_bandwidth = {}
self.echo_latency = {}
self.link_loss = {}
self.awareness = lookup_service_brick('awareness')
self.sw_module = lookup_service_brick('switches')
self.graph = None
self._graph = None
self.capabilities = None
self.best_paths = None
self.sending_echo_request_interval = 0.05
self.identify = False
# Start to green thread to monitor traffic and calculating
# free bandwidth of links respectively.
self.monitor_thread = hub.spawn(self._monitor)
self.save_thread = hub.spawn(self._save_graph)
def __init__(self, *args, **kwargs):
super(NetworkMonitor, self).__init__(*args, **kwargs)
self.name = 'monitor'
self.datapaths = {}
self.port_stats = {}
self.port_info = {}
self.flow_stats = {}
self.elephant_info = {}
self.elephant_path = {}
self.elephant_src = []
self.monitor_time = 5
self.monitor_number = 0
self.flow_number = 0
self.port_number = 0
self.flow_size = 0
self.port_size = 0
self.flow_request_number = 0
self.flow_request_size = 0
self.port_request_number = 0
self.port_request_size = 0
self.flow_mode_number = 0
self.flow_mode_size = 0
self.flow_path_number = 0
self.echo_latency = {}
self.sw_module = lookup_service_brick('switches')
self.awareness = lookup_service_brick('awareness')
self.graph = None
self.capabilities = None
self.best_paths = None
self.monitor_thread = hub.spawn(self._monitor)
def __init__(self, *args, **kwargs):
super(NetworkMonitor, self).__init__(*args, **kwargs)
self.name = 'monitor'
self.datapaths = {}
self.port_stats = {}
self.port_info = {}
self.flow_stats = {}
self.flow_speed = {}
self.stats = {}
self.port_features = {}
self.free_bandwidth = {}
self.link_info = {}
self.link_info_flag = False
self.link_elephant_flow = {}
self.elephant_info = []
self.elephant_path = {}
self.echo_latency = {}
self.times = 0
self.sw_module = lookup_service_brick('switches')
self.awareness = lookup_service_brick('awareness')
self.graph = None
self.capabilities = None
self.best_paths = None
# Start to green thread to monitor traffic and calculating
# free bandwidth of links respectively.
self.monitor_thread = hub.spawn(self._monitor)
self.measure_thread = hub.spawn(self._detector)
def __init__(self, *args, **kwargs):
super(simple_Monitor, self).__init__(*args, **kwargs)
self.name = "monitor"
self.count_monitor = 0
self.topology_api_app = self
self.datapaths = {}
self.port_stats = {}
self.port_speed = {}
self.flow_stats = {}
self.flow_speed = {}
self.flow_loss = {}
self.port_loss = {}
self.link_loss = {}
self.net_info = {}
self.net_metrics= {}
self.link_free_bw = {}
self.link_used_bw = {}
self.stats = {}
self.port_features = {}
self.free_bandwidth = {}
self.paths = {}
self.installed_paths = {}
self.delay = lookup_service_brick('delay')
self.awareness = lookup_service_brick('awareness')
self.monitor_thread = hub.spawn(self.monitor)
def _GA_Fit(routine):
j=-1
count=0
monitor = lookup_service_brick('monitor')
awareness = lookup_service_brick('awareness')
Max_value=setting.MAX_CAPACITY*1000.0
graph =awareness.graph.copy()
traffics=monitor.traffics
flow_code = routine
for k in flow_code:
j = j + 1
f=traffics[j]
src = f['src']
dst = f['dst']
speed = f['speed']
demand = f['demand']
core=1001 + k % 4
paths=monitor._ip2sw(src,dst)
for path in paths:
if path[int((len(path) - 1) / 2)] == core:
# print(path)
for i in xrange(0, len(path) - 1):
spare=graph[path[i]][path[i + 1]].get('bandwidth') - (setting.MAX_CAPACITY*demand)/4 # consider the flow_demand
# spare=graph[path[i]][path[i + 1]].get('bandwidth')-(speed*8)/1024
graph[path[i]][path[i + 1]]['bandwidth']=max(spare,0)
flow_band_list=[]
for link in graph.edges():
node1 = link[0]
node2 = link[1]
flow_band_list.append(graph[node1][node2].get('bandwidth'))
sd=np.std(flow_band_list,ddof=1)
# min_bw=min(flow_band_list)
return sd / 1024.000
def __init__(self, *args, **kwargs):
super(NetworkDelayDetector, self).__init__(*args, **kwargs)
self.name = 'delaydetector'
self.sw_module = lookup_service_brick('switches')
self.awareness = lookup_service_brick('awareness')
self.datapaths = {}
self.echo_latency = {}
self.measure_thread = hub.spawn(self._detector)
def __init__(self, *args, **kwargs):
super(NetworkDelayDetector, self).__init__(*args, **kwargs)
self.name = 'delaydetector'
self.sw_module = lookup_service_brick('switches')
self.awareness = lookup_service_brick('awareness')
self.datapaths = {}
self.echo_latency = {}
self.measure_thread = hub.spawn(self._detector)
def __init__(self, *args, **kwargs):
super(LatencyCalculator, self).__init__(*args, **kwargs)
self.name = 'latencycalculator'
self.sending_echo_request_interval = 0.05
# Get the active object of swicthes and nwtopology module.
# So that this module can use their data.
self.sw_module = lookup_service_brick('switches')
self.nwtopology = lookup_service_brick('topologydiscovery')
self.datapaths = {}
self.echo_latency = {}
self.measure_thread = hub.spawn(self._calculator)
def __init__(self, *args, **kwargs):
super(NetworkDelayDetector, self).__init__(*args, **kwargs)
self.name = 'delaydetector'
self.sending_echo_request_interval = 0.05
# Get the active object of swicthes and awareness module.
# So that this module can use their data.
self.sw_module = lookup_service_brick('switches')
self.awareness = lookup_service_brick('awareness')
self.datapaths = {}
self.echo_latency = {}
self.measure_thread = hub.spawn(self._detector)
def __init__(self, *args, **kwargs):
super(NetworkDelayDetector, self).__init__(*args, **kwargs)
self.name = 'delaydetector'
self.sending_echo_request_interval = 0.05
# Get the active object of swicthes and awareness module.
# So that this module can use their data.
self.sw_module = lookup_service_brick('switches')
self.awareness = lookup_service_brick('awareness')
self.datapaths = {}
self.echo_latency = {}
self.measure_thread = hub.spawn(self._detector)
def __init__(self, *args, **kwargs):
super(simple_Delay, self).__init__(*args, **kwargs)
self.name = "delay"
self.sending_echo_request_interval = 0.1
self.sw_module = lookup_service_brick('switches')
self.awareness = lookup_service_brick('awareness')
self.count = 0
self.datapaths = {}
self.echo_latency = {}
self.link_delay = {}
self.delay_dict = {}
self.measure_thread = hub.spawn(self._detector)
def __init__(self, *args, **kwargs):
super(Translation, self).__init__(*args, **kwargs)
self.name = 'oxp_translation'
self.args = args
self.network = app_manager.lookup_service_brick("Network_Aware")
self.router = app_manager.lookup_service_brick('shortest_forwarding')
self.domain = None
self.oxparser = oxproto_v1_0_parser
self.oxproto = oxproto_v1_0
self.buffer = {}
self.buffer_id = 0
def __init__(self, *args, **kwargs):
super(DelayDetect, self).__init__(*args, **kwargs)
self.name = "delay"
self.topology = lookup_service_brick("topology")
self.switches = lookup_service_brick("switches")
self.dpid2switch = {}
self.dpid2echoDelay = {}
self.src_sport_dst2Delay = {}
self.detector_thread = hub.spawn(self._detector)
def __init__(self, *args, **kwargs):
super(Manager, self).__init__(*args, **kwargs)
self.name = "manager"
self.awareness = lookup_service_brick("awareness")
self.delay = lookup_service_brick("delay")
self.monitor = lookup_service_brick("monitor")
# self.delay = kwargs["simple_delay"]
self.link_loss = {}
self.net_info = {}
self.net_metrics = {}
self.link_free_bw = {}
self.link_used_bw = {}
self.paths_metrics = {}
def __init__(self, *args, **kwargs):
super(NetworkMonitor, self).__init__(*args, **kwargs)
self.name = 'monitor'
self.datapaths = {}
self.port_stats = {}
self.port_info = {}
self.flow_stats = {}
self.elephant_info = {}
self.monitor_time = 5
self.monitor_number = 0
self.flow_number = 0
self.port_number = 0
self.flow_size = 0
self.port_size = 0
self.flow_request_number = 0
self.flow_request_size = 0
self.port_request_number = 0
self.port_request_size = 0
self.flow_mode_number = 0
self.flow_mode_size = 0
self.flow_path_number = 0
self.elephant_number = 0
self.hostsList = []
self.flows = [] # Record flows that need to be rescheduled. (hmc)
self.awareness = lookup_service_brick('awareness')
self.graph = None
self.capabilities = None
self.best_paths = None
self.monitor_thread = hub.spawn(self._monitor)
def _save_lldp_delay(self, src=0, dst=0, lldpdelay=0):
try:
self.topo_disc.graph[src][dst]['lldpdelay'] = lldpdelay
except:
if self.topo_disc is None:
self.topo_disc = lookup_service_brick('topo_disc')
return
def __init__(self, *args, **kwargs):
super(NetworkMonitor, self).__init__(*args, **kwargs)
self.name = 'monitor'
self.datapaths = {}
self.port_stats = {}
self.port_speed = {}
self.flow_stats = {}
self.pre_GFF_path = {}
self.flow_speed = {}
self.stats = {}
self.flow_index = []
self.select = {}
self.congested = False
self.flows_len = 0
self.flows = {}
self.traffics = {}
self.hostsList = []
self.port_features = {}
self.free_bandwidth = {
} # self.free_bandwidth = {dpid:{port_no:free_bw,},} unit:Kbit/s
self.current_free_bandwidth = {}
self.current_dectect_dp = {}
self.awareness = lookup_service_brick('awareness')
self.graph = None
self.capabilities = None
self.best_paths = None
self.k = 0
self.gp = GaProcessor()
# Start to green thread to monitor traffic and calculating
# free bandwidth of links respectively.
self.monitor_thread = hub.spawn(self._monitor)
def __init__(self, *args, **kwargs):
super(NetworkMonitor, self).__init__(*args, **kwargs)
self.name = 'monitor'
self.datapaths = {}
self.port_stats = {}
self.port_speed = {}
self.flow_stats = {}
self.pre_GFF_path = {}
self.flow_speed = {}
self.stats = {}
self.count = 0
self.record_dp = set()
self.flows = {}
self.flows_stats = {}
self.traffics = {}
self.hostsList = []
self.flowCount = 0
self.port_features = {}
self.free_bandwidth = {
} # self.free_bandwidth = {dpid:{port_no:free_bw,},} unit:Kbit/s
self.link_dropped = {}
self.link_errors = {}
self.link_info = {'bandwidth': {}}
self.port_speed = {'bandwidth': {}}
self.awareness = lookup_service_brick('awareness')
# self.shortest_forwarding = lookup_service_brick('shortest_forwarding')
self.graph = None
self.capabilities = None
self.best_paths = None
self.flow_num = []
# Start to green thread to monitor traffic and calculating
# free bandwidth of links respectively.
self.monitor_thread = hub.spawn(self._monitor)
def create_bw_graph(self, bw_dict):
"""
Save bandwidth data into networkx graph object.
"""
try:
graph = self.awareness.graph.copy()
link_to_port = self.awareness.link_to_port
for link in link_to_port:
(src_dpid, dst_dpid) = link
(src_port, dst_port) = link_to_port[link]
if src_dpid in bw_dict and dst_dpid in bw_dict:
bandwidth = bw_dict[src_dpid][src_port]
# Add key:value pair of bandwidth into graph.
if graph.has_edge(src_dpid, dst_dpid):
graph[src_dpid][dst_dpid]['bandwidth'] = int(100 /
bandwidth)
else:
graph.add_edge(src_dpid, dst_dpid)
graph[src_dpid][dst_dpid]['bandwidth'] = int(100 /
bandwidth)
else:
if graph.has_edge(src_dpid, dst_dpid):
graph[src_dpid][dst_dpid][
'bandwidth'] = setting.MAX_CAPACITY
else:
graph.add_edge(src_dpid, dst_dpid)
graph[src_dpid][dst_dpid][
'bandwidth'] = setting.MAX_CAPACITY = 10000
return graph
except:
self.logger.info("Create bw graph exception")
if self.awareness is None:
self.awareness = lookup_service_brick('awareness')
return self.awareness.graph
def add_Port_Task(self, src_dpid, dst_dpid):
topo = app_manager.lookup_service_brick('Shortest_Forwarding')
src_port = topo.get_link_to_port(topo.network_aware.link_to_port, src_dpid, dst_dpid)[0]
dst_port = topo.get_link_to_port(topo.network_aware.link_to_port, dst_dpid, src_dpid)[0]
self.send_port_stats_request(self.datapaths[src_dpid], src_port)
self.send_port_stats_request(self.datapaths[dst_dpid], dst_port)
return (src_dpid, src_port, dst_dpid, dst_port)
def __init__(self, *args, **kwargs):
super(Routing, self).__init__(*args, **kwargs)
self.module_topo = app_manager.lookup_service_brick("oxp_topology")
self.topology = self.module_topo.topo
self.location = self.module_topo.location
self.domains = {}
self.graph = {}
def __init__(self,
rules,
handovers,
finished_handovers,
switch=None,
position=None,
start_handover_callback=None):
self.switch = switch
self._position = position
self.is_ingress = position == 'ingress'
self.app = app_manager.lookup_service_brick('HandoverApi')
self.port_to_vnf = {}
self.port_to_mac = {}
self.vnf_id_to_port = {}
self.mac_to_port = {}
self.mac_to_vnf = {}
self.first_vnf_id = 0
self.active_flow_mod_entries = []
self.handovers = []
self.rules = rules
self.handovers = handovers
self.finished_handovers = finished_handovers
self.start_handover_callback = start_handover_callback
def _get_datapaths(self, app):
if not hasattr(app, 'datapaths') or not app.datapaths:
datapaths = lookup_service_brick("topoaware").datapaths
app.datapaths = datapaths
else:
datapaths = app.datapaths
return datapaths
def _save_lldp_delay(self, src=0, dst=0, lldpdelay=0):
try:
self.nwtopology.database[src][dst]['lldpdelay'] = lldpdelay
except:
if self.nwtopology is None:
self.nwtopology = lookup_service_brick('topologydiscovery')
return
def _save_lldp_delay(self, src=0, dst=0, lldpdelay=0):
try:
self.awareness.graph[src][dst]['lldpdelay'] = lldpdelay
except:
if self.awareness is None:
self.awareness = lookup_service_brick('awareness')
return
def __init__(self, *args, **kwargs):
super(Routing, self).__init__(*args, **kwargs)
self.module_topo = app_manager.lookup_service_brick('oxp_topology')
self.topology = self.module_topo.topo
self.location = self.module_topo.location
self.domains = {}
self.graph = {}
def create_bw_graph(self):
"""
Save bandwidth data into networkx graph object.
"""
try:
link_to_port = self.awareness.link_to_port
for link in link_to_port:
self.link_info_flag = True
(src_dpid, dst_dpid) = link
(src_port, dst_port) = link_to_port[link]
src_tx = (src_dpid, src_port)
dst_rx = (dst_dpid, dst_port)
src_tx_bandwidth = self.port_info[src_tx]['speedTx']
dst_rx_bandwidth = self.port_info[dst_rx]['speedRx']
if link not in self.link_info:
self.link_info[link] = {}
self.link_info[link]['bandwidth'] = 0
self.link_info[link][
'freebandwidth'] = setting.MAX_CAPACITY - self.link_info[
link]['bandwidth']
self.link_info[link]['bandwidth'] = min(
src_tx_bandwidth, dst_rx_bandwidth)
self.link_info[link][
'freebandwidth'] = setting.MAX_CAPACITY - self.link_info[
link]['bandwidth']
except:
self.logger.info("Create bw graph exception")
if self.awareness is None:
self.awareness = lookup_service_brick('awareness')
return self.awareness.graph
def __init__(self, *args, **kwargs):
super(NetworkMonitor, self).__init__(*args, **kwargs)
self.name = 'monitor'
self.awareness = lookup_service_brick('awareness')
self.datapaths = {}
self.port_stats = {}
self.port_speed = {}
self.flow_stats = {}
self.flow_speed = {}
self.stats = {}
self.port_features = {}
self.free_bandwidth = {} # {dpid:{port_no:free_bw,},} Unit:Kbit/s
self.graph = None
self.capabilities = None
self.best_paths = None
# Create four data structures for Hedera specially.
self.hostsList = []
self.flows = [] # Record flows that need to be rescheduled. (hmc)
self.statRecord = []
self.pre_GFF_path = {} # Record the last GFF path of flows
# Start to green thread to monitor traffic and calculating
# free bandwidth of links respectively.
self.monitor_thread = hub.spawn(self._monitor)
self.save_freebandwidth_thread = hub.spawn(self._save_bw_graph)
def __init__(self, *args, **kwargs):
super(HostAwareness, self).__init__(*args, **kwargs)
self.topo_module = lookup_service_brick("topoaware")
self.name = "hostaware"
self.ip_to_host = {} # ip -> host
self.mac_to_host = {} # mac -> host
self.dum_hosts_thread = hub.spawn(self._dump_hosts)
def _save_lldp_delay(self, src=0, dst=0, lldpdelay=0):
try:
self.awareness.graph[src][dst]['lldpdelay'] = lldpdelay
except:
if self.awareness is None:
self.awareness = lookup_service_brick('awareness')
return
def __init__(self, *args, **kwargs):
super(HostAwareness, self).__init__(*args, **kwargs)
self.topo_module = lookup_service_brick("topoaware")
self.name = "hostaware"
self.ip_to_host = {} # ip -> host
self.mac_to_host = {} # mac -> host
self.dum_hosts_thread = hub.spawn(self._dump_hosts)
def get_topology_data(self, ev):
time.sleep(2) # 等待拓扑建立完成
if self.switch_mod is None:
self.switch_mod = lookup_service_brick('switches')
switch_list = self.switch_mod.dps.keys()
#links_list = get_link(self.topology_api_app, None)
links_list = [(link.src.dpid, link.dst.dpid, {
'port': link.src.port_no,
'bw': 0,
'delay': 0,
'lldpdelay': 0
}) for link in self.switch_mod.links]
self.net.add_nodes_from(switch_list)
self.net.add_edges_from(links_list)
print(self.net.nodes())
for link in self.switch_mod.links:
self.idport_to_id.update({
(link.src.dpid, link.src.port_no):
link.dst.dpid
})
print(self.net.nodes())
print(self.idport_to_id)
def create_bw_graph(self, bw_dict):
"""
Save bandwidth data into networkx graph object.
"""
try:
graph = self.awareness.graph
link_to_port = self.awareness.link_to_port
for link in link_to_port:
(src_dpid, dst_dpid) = link
(src_port, dst_port) = link_to_port[link]
if src_dpid in bw_dict and dst_dpid in bw_dict:
bw_src = bw_dict[src_dpid][src_port]
bw_dst = bw_dict[dst_dpid][dst_port]
bandwidth = min(bw_src, bw_dst)
# Add key:value pair of bandwidth into graph.
if graph.has_edge(src_dpid, dst_dpid):
graph[src_dpid][dst_dpid]['bandwidth'] = bandwidth
else:
graph.add_edge(src_dpid, dst_dpid)
graph[src_dpid][dst_dpid]['bandwidth'] = bandwidth
else:
if graph.has_edge(src_dpid, dst_dpid):
graph[src_dpid][dst_dpid]['bandwidth'] = 0
else:
graph.add_edge(src_dpid, dst_dpid)
graph[src_dpid][dst_dpid]['bandwidth'] = 0
return graph
except:
self.logger.info("Create bw graph exception")
if self.awareness is None:
self.awareness = lookup_service_brick('awareness')
return self.awareness.graph
def _get_datapaths(self,app):
if not hasattr(app,'datapaths') or not app.datapaths:
datapaths = lookup_service_brick("topoaware").datapaths
app.datapaths = datapaths
else:
datapaths = app.datapaths
return datapaths
def register_switch_address(addr, interval=None):
"""
Registers a new address to initiate connection to switch.
Registers a new IP address and port pair of switch to let
ryu.controller.controller.OpenFlowController to try to initiate
connection to switch.
:param addr: A tuple of (host, port) pair of switch.
:param interval: Interval in seconds to try to connect to switch
"""
assert len(addr) == 2
assert ip.valid_ipv4(addr[0]) or ip.valid_ipv6(addr[0])
ofp_handler = app_manager.lookup_service_brick(ofp_event.NAME)
_TMP_ADDRESSES[addr] = interval
def _retry_loop():
# Delays registration if ofp_handler is not started yet
while True:
if ofp_handler.controller is not None:
for a, i in _TMP_ADDRESSES.items():
ofp_handler.controller.spawn_client_loop(a, i)
hub.sleep(1)
break
hub.sleep(1)
hub.spawn(_retry_loop)
def monitor(self):
"""
Main entry method of monitoring traffic.
"""
while True:
self.stats['flow'] = {}
self.stats['port'] = {}
print("[Statistics Module Ok]")
print("[{0}]".format(self.count_monitor))
if self.delay is None:
print('No monitor')
self.delay = lookup_service_brick('delay')
for dp in self.datapaths.values():
self.port_features.setdefault(dp.id, {}) #setdefault() returns the value of the item with the specified key
self.paths = None
self.request_stats(dp)
hub.sleep(1)
if self.stats['port']:
self.count_monitor += 1
self.get_port_loss()
self.get_link_free_bw()
self.get_link_used_bw()
self.write_values()
hub.sleep(setting.MONITOR_PERIOD)
if self.stats['port']:
self.show_stat('link')
hub.sleep(1)
def create_bw_graph(self, graph, bw_dict):
"""
Save bandwidth data into networkx graph object.
"""
try:
link_to_port = self.awareness.link_to_port
for link, port in link_to_port.items():
(src_dpid, dst_dpid) = link
(src_port, dst_port) = port
if src_dpid in bw_dict and dst_dpid in bw_dict:
bandwidth = bw_dict[src_dpid][src_port]
# Add key-value pair of bandwidth into graph.
if graph.has_edge(src_dpid, dst_dpid):
graph[src_dpid][dst_dpid]['bandwidth'] = bandwidth
else:
graph.add_edge(src_dpid, dst_dpid)
graph[src_dpid][dst_dpid]['bandwidth'] = bandwidth
else:
if graph.has_edge(src_dpid, dst_dpid):
graph[src_dpid][dst_dpid]['bandwidth'] = 0
else:
graph.add_edge(src_dpid, dst_dpid)
graph[src_dpid][dst_dpid]['bandwidth'] = 0
except:
self.logger.info("Create bw graph exception")
if self.awareness is None:
self.awareness = lookup_service_brick('awareness')
def get_Flow_Bandwidth(self, dpid, src_ip, dst_ip):
topo = app_manager.lookup_service_brick('Shortest_Forwarding')
self.flow_reply_count = {'dpid':dpid, 'src_ip':src_ip, 'dst_ip':dst_ip, 'count':1}
self.send_flow_stats_request(self.datapaths[dpid])
while self.flow_reply_count['count'] != 0 :
time.sleep(0.01)
print self.flow_stats
return (dpid, src_ip, dst_ip, self.flow_stats[dpid][(src_ip, dst_ip)][-1], self.flow_speed[dpid][(src_ip, dst_ip)][-1])
def __init__(self, *args, **kwargs):
super(SimpleSwitch13, self).__init__(*args, **kwargs)
self.mac_to_port = {}
self.dpset = app_manager.lookup_service_brick("dpset")
self.flowDB = set()
if self.CONF.enable_debugger:
self.logger.setLevel(logging.DEBUG)
def zclient_connection_factory(sock, addr):
LOG.debug('Connected from client: %s: %s', addr, sock)
zserv = app_manager.lookup_service_brick(ZServer.__name__)
with contextlib.closing(ZClient(zserv, sock, addr)) as zclient:
try:
zclient.start()
except Exception as e:
LOG.error('Error in client%s: %s', addr, e)
raise e
def __init__(self, *args, **kwargs):
super(BandwidthDetector, self).__init__(*args, **kwargs)
self.name = "bandwidthaware"
self._topo_module = lookup_service_brick("topoaware")
self.datapaths = {}
self.last_port_stats = {} # (dpid,port_no) -> portstatsreply
self.port_speed = {} # (dpid,port_no) -> speed
self.port_loss = {} # (dpid,port_no) -> loss
self.port_measure_thread = hub.spawn(self._port_stats_detect)
def __init__(self,*args,**kwargs):
super(Policy,self).__init__(*args,**kwargs)
hdlr = logging.StreamHandler()
fmt_str = '%(asctime)s - %(levelname)s - %(name)s - %(message)s'
hdlr.setFormatter(logging.Formatter(fmt_str))
self.logger.addHandler(hdlr)
self.logger.propagate = False
if self.CONF.enable_debugger:
self.logger.setLevel(logging.DEBUG)
self.nib = app_manager.lookup_service_brick("NIB")
self.dpset = app_manager.lookup_service_brick("dpset")
self.matches = {} #stored josndict
self.queueref = {} #[port][queue]
self.requestQ = [] #a request queue
self.sem = semaphore.Semaphore(1) #TO protect self.requestQ
def _detector(self):
while CONF.weight == 'delay':
self.create_link_delay()
try:
self.awareness.shortest_paths = {}
self.logger.debug("Refresh the shortest_paths")
except:
self.awareness = lookup_service_brick('awareness')
self.show_delay_statis()
self._send_echo_request()
hub.sleep(setting.DELAY_DETECTING_PERIOD)
def factory(cls, sock, address, probe_interval=None, *args, **kwargs):
ovs_stream = stream.Stream(sock, None, None)
connection = jsonrpc.Connection(ovs_stream)
schemas = discover_schemas(connection)
if not schemas:
return
fsm = reconnect.Reconnect(now())
fsm.set_name('%s:%s' % address)
fsm.enable(now())
fsm.set_passive(True, now())
fsm.set_max_tries(-1)
if probe_interval is not None:
fsm.set_probe_interval(probe_interval)
fsm.connected(now())
session = jsonrpc.Session(fsm, connection)
idl = Idl(session, schemas[0])
system_id = discover_system_id(idl)
if not system_id:
return None
name = cls.instance_name(system_id)
ovs_stream.name = name
connection.name = name
fsm.set_name(name)
kwargs = kwargs.copy()
kwargs['address'] = address
kwargs['idl'] = idl
kwargs['name'] = name
kwargs['system_id'] = system_id
app_mgr = app_manager.AppManager.get_instance()
old_app = app_manager.lookup_service_brick(name)
old_events = None
if old_app:
old_events = old_app.events
app_mgr.uninstantiate(name)
app = app_mgr.instantiate(cls, *args, **kwargs)
if old_events:
app.events = old_events
return app
def create_link_delay(self):
try:
for src in self.awareness.graph:
for dst in self.awareness.graph[src]:
if src == dst:
self.awareness.graph[src][dst]['delay'] = 0
continue
delay = self.get_dalay(src, dst)
self.awareness.graph[src][dst]['delay'] = delay
except:
if self.awareness is None:
self.awareness = lookup_service_brick('awareness')
return
def __init__(self, dpid):
# referenc to switches app
self.switches_app_ref = app_manager.lookup_service_brick('switches')
self.dpid = dpid
# statistics "history"
self.port_stat_dict = {} # current statistics per port
self.tw_port_stat_dict = {} # time window statistics per port
self.lldp_counter = LLDPCounter(dpid) # current lldp counter
self.tw_lldp_counter = LLDPCounter(dpid) # time window lldp counter
self.drop_rate = 0.0
self.fabrication_rate = 0.0
def get_Port_Bandwidth(self, src_dpid, dst_dpid):
topo = app_manager.lookup_service_brick('Shortest_Forwarding')
src_port = topo.get_link_to_port(topo.network_aware.link_to_port, src_dpid, dst_dpid)[0]
dst_port = topo.get_link_to_port(topo.network_aware.link_to_port, dst_dpid, src_dpid)[0]
self.send_port_stats_request(self.datapaths[src_dpid], src_port)
self.send_port_stats_request(self.datapaths[dst_dpid], dst_port)
self.reply_count_src={'dpid':src_dpid, 'port':src_port, 'count':1}
self.reply_count_dst={'dpid':dst_dpid, 'port':dst_port, 'count':1}
while self.reply_count_src['count'] != 0 or self.reply_count_dst['count'] != 0 :
time.sleep(0.01)
return ((src_port, self.port_stats[(src_dpid, src_port)][-1], self.port_speed[(src_dpid, src_port)][-1]),
(dst_port, self.port_stats[(src_dpid, src_port)][-1], self.port_speed[(src_dpid, src_port)][-1]))
def add_Flow_Task(self, src_ip, dst_ip):
self.is_loss_task = 1
topo = app_manager.lookup_service_brick('Shortest_Forwarding')
flow_path = topo.flowPaths[(src_ip,dst_ip)]
self.flow_reply_count = {'src_ip':src_ip, 'dst_ip':dst_ip, 'count':2}
self.send_flow_stats_request(self.datapaths[flow_path[0]])
self.send_flow_stats_request(self.datapaths[flow_path[-1]])
while self.flow_reply_count['count'] != 0 :
time.sleep(0.01)
self.is_loss_task = 0
return (src_ip, dst_ip, flow_path[0], flow_path[-1])
def add_Link_Task(self, src_dpid, dst_dpid):
self.is_loss_task = 1
topo = app_manager.lookup_service_brick('Shortest_Forwarding')
src_port = topo.get_link_to_port(topo.network_aware.link_to_port, src_dpid, dst_dpid)[0]
dst_port = topo.get_link_to_port(topo.network_aware.link_to_port, dst_dpid, src_dpid)[0]
self.send_port_stats_request(self.datapaths[src_dpid], src_port)
self.send_port_stats_request(self.datapaths[dst_dpid], dst_port)
self.reply_count_src={'dpid':src_dpid, 'port':src_port, 'count':1}
self.reply_count_dst={'dpid':dst_dpid, 'port':dst_port, 'count':1}
while self.reply_count_src['count'] != 0 or self.reply_count_dst['count'] != 0 :
time.sleep(0.01)
self.is_loss_task = 0
return (src_dpid, src_port, dst_dpid, dst_port)
def __init__(self, *args, **kwargs):
super(NetworkMonitor, self).__init__(*args, **kwargs)
self.name = 'monitor'
self.datapaths = {}
self.port_stats = {}
self.port_speed = {}
self.flow_stats = {}
self.flow_speed = {}
self.stats = {}
self.port_link = {}
self.free_bandwidth = {}
self.awareness = lookup_service_brick('awareness')
self.graph = None
self.monitor_thread = hub.spawn(self._monitor)
self.save_freebandwidth_thread = hub.spawn(self._save_bw_graph)
def create_link_delay(self):
"""
Create link delay data, and save it into graph object.
"""
try:
for src in self.awareness.graph:
for dst in self.awareness.graph[src]:
if src == dst:
self.awareness.graph[src][dst]['delay'] = 0
continue
delay = self.get_delay(src, dst)
self.awareness.graph[src][dst]['delay'] = delay
except:
if self.awareness is None:
self.awareness = lookup_service_brick('awareness')
return
def set_routing_path_method(self, ip_dst, ip_src):
routing_path = RandomRoutingPath(self.net)
srv_mgr_ref = app_manager.lookup_service_brick('ServiceManager')
try:
# ask for routing_path object in case of msg directed to service
routing_path = srv_mgr_ref.set_routing_path_method(ip_dst, ip_src)
routing_path.net = self.net
except AttributeError:
# this error is raised for None value @srv_mgr_ref
# ignore silently
pass
except ServiceManager.ServiceNotFound:
# the dst_ip or src_ip are not registered services: use non-trusted path
pass
return routing_path
def packet_in_handler(self, ev):
"""
Parsing LLDP packet and get the delay of link.
"""
msg = ev.msg
try:
src_dpid, src_port_no = LLDPPacket.lldp_parse(msg.data)
dpid = msg.datapath.id
if self.sw_module is None:
self.sw_module = lookup_service_brick('switches')
for port in self.sw_module.ports.keys():
if src_dpid == port.dpid and src_port_no == port.port_no:
delay = self.sw_module.ports[port].delay
self._save_lldp_delay(src=src_dpid, dst=dpid,
lldpdelay=delay)
except LLDPPacket.LLDPUnknownFormat as e:
return
def get_topology(self, ev):
switch_list = get_switch(self.topology_api_app, None)
self.create_port_map(switch_list)
self.switches = self.switch_port_table.keys()
links = get_link(self.topology_api_app, None)
self.create_interior_links(links)
self.create_access_ports()
self.get_graph(self.link_to_port.keys())
# self.show_topology()
if self.oxp_brick is None:
self.oxp_brick = app_manager.lookup_service_brick('oxp_event')
# If the topo change, reset the CONF.oxp_period.
# So, topo_reply module can reply in time.
CONF.oxp_period = self.period
def __init__(self, *args, **kwargs):
super(NetworkMonitor, self).__init__(*args, **kwargs)
self.name = 'monitor'
self.datapaths = {}
self.port_stats = {}
self.port_speed = {}
self.flow_stats = {}
self.flow_speed = {}
self.stats = {}
self.port_features = {}
self.free_bandwidth = {}
self.awareness = lookup_service_brick('awareness')
self.graph = None
self.capabilities = None
self.best_paths = None
# Start to green thread to monitor traffic and calculating
# free bandwidth of links respectively.
self.monitor_thread = hub.spawn(self._monitor)
self.save_freebandwidth_thread = hub.spawn(self._save_bw_graph)
def packet_in_handler(self, ev):
msg = ev.msg
try:
src_dpid, src_port_no = LLDPPacket.lldp_parse(msg.data)
dpid = msg.datapath.id
in_port = msg.match['in_port']
if self.sw_module is None:
self.sw_module = lookup_service_brick('switches')
for port in self.sw_module.ports.keys():
if src_dpid == port.dpid and src_port_no == port.port_no:
port_data = self.sw_module.ports[port]
timestamp = port_data.timestamp
if timestamp:
delay = time.time() - timestamp
self._save_lldp_delay(src=src_dpid, dst=dpid,
lldpdelay=delay)
except LLDPPacket.LLDPUnknownFormat as e:
return
def state_change_handler(self, ev):
domain = ev.domain
if ev.state == MAIN_DISPATCHER:
if domain.id not in self.topo.domains.keys():
self.topo.domains.setdefault(domain.id, None)
domain_topo = topology_data.Domain(domain_id=domain.id)
self.topo.domains[domain.id] = domain_topo
self.location.locations.setdefault(domain.id, set())
topo_request = domain.oxproto_parser.OXPTopoRequest(domain)
domain.send_msg(topo_request)
self.logger.info("Domain[%s] connected." % domain.id)
else:
self.logger.info("same domain id ocurred: %s" % domain.id)
self.oxp_brick = app_manager.lookup_service_brick('oxp_event')
if ev.state == DEAD_DISPATCHER:
del self.topo.domains[domain.id]
del self.location.locations[domain.id]
self.logger.info("Domain[%s] leave." % domain.id)
def create_bw_graph(self, bw_dict):
try:
graph = self.awareness.graph
link_to_port = self.awareness.link_to_port
for link in link_to_port:
(src_dpid, dst_dpid) = link
(src_port, dst_port) = link_to_port[link]
if src_dpid in bw_dict and dst_dpid in bw_dict:
bw_src = bw_dict[src_dpid][src_port]
bw_dst = bw_dict[dst_dpid][dst_port]
bandwidth = min(bw_src, bw_dst)
graph[src_dpid][dst_dpid]['bandwidth'] = bandwidth
else:
graph[src_dpid][dst_dpid]['bandwidth'] = 0
return graph
except:
self.logger.info("Create bw graph exception")
if self.awareness is None:
self.awareness = lookup_service_brick('awareness')
return self.awareness.graph
def _port_stats_reply_handler(self, ev):
msg = ev.msg
datapath = msg.datapath
body = msg.body
#LOG.info('TRUST_EVAL-EVENT: port statistics for dp %016x', datapath.id)
# TODO in case of EventSwitchLeave while a request is pending, the counter is
# never reset
self.pending_stats_req -= 1
# update lldp counter
sw_ref = app_manager.lookup_service_brick('switches')
lldp_counter = sw_ref.lldp_count_dict[datapath.id]
self.datapaths_stats[datapath.id].update_lldp_counter(lldp_counter)
# update port statistics
for stat in body:
if not stat.port_no == self.SW_TO_CONTR_PORT: # ignore port for controller communication
new_stat = SwStatistic.PortStat(datapath.id, stat.port_no)
new_stat.rx_pkts = stat.rx_packets
new_stat.tx_pkts = stat.tx_packets
self.datapaths_stats[datapath.id].update_port_stat(new_stat, stat.port_no)
#self._log_inter_port_stats(self.logger, datapath.id)
# compute drop rate for the switch
sw_drop_rate, sw_fabr_rate = self.datapaths_stats[datapath.id].get_flow_conservation()
LOG.info("DEBUG: Flow conservation property for dp %s: drop=%s%% fabr=%s%%", datapath.id, sw_drop_rate*100, sw_fabr_rate*100)
#self._log_port_statistics(msg, self.logger)
# raise event for switch drop rate
#trust_ev = trust_event.EventSwitchTrustChange(datapath.id, sw_drop_rate)
if not self.is_first_stat_req:
# self.send_event_to_observers(trust_ev)
# compute drop rate for all links if no requests are pending
if self.pending_stats_req == 0 :
self.link_drop_rate()
