def __setup_events(self): self.__readable = Event() self.__writable = Event() try: read_event = get_hub().reactor.read_event self._state_event = read_event(self.getsockopt(zmq.FD), persist=True) self._state_event.add(None, self.__state_changed) except AttributeError: # for gevent<=0.14 compatibility from gevent.core import read_event self._state_event = read_event(self.getsockopt(zmq.FD), self.__state_changed, persist=True)
def select(rlist, wlist, xlist, timeout=None): """An implementation of :meth:`select.select` that blocks only the current greenlet. Note: *xlist* is ignored. """ hub = get_hub() current = getcurrent() assert hub is not current, 'do not call blocking functions from the mainloop' allevents = [] timeout = Timeout.start_new(timeout) try: try: for readfd in rlist: allevents.append( core.read_event(get_fileno(readfd), _select_callback, arg=(current, readfd))) for writefd in wlist: allevents.append( core.write_event(get_fileno(writefd), _select_callback, arg=(current, writefd))) except IOError, ex: raise error(*ex.args) try: result = hub.switch() except Timeout, ex: if ex is not timeout: raise return [], [], []
def wait_read(fileno, timeout=-1, timeout_exc=_socket.timeout('timed out')): evt = core.read_event(fileno, _wait_helper, timeout, (getcurrent(), timeout_exc)) try: switch_result = get_hub().switch() assert evt is switch_result, 'Invalid switch into wait_read(): %r' % (switch_result, ) finally: evt.cancel()
def wait_read(fileno, timeout=-1): evt = read_event(fileno, _wait_helper, timeout, getcurrent()) try: switch_result = get_hub().switch() assert evt is switch_result, 'Invalid switch into wait_read(): %r' % (switch_result, ) finally: evt.cancel()
def __init__(self, address=("127.0.0.1", 2011)): self.cli_sock = create_connection(address) if self.cli_sock: self.accept_event = core.read_event(self.cli_sock.fileno(), self.do_read, persist=True)
def _start_receiving(self, _event): if self._recv_event is None: if 'socket' not in self.__dict__: return self._recv_event = core.read_event(self.socket.fileno(), self._do_recv, persist=True)
def __init__(self,uid=1,address=("127.0.0.1", 8080)): self.secret_key = "" self.uid = uid self.rid = 1 self.cli_sock = create_connection(address) if self.cli_sock: self.accept_event = core.read_event(self.cli_sock.fileno(), self.do_read, persist=True)
def wait_read(fileno, timeout=None, timeout_exc=timeout('timed out'), event=None): """Block the current greenlet until *fileno* is ready to read. If *timeout* is non-negative, then *timeout_exc* is raised after *timeout* second has passed. By default *timeout_exc* is ``socket.timeout('timed out')``. If :func:`cancel_wait` is called, raise ``socket.error(EBADF, 'File descriptor was closed in another greenlet')``. """ if event is None: event = core.read_event(fileno, _wait_helper, timeout, (getcurrent(), timeout_exc)) else: assert event.callback == _wait_helper, event.callback assert event.arg is None, 'This event is already used by another greenlet: %r' % ( event.arg, ) event.arg = (getcurrent(), timeout_exc) event.add(timeout) try: switch_result = get_hub().switch() assert event is switch_result, 'Invalid switch into wait_read(): %r' % ( switch_result, ) finally: event.cancel() event.arg = None
def __init__(self, uid=1, address=("127.0.0.1", 8080)): self.secret_key = "" self.uid = uid self.rid = 1 self.cli_sock = create_connection(address) if self.cli_sock: self.accept_event = core.read_event(self.cli_sock.fileno(), self.do_read, persist=True)
def wait_read(fileno, timeout=-1, timeout_exc=_socket.timeout('timed out')): evt = core.read_event(fileno, _wait_helper, timeout, (getcurrent(), timeout_exc)) try: switch_result = get_hub().switch() assert evt is switch_result, 'Invalid switch into wait_read(): %r' % ( switch_result, ) finally: evt.cancel()
def __setup_events(self): self.__readable = AsyncResult() self.__writable = AsyncResult() try: self._state_event = get_hub().loop.io(self.getsockopt(FD), 1) # read state watcher self._state_event.start(self.__state_changed) except AttributeError: # for gevent<1.0 compatibility from gevent.core import read_event self._state_event = read_event(self.getsockopt(FD), self.__state_changed, persist=True)
def connect(self): if self.php_sock == None: try: self.php_sock = create_connection(self.address) if self.accept_event is None: self.accept_event = core.read_event(self.php_sock.fileno(), self.do_read, persist=True) except: self.php_sock = None self.accept_event = None logging.error("can't connect to php server `%s` ", self.address) return self.php_sock != None
def select(rlist, wlist, xlist, timeout=None): """An implementation of :meth:`select.select` that blocks only the current greenlet. Note: *xlist* is ignored. """ allevents = [] timeout = Timeout.start_new(timeout) result = SelectResult() try: try: for readfd in rlist: allevents.append(core.read_event(get_fileno(readfd), result.update, arg=readfd)) for writefd in wlist: allevents.append(core.write_event(get_fileno(writefd), result.update, arg=writefd)) except IOError, ex: raise error(*ex.args) result.event.wait(timeout=timeout) return result.read, result.write, []
def wait_read(fileno, timeout=None, timeout_exc=timeout('timed out'), event=None): """Block the current greenlet until *fileno* is ready to read. If *timeout* is non-negative, then *timeout_exc* is raised after *timeout* second has passed. By default *timeout_exc* is ``socket.timeout('timed out')``. If :func:`cancel_wait` is called, raise ``socket.error(EBADF, 'File descriptor was closed in another greenlet')``. """ if event is None: event = core.read_event(fileno, _wait_helper, timeout, (getcurrent(), timeout_exc)) else: assert event.callback == _wait_helper, event.callback assert event.arg is None, 'This event is already used by another greenlet: %r' % (event.arg, ) event.arg = (getcurrent(), timeout_exc) event.add(timeout) try: switch_result = get_hub().switch() assert event is switch_result, 'Invalid switch into wait_read(): %r' % (switch_result, ) finally: event.cancel() event.arg = None
def select(rlist, wlist, xlist, timeout=None): """An implementation of :meth:`select.select` that blocks only the current greenlet. Note: *xlist* is ignored. """ allevents = [] timeout = Timeout.start_new(timeout) result = SelectResult() try: try: for readfd in rlist: allevents.append( core.read_event(get_fileno(readfd), result.update, arg=readfd)) for writefd in wlist: allevents.append( core.write_event(get_fileno(writefd), result.update, arg=writefd)) except IOError, ex: raise error(*ex.args) result.event.wait(timeout=timeout) return result.read, result.write, []
def select(rlist, wlist, xlist, timeout=None): """An implementation of :meth:`select.select` that blocks only the current greenlet. Note: *xlist* is ignored. """ hub = get_hub() current = getcurrent() assert hub is not current, 'do not call blocking functions from the mainloop' allevents = [] timeout = Timeout.start_new(timeout) try: try: for readfd in rlist: allevents.append(core.read_event(get_fileno(readfd), _select_callback, arg=(current, readfd))) for writefd in wlist: allevents.append(core.write_event(get_fileno(writefd), _select_callback, arg=(current, writefd))) except IOError, ex: raise error(*ex.args) try: result = hub.switch() except Timeout, ex: if ex is not timeout: raise return [], [], []
def _start_accepting(self, _event): if self._accept_event is None: if 'socket' not in self.__dict__: return self._accept_event = core.read_event(self.socket.fileno(), self._do_accept, persist=True)
def start_accepting(self): if self._accept_event is None: self._accept_event = core.read_event(self.socket.fileno(), self._do_accept, persist=True)