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