def _consumer_threadproc(self): """ :return: """ timeout = 3 while core.running: try: data = self.q.get(timeout=timeout) except: continue if data is None: # Signal to quit break batch = [] while True: self.q.task_done() port_no, packet = data batch.append((port_no, packet)) try: data = self.q.get(block=False) except: break core.callLater(self._rx_batch, batch)
def __init__ (self, con, *args, **kw): self._response = None self._sync = threading.Event() self._aborted = False self._listeners = None self._con = con core.callLater(self._do_init, args, kw)
def _make_connection(self, loop, addr, port, reconnect_delay=_default_retry_delay, connect_callback=None, disconnect_callback=None, **kw): self.loop = loop self.addr = addr #IPAddr(addr) self.port = port self.reconnect_delay = reconnect_delay self.connect_callback = connect_callback self.disconnect_callback = disconnect_callback s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket = s s.setblocking(0) self._debug("Attempting to connect to %s:%s", self.addr, self.port) r = s.connect_ex((str(self.addr), self.port)) if r in (0, errno.EINPROGRESS, errno.EAGAIN, 10035): # 10035=WSAEWOULDBLOCK # We either connected or connection is in progress pass else: #self._error("Couldn't connect to %s:%s", self.addr, self.port) #raise RuntimeError("Couldn't connect") core.callLater(self._handle_close) return self.loop.register_worker(self)
def _make_connection (self, loop, addr, port, reconnect_delay = _default_retry_delay, connect_callback = None, disconnect_callback = None, **kw): self.loop = loop self.addr = addr #IPAddr(addr) self.port = port self.reconnect_delay = reconnect_delay self.connect_callback = connect_callback self.disconnect_callback = disconnect_callback s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket = s s.setblocking(0) self._debug("Attempting to connect to %s:%s", self.addr, self.port) r = s.connect_ex((str(self.addr), self.port)) if r in (0, errno.EINPROGRESS, errno.EAGAIN, 10035): # 10035=WSAEWOULDBLOCK # We either connected or connection is in progress pass else: #self._error("Couldn't connect to %s:%s", self.addr, self.port) #raise RuntimeError("Couldn't connect") core.callLater(self._handle_close) return self.loop.register_worker(self)
def request_dispatcher(): print "Starting request dispatcher..." context = zmq.Context.instance() socket = context.socket(zmq.REP) socket.bind(REQ_URL) while True: req_obj = socket.recv_json() print("Received request in dispatcher") if "type" not in req_obj: socket.send_json({ "type": "Error", "what": "Unknown message, no 'type' field." }) continue app = core.l2_multi type = req_obj["type"] #------------------------------------------------------------ if type == "LinkFailure": Link = req_obj["link"] # To get the failed link Link_Probability = req_obj[ "probability"] # To get the link probability core.callLater(app.received_info, Link, Link_Probability) socket.send_json({"type": "processing", "what": req_obj}) else: socket.send_json({ "type": "Error", "what": "Unknown message type." })
def __init__(self, con, *args, **kw): self._response = None self._sync = threading.Event() self._aborted = False self._listeners = None self._con = con #self._init(*args, **kw) core.callLater(self._do_init, args, kw)
def launch (): def f (): import sys sys.settrace(_tf) core.callLater(f) import threading _trace_thread = threading.Thread(target=_trace_thread_proc) _trace_thread.daemon = True _trace_thread.start()
def _dispatch_one (self, code, rv, args, kw): if callable(code): r = code(*args, **kw) else: def f (): l = {'self':self} l.update(kw) exec code in globals(), l r = f() if rv: core.callLater(rv, r)
def _pcap_cb (self, obj, data, sec, usec, length): """ Handles incoming data from pcap This may not be on the right thread, so we just push it to a thread-safe queue and poke the cooperative thread, which will pop it later. """ do_read = self._q.empty() self._q.put((obj,data)) if do_read: core.callLater(self._queue_read)
def _dispatch_one(self, code, rv, args, kw): if callable(code): r = code(*args, **kw) else: def f(): l = {'self': self} l.update(kw) exec code in globals(), l r = f() if rv: core.callLater(rv, r)
def move_entry (from_list, from_set, to_list, to_set): """ Move entry from one list to another """ i,mac = get(from_list) if mac is None: return from_list.delete(i) to_list.insert(END, mac) mac = EthAddr(mac) to_set.add(mac) from_set.remove(mac) if clear_tables_on_change: # This is coming from another thread, so don't just send -- use # callLater so that it happens from the coop thread. core.callLater(clear_flows)
def call_as_coop_task(func, *args, **kwargs): """ Schedule a coop microtask and run the given function with parameters in it. Use POX core logic directly. :param func: function need to run :type func: func :param args: nameless arguments :param kwargs: named arguments :return: None """ from pox.core import core core.callLater(func, *args, **kwargs)
def launch(): """ Lança nova thread de _trace_thread_proc. :return: Sem retorno. """ def f(): import sys sys.settrace(_tf) core.callLater(f) import threading _trace_thread = threading.Thread(target=_trace_thread_proc) _trace_thread.daemon = True _trace_thread.start()
def _queue_read (self): anything = False for _ in xrange(10): # as most X at once try: data = self._q.get(False) self._q.task_done() anything = True except: break pcap,data = data self.raiseEventNoErrors(RXData, self, data) if anything: # Check for remainders later core.callLater(self._queue_read)
def do_POST(self): hmh = self._enter() if hmh is None: return None l = self.headers.get("Content-Length", "") if l == "": data = json.loads(self.rfile.read()) else: data = json.loads(self.rfile.read(int(l))) payload = data['data'] # We send null payload for timeout poking and initial setup if payload is not None: if not hmh._check_rx_seq(data['seq']): # Bad seq! data = '{"seq":-1,"ses":"%s"}' % (hmh.session_key, ) self.send_response(400, "Bad sequence number") self.send_header("Content-Type", "application/json") self.send_header("Content-Length", str(data)) self.send_header("X-POX-Messenger-Sequence-Number", "-1") if self.auth_function: self.send_header("WWW-Authenticate", 'Basic realm="POX"') self.end_headers() self.wfile.write(data) hmh._close() return core.callLater(hmh._do_recv_msg, payload) else: #print "KeepAlive", hmh pass try: data = '{"seq":-1,"ses":"%s"}' % (hmh.session_key, ) self.send_response(200, "OK") self.send_header("Content-Type", "application/json") self.send_header("Content-Length", str(data)) self.send_header("X-POX-Messenger-Sequence-Number", "-1") if self.auth_function: self.send_header("WWW-Authenticate", 'Basic realm="POX"') self.end_headers() self.wfile.write(data) except: import traceback tracekback.print_exc() pass return
def _consumer_threadproc (self): timeout = 3 while core.running: try: data = self.q.get(timeout=timeout) except: continue batch = [] while True: self.q.task_done() port_no,data = data data = ethernet(data) batch.append((data,port_no)) try: data = self.q.get(block=False) except: break core.callLater(self.rx_batch, batch)
def do_POST (self): hmh = self._enter() if hmh is None: return None l = self.headers.get("Content-Length", "") if l == "": data = json.loads(self.rfile.read()) else: data = json.loads(self.rfile.read(int(l))) payload = data['data'] # We send null payload for timeout poking and initial setup if payload is not None: if not hmh._check_rx_seq(data['seq']): # Bad seq! data = '{"seq":-1,"ses":"%s"}' % (hmh.session_key,) self.send_response(400, "Bad sequence number") self.send_header("Content-Type", "application/json") self.send_header("Content-Length", str(data)) self.send_header("X-POX-Messenger-Sequence-Number", "-1") if self.auth_function: self.send_header("WWW-Authenticate", 'Basic realm="POX"') self.end_headers() self.wfile.write(data) hmh._close() return core.callLater(hmh._do_recv_msg, payload) else: #print "KeepAlive", hmh pass try: data = '{"seq":-1,"ses":"%s"}' % (hmh.session_key,) self.send_response(200, "OK") self.send_header("Content-Type", "application/json") self.send_header("Content-Length", str(data)) self.send_header("X-POX-Messenger-Sequence-Number", "-1") if self.auth_function: self.send_header("WWW-Authenticate", 'Basic realm="POX"') self.end_headers() self.wfile.write(data) except: import traceback tracekback.print_exc() pass return
def _consumer_threadproc(self): timeout = 3 while core.running: try: data = self.rx_q.get(timeout=timeout) except: continue if data is None: # Signal to quit break batch = [] while True: self.rx_q.task_done() port_no, data = data # data = ethernet(data) batch.append((data, port_no)) try: data = self.rx_q.get(block=False) except: break core.callLater(self.rx_batch, batch)
def one_time_wrapper(*args, **kwargs): # Use POX internal thread-safe wrapper for scheduling return core.callLater(func, *args, **kwargs)