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()