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 __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 __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_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)
def start_accepting(self):
if self._accept_event is None:
self._accept_event = core.read_event(self.socket.fileno(), self._do_accept, 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)
