def __init__(self): self.graph = nx.Graph() self.ht = host_tracker.host_tracker() core.openflow_discovery.addListeners(self) self.listenTo(self.ht) core.addListeners(self)
def start(self): assert self._thread is None from pox.core import core core.addListeners(self, weak=True) self._thread = Thread(target=self._thread_func) #self._thread.daemon = True self._thread.start()
def __init__(self): core.addListeners(self) core.openflow_discovery.addListeners(self) self.nodes = [] self.edges = defaultdict(list) self.distances = {} self.ports = {}
def __init__(self, **kw): """ Create a switch instance Additional options over superclass: log_level (default to default_log_level) is level for this instance ports is a list of interface names """ log_level = kw.pop('log_level', self.default_log_level) self.magic_virtual_port_names = kw.pop("magic_virtual_port_names", self.magic_virtual_port_names) self.q = Queue() self.t = Thread(target=self._consumer_threadproc) core.addListeners(self) ports = kw.pop('ports', []) kw['ports'] = [] super(PCapSwitch, self).__init__(**kw) self._next_port = 1 self.px = {} for p in ports: self.add_interface(p, start=False) self.log.setLevel(log_level) for px in self.px.itervalues(): px.start() self.t.start()
def __init__ (self): # This timer handles expiring stuff self._expire_timer = Timer(5, _handle_expiration, recurring=True) self._arp_timer = Timer(3, _arp_for_real_servers, recurring=True, selfStoppable=True) core.addListeners(self)
def start (self): assert self._thread is None from pox.core import core core.addListeners(self, weak=True) self._thread = Thread(target=self._thread_func) #self._thread.daemon = True self._thread.start()
def __init__ (self, *args, **kw): """ Create a switch instance Additional options over superclass: log_level (default to default_log_level) is level for this instance """ log_level = kw.pop('log_level', self.default_log_level) self.q = Queue() self.t = Thread(target=self._consumer_threadproc) core.addListeners(self) super(PCapSwitch,self).__init__(*args,**kw) self.px = {} for p in self.ports.values(): px = pxpcap.PCap(p.name, callback = self._pcap_rx, start = False) px.port_no = p.port_no self.px[p.port_no] = px self.log.setLevel(log_level) for px in self.px.itervalues(): px.start() self.t.start()
def __init__ (self, **kw): """ Create a switch instance Additional options over superclass: log_level (default to default_log_level) is level for this instance ports is a list of interface names """ log_level = kw.pop('log_level', self.default_log_level) self.q = Queue() self.t = Thread(target=self._consumer_threadproc) core.addListeners(self) ports = kw.pop('ports', []) kw['ports'] = [] super(PCapSwitch,self).__init__(**kw) self._next_port = 1 self.px = {} for p in ports: self.add_interface(p, start=False) self.log.setLevel(log_level) for px in self.px.itervalues(): px.start() self.t.start()
def __init__ (self, pusher_stream="pox"): core.addListeners(self) core.openflow.addListeners(self) self.stream = pusher_stream self.stopStatsThread = Event() self.syncThread = TimerThread(self.stopStatsThread, request_stats, STAT_SAMPLING_PERIOD) self.syncThread.start()
def __init__(self, filename): Timer(15, self.write_topology) self.net = core.thesis_topo self.filename = filename core.openflow.addListeners(self) core.addListeners(self)
def __init__(self, port = 6655, address = '0.0.0.0'): Task.__init__(self) self.port = int(port) self.address = address self.connection=None #core.addListener(pox.core.GoingUpEvent, self._handle_GoingUpEvent) core.addListeners(self)
def __init__(self): # self._expire_timer = Timer(5, _handle_expiration, recurring=True) # self.ip = IPAddr(input("Enter dummy IP Address: ")) # self.mac = EthAddr(input("Enter dummy MAC Address: ")) self.ip = IPAddr("10.0.0.100") self.mac = EthAddr("00:11:22:33:44:55") core.addListeners(self, priority=1) self.hold_down_expired = _flood_delay == 0
def __init__(self): # This timer handles expiring stuff self._expire_timer = Timer(5, _handle_expiration, recurring=True) self._arp_timer = Timer(3, _arp_for_real_servers, recurring=True, selfStoppable=True) core.addListeners(self)
def __init__(self): self.groups = {} self.incomplete_groups = {} self.group_addrs = set() self.member_state_builder = None core.addListeners(self) core.listen_to_dependencies(self, ['MemberStateBuilder']) core.openflow.addListeners(self)
def __init__(self): threading.Thread.__init__(self) core.addListeners(self) self._dataForConnection = {} self._lock = threading.RLock() self._waker = pox.lib.util.makePinger() self.sending = False self.start()
def __init__ (self): threading.Thread.__init__(self) core.addListeners(self) self._dataForConnection = {} self._lock = threading.RLock() self._waker = pox.lib.util.makePinger() self.sending = False self.start()
def _all_dependencies_met(self): """ Called when every component on which depends are initialized on POX core. Contain dependency relevant initialization. :return: None """ try: self.initialize() # With fully event-driven communication between the layers the dependency # handling takes care by listen_to_dependencies() run into a dead-lock. # The root of this problem is the bidirectional or cyclic dependency # between the components, so basically the layers will always wait to each # other to be registered on core. To avoid this situation the naming # convention of event handlers on which the dependency checking based is # not followed (a.k.a. leave _handle_<component name>_<event name>) and # the event listeners is set up manually. For automatic core registration # the components have to contain dependencies explicitly. for dep in self.dependencies: if not self._standalone: if core.core.hasComponent(dep): dep_layer = core.components[dep] # Register actual event handlers on dependent layer dep_layer.addListeners(self) # Register dependent layer's event handlers on actual layer self.addListeners(dep_layer) else: raise AttributeError( "Component is not registered on core") else: # In case of standalone mode set up a StandaloneHelper in this object # with the name of the dependency to handle raised events # automatically setattr(self, dep, SimpleStandaloneHelper(self, dep)) # Subscribe for GoingDownEvent to finalize API classes # shutdown() function will be called if POX's core going down core.addListenerByName('GoingDownEvent', self.shutdown) # Subscribe for UpEvent to call functions after everithing is up core.addListenerByName('UpEvent', self.post_up_hook) # Subscribe core event for advanced functions # Listeners' name must follow POX naming conventions core.addListeners(self) # Everything is set up an "running" so register the component on pox.core # as a final step. Other dependent component can finish initialization # now. core.core.register(self._core_name, self) # Set "running" config for convenience purposes CONFIG.set_layer_loaded(self._core_name) except KeyboardInterrupt: quit_with_error( msg="Initialization of %s was interrrupted by user!" % self.__class__.__name__) except Exception as e: quit_with_error(msg="Abort ESCAPEv2 initialization...", exception=e)
def __init__(self): """ Initialise topology module. """ self.graph = nx.Graph() self.ht = host_tracker.host_tracker() core.openflow_discovery.addListeners(self) self.listenTo(self.ht) core.addListeners(self)
def __init__(self, connection, client_macs, **kwargs): for name, value in kwargs.items(): setattr(self, name, value) self.connection = connection self.unacked = [] self.controlling = [] self.transport = PiloTransport(self, self.udp_ip, self.udp_port, self.src_address, self.retransmission_timeout, self.heartbeat_interval) for client_mac in client_macs: self.transport.initiate_connection(client_mac) # Creates an open flow rule which should send PILO broadcast messages # to our handler broadcast_msg_flow = of.ofp_flow_mod() broadcast_msg_flow.priority = 100 broadcast_msg_flow.match.dl_type = pkt.ethernet.IP_TYPE broadcast_msg_flow.match.nw_proto = pkt.ipv4.UDP_PROTOCOL broadcast_msg_flow.match.nw_dst = IPAddr( self.udp_ip) # TODO: better matching for broadcast IP broadcast_msg_flow.actions.append( of.ofp_action_output(port=of.OFPP_CONTROLLER)) self.connection.send(broadcast_msg_flow) normal_msg_flow = of.ofp_flow_mod() normal_msg_flow.priority = 101 normal_msg_flow.match.dl_type = pkt.ethernet.IP_TYPE normal_msg_flow.match.dl_src = pkt.packet_utils.mac_string_to_addr( get_hw_addr(self.this_if)) normal_msg_flow.match.nw_proto = pkt.ipv4.UDP_PROTOCOL normal_msg_flow.match.nw_dst = IPAddr( self.udp_ip) # TODO: better matching for broadcast IP normal_msg_flow.actions.append(of.ofp_action_output(port=of.OFPP_ALL)) self.connection.send(normal_msg_flow) # A Final rule to send any ovs rule misses to the controller # I believe that OF 1.0 does this automatically, but later versions do not table_miss_msg_flow = of.ofp_flow_mod() table_miss_msg_flow.priority = 1 table_miss_msg_flow.actions.append( of.ofp_action_output(port=of.OFPP_CONTROLLER)) self.connection.send(table_miss_msg_flow) connection.addListeners(self, priority=99) self.transport.addListeners(self) core.addListeners(self, priority=99) core.openflow.addListeners(self, priority=99)
def __init__ (self, port = 6655, address = '0.0.0.0'): Task.__init__(self) self.port = int(port) self.address = address self.connection=None self.finallink=[] self.switches = set() self.adjacency = {} core.addListeners(self) core.openflow_discovery.addListeners(self) core.openflow.addListeners(self)
def __init__ (self): self.prev_change_port = None self.log_file = open("/tmp/pox_log", "w") self.barrier_log_file = open("/tmp/barrier_log", "w") self._pending_barriers = {} self._prev_barrier_arrived = {} self._xid_generator = of.xid_generator() core.openflow.addListeners(self) core.Outband.addListeners(self) core.addListeners(self) super( ProactiveRouting, self ).__init__()
def __init__(self): self.prev_change_port = None self.log_file = open("/tmp/pox_log", "w") self.barrier_log_file = open("/tmp/barrier_log", "w") self._pending_barriers = {} self._prev_barrier_arrived = {} self._xid_generator = of.xid_generator() core.openflow.addListeners(self) core.Outband.addListeners(self) core.addListeners(self) super(ProactiveRouting, self).__init__()
def __init__(self, objective, preinstall): Timer(30, self._update_flows) #Timer(15, self._preinstall_rules) self.flows = {} self.net = core.thesis_topo self.stats = core.thesis_stats self.objective = objective self.preinstall = preinstall core.openflow.addListeners(self) core.addListeners(self)
def __init__(self): # (topology dependent)initialize arp and master table with host ip-mac self._master_arp_table = {} for i in range(1, 7): ipaddr = "10.0.0.%s" % str(i) mac = "00:00:00:00:00:0%s" % str(i) self._master_arp_table[IPAddr(ipaddr)] = EthAddr(mac) self._arp_table = {} #(topology specific) dpid self.S4 = 4 self.S5 = 5 core.addListeners(self)
def __init__(self,tor_num,core_num): core.addListeners(self) self.tor_list = set() self.tor_addr_config= dict() self.core_list = set() for s in range(tor_num): dpid = "00-00-%0.2x-00-00-00" % (s+1) ip = "192.168.%i.254/24" % (s+1) self.tor_list.add(dpid) self.tor_addr_config[dpid] = ip for s in range(core_num): dpid = "10-00-%0.2x-00-00-00" % (s+1) self.core_list.add(dpid)
def startup(self): """ Esta funcion se encarga de inicializar el controller Agrega el controller como event handler para los eventos de openflow y openflow_discovery """ core.openflow.addListeners(self) core.openflow_discovery.addListeners(self) core.host_tracker.addListeners(self) core.addListeners(self) core.openflow.addListenerByName("FlowRemoved", self._handle_flow_removal) log.info('Controller initialized')
def __init__ (self, host_tracker=False, pusher_stream="pox"): core.listen_to_dependencies(self) core.addListeners(self) self.initModel() self.stream = pusher_stream if host_tracker: # TODO: Don't seem to be getting host events at the moment? log.info("Host tracking enabled") host_tracker.addListenerByName("HostEvent", self.__handle_host_tracker_HostEvent) self.stopSyncThread = Event() self.syncThread = TimerThread(self.stopSyncThread, self.sync, 15) self.syncThread.start()
def __init__(self, host_tracker=False, pusher_stream="pox"): core.listen_to_dependencies(self) core.addListeners(self) self.initModel() self.stream = pusher_stream if host_tracker: # TODO: Don't seem to be getting host events at the moment? log.info("Host tracking enabled") host_tracker.addListenerByName( "HostEvent", self.__handle_host_tracker_HostEvent) self.stopSyncThread = Event() self.syncThread = TimerThread(self.stopSyncThread, self.sync, 15) self.syncThread.start()
def __init__(self,no_flows,explicit_drop,validate_link_timeout,delete_link_timeout,flow_priority,ttl,send_cycle,send_lldp_cycle_interval,raise_link_event_cycle_interval): self.install_flow = not no_flows self.explicit_drop = explicit_drop self.validate_link_timeout = validate_link_timeout self.delete_link_timeout = delete_link_timeout self.flow_priority = flow_priority self.ttl = ttl self.send_cycle = send_cycle self.send_lldp_cycle_interval = send_lldp_cycle_interval self.raise_link_event_cycle_interval = raise_link_event_cycle_interval self.adjacency = Adjacency() self._set_link_validate_timer(validate_link_timeout) self.port_addr = dict() core.addListeners(self) core.Interactive.variables["link"] = self.adjacency
def __init__(self, no_flow, eat_packets, default_request_src_mac=False, default_reply_src_mac=None): """ Initialize default_request_src_mac and default_reply_src_mac are the default source MAC addresses for send_arp_request() and send_arp_reply(). """ core.addListeners(self) self._install_flow = not no_flow self.eat_packets = eat_packets self.default_request_src_mac = default_request_src_mac self.default_reply_src_mac = default_reply_src_mac
def __init__(self, connection, transparent): self.macToPort = {} self.connection = connection self.transparent = transparent # for _handle_PacketIn to work core.addListeners(self, priority = PRIORITY) core.openflow.addListeners(self, priority = PRIORITY) connection.addListeners(self, priority = PRIORITY) # Rule for ARP default_timout = OpF.OFP_FLOW_PERMANENT msg = OpF.ofp_flow_mod() msg.match = OpF.ofp_match(dl_type = pkt.ethernet.ARP_TYPE) msg.idle_timeout = default_timout msg.hard_timeout = default_timout msg.priority = PRIORITY msg.actions.append(OpF.ofp_action_output(port = OpF.OFPP_CONTROLLER)) self.connection.send(msg)
def __init__(self, objective, preinstall): """ Initialise multicommodity module. objective: objective function for calculating routes preinstall: list of flow rules to preinstall on switches """ Timer(30, self._update_flows) self.flows = {} self.net = core.thesis_topo self.stats = core.thesis_stats self.objective = objective self.preinstall = preinstall self.log_rules = False self.done = False core.openflow.addListeners(self) core.addListeners(self)
def start(self): assert self._thread is None from pox.core import core core.addListeners(self, weak=True) if self.use_select: try: import select except: # Fall back self.use_select = False # Log warning? if self.use_select: self.blocking = False self._thread = pcap_select_loop.add(self) else: self._thread = Thread(target=self._thread_func) self._thread.start()
def __init__(self, connection, transparent): self.macToPort = {} self.connection = connection self.transparent = transparent # for _handle_PacketIn to work core.addListeners(self, priority=PRIORITY) core.openflow.addListeners(self, priority=PRIORITY) connection.addListeners(self, priority=PRIORITY) # Rule for ARP default_timout = OpF.OFP_FLOW_PERMANENT msg = OpF.ofp_flow_mod() msg.match = OpF.ofp_match(dl_type=pkt.ethernet.ARP_TYPE) msg.idle_timeout = default_timout msg.hard_timeout = default_timout msg.priority = PRIORITY msg.actions.append(OpF.ofp_action_output(port=OpF.OFPP_CONTROLLER)) self.connection.send(msg)
def __init__(self, **kw): """ Create a switch instance Additional options over superclass: log_level (default to default_log_level) is level for this instance ports is a list of interface names """ log_level = kw.pop('log_level', self.default_log_level) self.policy = None self.rx_q = Queue() self.consumer_thread = Thread(target=self._consumer_threadproc) self.tx_q = Queue() self.producer_thread = Thread(target=self._producer_threadproc) core.addListeners(self) ports = kw.pop('ports', []) kw['ports'] = [] self.policy_name = kw.pop("policy", '') if self.policy_name: load_policy(self, self.policy_name) super(ProgSwitch, self).__init__(**kw) self._next_port = 1 self.px = {} for p in ports: self.add_interface(p, start=False) self.log.setLevel(log_level) for px in self.px.itervalues(): px.start() self.consumer_thread.start() self.producer_thread.start()
def __init__(self,timeout,no_flow,eat_packets,no_learn,*args,**kwargs): self.ARP_TIMEOUT = timeout self.install_flow = not no_flow self.eat_packets = eat_packets self.learn = not no_learn #buffer for packet stored in datapath self.ipv4_buffers = dict() self.arp_buffers = dict() # This timer handles expiring stuff self._expire_arp_table_timer = Timer(5, self._handle_arp_table_expiration,recurring=True) self._expire_ipv4_buffer_timer = Timer(5, self._handle_ipv4_buffer_expiration,recurring=True) self._expire_arp_buffer_timer = Timer(5, self._handle_arp_buffer_expiration,recurring=True) # Listen to dependencies core.addListeners(self) def _listen_to_dependencies(): core.BaseUtil.addListeners(self,priority=100) core.LLDPUtil.addListeners(self,priority=100) core.call_when_ready(_listen_to_dependencies, ('BaseUtil','LLDPUtil')) #Get SRPConfig def _get_config(): log.debug('Config Module is loaded!') self.arp_table = ARPTableSet() for dpid in core.SRPConfig.tor_list: self.arp_table[dpid] = ARPTable() ip = IPAddr(parse_cidr(core.SRPConfig.get_tor_lan_addr(dpid))[0]) self.arp_table[dpid][ip] = Entry(_dpid_to_mac(str_to_dpid(dpid)), static=True) for k, v in kwargs.iteritems(): self.arp_table[dpid][IPAddr(k)] = Entry(v, static=True) core.Interactive.variables['arp'] = self.arp_table core.call_when_ready(_get_config,('SRPConfig',))
def __init__(self, name, main=None, **kwargs): """ Create a switch instance log_level (default to default_log_level) is level for this instance ports is a list of interface names :param kwargs: :return: """ super(ProgSwitch, self).__init__() self.name = name self.tables = None self.policy = None if main: r_value = main() if isinstance(r_value, Policy): self.policy = r_value elif isinstance(r_value, tuple) and len(r_value) == 2: if not isinstance(r_value[0], tables): raise TypeError("Invalid tables") self.tables = r_value[0] if not isinstance(r_value[1], Policy): raise TypeError("Invalid policy") self.policy = r_value[1] else: raise TypeError("Invalid target.datapath policy") core.addListeners(self) self.port_no = 1 self.ports = {} self.q = Queue() self.t = Thread(target=self._consumer_threadproc)
def __init__ (self): # This timer handles expiring stuff self._expire_timer = Timer(5, _handle_expiration, recurring=True) core.addListeners(self)
def __init__(self, no_flow, eat_packets, use_port_mac=False): core.addListeners(self) self._install_flow = not no_flow self.eat_packets = eat_packets self.use_port_mac = use_port_mac
def __init__(self): self._arp_table = {} #initialize table self._master_arp_table = {} core.addListeners(self)
def __init__(self, connection): self.dict_pxpcap = defaultdict(lambda:defaultdict(lambda:[])) connection.addListeners(self) core.addListeners(self, weak=True)
def __init__ (self): # This timer handles expiring stuff self._expire_timer = Timer(5, _handle_expiration, recurring=True) core.listen_to_dependencies(self) core.addListeners(self, priority = 2)
def __init__(self): self.first = True core.openflow.addListeners(self) core.addListeners(self)
def __init__(self, no_flow, eat_packets): core.addListeners(self) self._install_flow = not no_flow self.eat_packets = eat_packets
def __init__(self): self._arp_table = {} self._master_arp_table = {} core.addListeners(self)
def __init__(self): self.groups = {} core.addListeners(self) core.openflow.addListeners(self)
def __init__(self, type='full'): self.type = type self.db = {} core.openflow.addListeners(self) core.addListeners(self)
def __init__(self): log.info("HostController init...") # core.listen_to_dependencies(self) # core.openflow.addListeners(self) core.addListeners(self) log.info("Done.")
def __init__ (self): self.first = True core.openflow.addListeners(self) core.addListeners(self)
def __init__(self, topoFile, routingFile): self.topoStruct = TopoStructure(topoFile) self.routingConfig = routingFile core.addListeners(self)
def __init__(self): self.switches = {} core.openflow.addListeners(self) core.addListeners(self)
def __init__ (self, transparent): self.listenTo(core.openflow) core.addListeners(self) self.transparent = transparent
def __init__(self): # This timer handles expiring stuff self._expire_timer = Timer(5, _handle_expiration, recurring=True) core.addListeners(self)
def __init__ (self, timeout = 10): self.timeout = timeout self._t = Timer(self.timeout, self._check_timeouts, recurring=True) core.addListeners(self) core.host_tracker.addListeners(self)