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