def __init__(self, loop, socket):
self.loop = loop
self.socket = socket
# shortcircuit some socket methods
self.bind = self.socket.bind
self.bind_to_random_port = self.socket.bind_to_random_port
self.connect = self.socket.connect
self.setsockopt = self.socket.setsockopt
self.getsockopt = self.socket.getsockopt
self.setsockopt_string = self.socket.setsockopt_string
self.getsockopt_string = self.socket.getsockopt_string
self.setsockopt_unicode = self.socket.setsockopt_unicode
self.getsockopt_unicode = self.socket.getsockopt_unicode
self.fd = socket.getsockopt(zmq.FD)
self._poll = pyuv.Poll(loop, self.fd)
self._poll.start(pyuv.UV_READABLE, self._on_events)
self._prepare_h = pyuv.Prepare(loop)
self._waker = pyuv.Idle(self.loop)
self._events = 0
self._send_queue = deque()
self._read_cb = None
self._read_copy = True
self._read_track = False
def __init__(self, fileno, persistent=False, **kw):
"""
Create a poller.
:param fileno: the file descriptor we are going to poll
:param cb: the callback to call when we have detected we can read/write from this file descriptor
:param *args: the arguments to pass to cb
:param **kw: the keyword arguments to pass to cb
This poller will not be run unless it is scheduled in a hub by get_hub().add_poller(poller).
"""
if fileno < 0:
raise ValueError('invalid file descriptor: %d' % (fileno))
self.fileno = fileno
self.persistent = persistent
self.started = False
self.read_callback = kw.pop('_read_callback', None)
self.write_callback = kw.pop('_write_callback', None)
self.hub = weakref.proxy(kw.pop('_hub', get_hub()))
self.impl = pyuv.Poll(self.hub.uv_loop, fileno)
if _g_debug:
import traceback, cStringIO
self.traceback = cStringIO.StringIO()
traceback.print_stack(file=self.traceback)
def _adapter_connect(self):
"""Connect to the remote socket, adding the socket to the IOLoop if
connected
:rtype: bool
"""
LOGGER.debug('init io and signal watchers if any')
# reuse existing signal watchers, can only be declared for 1 ioloop
global global_sigint_watcher, global_sigterm_watcher
error = super(LibuvConnection, self)._adapter_connect()
if not error:
if self._on_signal_callback and not global_sigterm_watcher:
global_sigint_watcher = pyuv.Signal(self.ioloop)
if self._on_signal_callback and not global_sigint_watcher:
global_sigterm_watcher = pyuv.Signal(self.ioloop)
if not self._io_watcher:
self._io_watcher = pyuv.Poll(self.ioloop, self.socket.fileno())
self._io_watcher.fd = self.socket.fileno()
self. async = pyuv.Async(self.ioloop, self._noop_callable())
self. async .send()
if self._on_signal_callback:
global_sigterm_watcher.start(signal.SIGTERM,
self._handle_sigterm)
global_sigint_watcher.start(signal.SIGINT, self._handle_sigint)
self._io_watcher.start(self._PIKA_TO_LIBUV_ARRAY[self.event_state],
self._handle_events)
return error
def _update(self, f, mode, handler=None):
def uvcallback(watcher, revents, error):
event = 0
if error:
event = POLL_ERR
else:
if revents & pyuv.UV_READABLE:
event |= POLL_IN
if revents & pyuv.UV_WRITABLE:
event |= POLL_OUT
handler = self._wahtch2handler[watcher]
try:
fd = watcher.fileno()
handler.handle_event(self._fd2sock[fd], fd, event)
except (OSError, IOError) as e:
shell.print_exception(e)
fd = f.fileno()
uvmode = 0
if mode & POLL_IN:
uvmode |= pyuv.UV_READABLE
if mode & POLL_OUT:
uvmode |= pyuv.UV_WRITABLE
if handler is None:
watcher = self._fd2wahtch[fd]
watcher.start(uvmode, uvcallback)
else:
watcher = pyuv.Poll(self.loop, fd)
watcher.start(uvmode, uvcallback)
self._fd2wahtch[fd] = watcher
self._wahtch2handler[watcher] = handler
self._fd2sock[fd] = f
def __init__(self, loop, fd):
# 创建一个 Poll 类的实例，须提供事件循环对象和套接字的文件描述符作为参数
# 该实例有一个 start 方法，提供事件常数和回调函数即可调用此方法
# 执行此方法后，loop 对象就会注册监听此套接字的相关事件
self.poll = pyuv.Poll(loop.loop, fd)
# 回调函数，即当前协程的 switch 方法
# 上面已经介绍，调用 Poll 实例的 start 方法时会将这个回调函数作为参数
self.callback = greenlet.getcurrent().switch
def __init__(self, sock, address, loop):
self.sock = sock
self.address = address
self.sock.setblocking(0)
self.buf = ""
self.watcher = pyuv.Poll(loop, self.sock.fileno())
self.watcher.start(pyuv.UV_READABLE, self.io_cb)
logging.debug("{0}: ready".format(self))
def __init__(self, address):
self.sock = socket.socket()
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind(address)
self.sock.setblocking(0)
self.address = self.sock.getsockname()
self.loop = pyuv.Loop.default_loop()
self.poll_watcher = pyuv.Poll(self.loop, self.sock.fileno())
self.async = pyuv.Async(self.loop, self.async_cb)
self.conns = weakref.WeakValueDictionary()
self.signal_watchers = set()
def add_handler(self, fd, handler, events):
if fd in self._handlers:
raise IOError("fd %d already registered" % fd)
poll = pyuv.Poll(self._loop, fd)
self._handlers[fd] = (poll, stack_context.wrap(handler))
poll_events = 0
if (events & IOLoop.READ):
poll_events |= pyuv.UV_READABLE
if (events & IOLoop.WRITE):
poll_events |= pyuv.UV_WRITABLE
poll.start(poll_events, self._handle_poll_events)
def accept(self):
""" start the accept loop. Let the OS handle accepting balancing
between listeners """
if self.poller is None:
self.poller = pyuv.Poll(self.uv.loop, self.fd)
self.poller.start(pyuv.UV_READABLE, self._on_read)
listener = Listener()
self.listeners.append(listener)
return listener.c.receive()
def add_handler(self, fd, handler, events):
fd, obj = self.split_fd(fd)
if fd in self._handlers:
raise IOError("fd %d already registered" % fd)
poll = pyuv.Poll(self._loop, fd)
poll.handler = stack_context.wrap(handler)
self._handlers[fd] = poll
poll_events = 0
if events & IOLoop.READ:
poll_events |= pyuv.UV_READABLE
if events & IOLoop.WRITE:
poll_events |= pyuv.UV_WRITABLE
poll.start(poll_events, self._handle_poll_events)
def connect(self, broker_ip, broker_port=1883):
super(M2mipc, self).connect(broker_ip, broker_port)
if self.socket():
loop = self._uv_loop
poll = uv.Poll(loop, self.socket().fileno())
poll.start(uv.UV_READABLE, self._on_uv_poll)
self._uv_poll = poll
timer = uv.Timer(loop)
timer.start(self._on_uv_timer, 1, 1)
self._uv_timer = timer
else:
raise Exception("Connect to broker failed.")
def __init__(self):
# main event loop
self.loop = pyuv.Loop.default_loop()
# set up Ctrl-C to exit
pyuv.Signal(self.loop).start(self.sigint_callback, signal.SIGINT)
self.ds4_init()
self.wheelchair_js_init()
self.drone_controller_init()
self.ds4_poll_handle = pyuv.Poll(self.loop, self.ds4.fd).start(
pyuv.UV_READABLE, self.ds4_callback)
self.wheelchair_js_poll_handle = pyuv.Poll(
self.loop,
self.wheelchair_js.fd).start(pyuv.UV_READABLE,
self.wheelchair_js_callback)
self.idle_handle = pyuv.Idle(self.loop).start(self.idle_callback)
# Start with PS4 controller (DualShock 4) overriding wheelchair joystick
self.override = True
# Assume wheelchair joystick starts off centered
self.wheelchair_X_centered = self.wheelchair_Y_centered = True
def __init__(self, loop, fd):
self.loop = loop
try:
poll = loop._poll_handles[fd]
except KeyError:
poll = pyuv.Poll(loop, fd)
poll._count = 0
poll._events = 0
poll._readers = []
poll._writers = []
loop._poll_handles[fd] = poll
poll._count += 1
self._poll = poll
self._events = 0
self._callback = None
self._closed = False
def test_poll(self):
self.server = pyuv.TCP(self.loop)
self.server.bind(("0.0.0.0", TEST_PORT))
self.server.listen(self.on_connection)
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.setblocking(False)
while True:
r = self.sock.connect_ex(("127.0.0.1", TEST_PORT))
if r and r != errno.EINTR:
break
if r not in NONBLOCKING:
self.server.close()
self.fail("Error connecting socket: %d" % r)
return
self.connecting = True
self.poll = pyuv.Poll(self.loop, self.sock.fileno())
self.poll.start(pyuv.UV_WRITABLE, self.poll_cb)
self.loop.run()
def _sock_state_cb(self, fd, readable, writable):
if readable or writable:
if fd not in self._fd_map:
# New socket
handle = pyuv.Poll(self.loop, fd)
handle.fd = fd
self._fd_map[fd] = handle
else:
handle = self._fd_map[fd]
if not self._timer.active:
self._timer.start(self._timer_cb, 1.0, 1.0)
handle.start(pyuv.UV_READABLE if readable else 0 | pyuv.UV_WRITABLE if writable else 0, self._poll_cb)
else:
# Socket is now closed
handle = self._fd_map.pop(fd)
handle.close()
if not self._fd_map:
self._timer.stop()
def addWriter(self, writer):
if writer in self._writers:
return
fd = writer.fileno()
self._writers[writer] = fd
if fd in self._fds:
reader, _ = self._fds[fd]
self._fds[fd] = (reader, writer)
if reader:
# We already registered this fd for read events,
# update it for write events as well.
poll_handle = self._poll_handles[fd]
poll_handle.start(pyuv.UV_READABLE | pyuv.UV_WRITABLE,
self._invoke_callback)
else:
self._fds[fd] = (None, writer)
poll_handle = pyuv.Poll(self._loop, fd)
poll_handle.start(pyuv.UV_WRITABLE, self._invoke_callback)
self._poll_handles[fd] = poll_handle
def addReader(self, reader):
if reader in self._readers:
# Don't add the reader if it's already there
return
fd = reader.fileno()
self._readers[reader] = fd
if fd in self._fds:
_, writer = self._fds[fd]
self._fds[fd] = (reader, writer)
if writer:
# We already registered this fd for write events,
# update it for read events as well.
poll_handle = self._poll_handles[fd]
poll_handle.start(pyuv.UV_READABLE | pyuv.UV_WRITABLE,
self._invoke_callback)
else:
self._fds[fd] = (reader, None)
poll_handle = pyuv.Poll(self._loop, fd)
poll_handle.start(pyuv.UV_READABLE, self._invoke_callback)
self._poll_handles[fd] = poll_handle
def _watch_read(self):
self._lock.acquire()
if not self.rpoller:
self.rpoller = pyuv.Poll(self.uv.loop, self.client.fileno())
self.rpoller.start(pyuv.UV_READABLE, self._on_read)
# increase the reader refcount
self.ncr += 1
self._lock.release()
try:
self.cr.receive()
finally:
self._lock.acquire()
# decrease the refcount
self.ncr -= 1
# if no more waiters, close the poller
if self.ncr <= 0:
self.rpoller.stop()
self.rpoller = None
self._lock.release()
def _watch_write(self):
self._lock.acquire()
# create a new poller
if not self.wpoller:
self.wpoller = pyuv.Poll(self.uv.loop, self.client.fileno())
self.wpoller.start(pyuv.UV_WRITABLE, self._on_write)
# increase the writer refcount
self.ncw += 1
self._lock.release()
try:
self.cw.receive()
finally:
self._lock.acquire()
self.ncw -= 1
if self.ncw <= 0:
self.wpoller.stop()
self.wpoller = None
self._lock.release()
def _sock_state_cb(fd, readable, writable):
if readable or writable:
if fd not in _fd_map:
# New socket
handle = pyuv.Poll(self.loop, fd)
handle.fd = fd
_fd_map[fd] = handle
else:
handle = _fd_map[fd]
if not _timer.active:
_timer.start(_timer_cb, 1.0, 1.0)
flags = 0
if readable:
flags |= pyuv.UV_READABLE
if writable:
flags |= pyuv.UV_WRITABLE
handle.start(flags, _poll_cb)
else:
# Socket is now closed
handle = _fd_map.pop(fd)
handle.close()
if not _fd_map:
_timer.stop()
def _create_poll_handle(self, fdobj):
poll_h = pyuv.Poll(self._loop, self._fileobj_to_fd(fdobj))
poll_h.pevents = 0
poll_h.read_handler = None
poll_h.write_handler = None
return poll_h
def add_write_stream(self, stream, listener):
key = hash(stream)
if key not in self.write_streams:
uv_poll = libuv.Poll(self.uv_loop, stream.fileno())
uv_poll.start(libuv.UV_WRITABLE, lambda *args: listener(stream))
self.write_streams[key] = uv_poll
def _create_poll_handle(self, fd):
poll_h = pyuv.Poll(self._loop, fd)
poll_h.pevents = 0
poll_h.read_handler = None
poll_h.write_handler = None
return poll_h