def test_io(self): if sys.platform == 'win32': Error = IOError else: Error = ValueError self.assertRaises(Error, core.loop().io, -1, 1) self.assertRaises(ValueError, core.loop().io, 1, core.TIMER)
def test_io(self): if sys.platform == 'win32': # libev raises IOError, libuv raises ValueError Error = (IOError, ValueError) win32 = True else: Error = ValueError win32 = False with self.assertRaises(Error): core.loop().io(-1, 1) if hasattr(core, 'TIMER'): # libev with self.assertRaises(ValueError): core.loop().io(1, core.TIMER) # Test we can set events and io before it's started if not win32: # We can't do this with arbitrary FDs on windows; # see libev_vfd.h io = core.loop().io(1, core.READ) io.fd = 2 self.assertEqual(io.fd, 2) io.events = core.WRITE if not hasattr(core, 'libuv'): # libev self.assertEqual(core._events_to_str(io.events), 'WRITE|_IOFDSET') else: self.assertEqual(core._events_to_str(io.events), 'WRITE') io.close()
def test_flags_conversion(self): if sys.platform != 'win32': self.assertEqual(core.loop(2, default=False).backend_int, 2) self.assertEqual(core.loop('select', default=False).backend, 'select') self.assertEqual(core._flags_to_int(None), 0) self.assertEqual(core._flags_to_int(['kqueue', 'SELECT']), core.BACKEND_KQUEUE | core.BACKEND_SELECT) self.assertEqual(core._flags_to_list(core.BACKEND_PORT | core.BACKEND_POLL), ['port', 'poll']) self.assertRaises(ValueError, core.loop, ['port', 'blabla']) self.assertRaises(TypeError, core.loop, object())
def test_flags_conversion(self): # pylint: disable=no-member if not greentest.WIN: self.assertEqual(core.loop(2, default=False).backend_int, 2) self.assertEqual(core.loop('select', default=False).backend, 'select') self.assertEqual(core._flags_to_int(None), 0) self.assertEqual(core._flags_to_int(['kqueue', 'SELECT']), core.BACKEND_KQUEUE | core.BACKEND_SELECT) self.assertEqual( core._flags_to_list(core.BACKEND_PORT | core.BACKEND_POLL), ['port', 'poll']) self.assertRaises(ValueError, core.loop, ['port', 'blabla']) self.assertRaises(TypeError, core.loop, object())
def run(self): """ 注册master和branch协程 启动loop,监听接入层请求,监听旁路回包 接入层入口 self.master_watch 旁路入口 self.branch_watch :return: 注册失败则程序推出 """ l = loop() # 注册master处理方法 try: io = l.io(self.master_sock.fileno(), 1) # 1代表read io.start(self.master_watch) except Exception as e: g_log.critical("error: %s", e) sys.exit(-1) g_log.debug("register master coroutine self.master_watch done ...") # 注册旁路处理方法 for handler in self.branch_handler: try: sock = handler["sock"] io = l.io(sock.fileno(), 1) io.start(self.branch_watch(handler["name"])) except Exception as e: g_log.critical("error:", e) sys.exit(-1) g_log.debug("register branch %s coroutine self.branch_watch done ...", handler["name"]) g_log.debug("register branch coroutine done ...") # 启动libev loop g_log.debug("now start event loop...") l.run()
def test_invalid_fd(self): loop = core.loop(default=False) # Negative case caught everywhere. ValueError # on POSIX, OSError on Windows Py3, IOError on Windows Py2 with self.assertRaises((ValueError, OSError, IOError)): loop.io(-1, core.READ) loop.destroy()
def test_io(self): if sys.platform == 'win32': Error = IOError win32 = True else: Error = ValueError win32 = False self.assertRaises(Error, core.loop().io, -1, 1) self.assertRaises(ValueError, core.loop().io, 1, core.TIMER) # Test we can set events and io before it's started if not win32: # We can't do this with arbitrary FDs on windows; # see libev_vfd.h io = core.loop().io(1, core.READ) io.fd = 2 self.assertEqual(io.fd, 2) io.events = core.WRITE self.assertEqual(core._events_to_str(io.events), 'WRITE|_IOFDSET')
def test_types(self): loop = core.loop() lst = [] io = loop.timer(0.01) # test that cannot pass non-callable thing to start() self.assertRaises(TypeError, io.start, None) self.assertRaises(TypeError, io.start, 5) # test that cannot set 'callback' to non-callable thing later either io.start(lambda *args: lst.append(args)) self.assertEqual(io.args, ()) try: io.callback = False raise AssertionError('"io.callback = False" must raise TypeError') except TypeError: pass try: io.callback = 5 raise AssertionError('"io.callback = 5" must raise TypeError') except TypeError: pass # test that args can be changed later io.args = (1, 2, 3) if greentest.PYPY: pass # on PYPY .args is just a normal property else: # test that only tuple and None are accepted by 'args' attribute try: io.args = 5 raise AssertionError('"io.args = 5" must raise TypeError') except TypeError: pass self.assertEqual(io.args, (1, 2, 3)) try: io.args = [4, 5] raise AssertionError('"io.args = [4, 5]" must raise TypeError') except TypeError: pass self.assertEqual(io.args, (1, 2, 3)) if greentest.PYPY: io.args = () else: # None also works, means empty tuple # XXX why? io.args = None start = core.time() loop.run() took = core.time() - start self.assertEqual(lst, [()]) assert took < 1, took io.start(reset, io, lst) del io loop.run() self.assertEqual(lst, [(), 25])
def test_types(self): loop = core.loop(default=False) lst = [] io = loop.timer(0.01) # test that cannot pass non-callable thing to start() self.assertRaises(TypeError, io.start, None) self.assertRaises(TypeError, io.start, 5) # test that cannot set 'callback' to non-callable thing later either io.start(lambda *args: lst.append(args)) self.assertEqual(io.args, ()) try: io.callback = False raise AssertionError('"io.callback = False" must raise TypeError') except TypeError: pass try: io.callback = 5 raise AssertionError('"io.callback = 5" must raise TypeError') except TypeError: pass # test that args can be changed later io.args = (1, 2, 3) # test that only tuple and None are accepted by 'args' attribute self.assertRaises(TypeError, setattr, io, 'args', 5) self.assertEqual(io.args, (1, 2, 3)) self.assertRaises(TypeError, setattr, io, 'args', [4, 5]) self.assertEqual(io.args, (1, 2, 3)) # None also works, means empty tuple # XXX why? io.args = None self.assertEqual(io.args, None) time_f = getattr(core, 'time', loop.now) start = time_f() loop.run() took = time_f() - start self.assertEqual(lst, [()]) if hasattr(core, 'time'): # only useful on libev assert took < 1, took io.start(reset, io, lst) del io loop.run() self.assertEqual(lst, [(), 25]) loop.destroy()
def test_types(self): loop = core.loop() lst = [] io = loop.timer(0.01) # test that cannot pass non-callable thing to start() self.assertRaises(TypeError, io.start, None) self.assertRaises(TypeError, io.start, 5) # test that cannot set 'callback' to non-callable thing later either io.start(lambda *args: lst.append(args)) self.assertEqual(io.args, ()) try: io.callback = None raise AssertionError('"io.callback = None" must raise TypeError') except TypeError: pass try: io.callback = 5 raise AssertionError('"io.callback = 5" must raise TypeError') except TypeError: pass # test that args can be changed later io.args = (1, 2, 3) # test that only tuple and None are accepted by 'args' attribute try: io.args = 5 raise AssertionError('"io.args = 5" must raise TypeError') except TypeError: pass self.assertEqual(io.args, (1, 2, 3)) try: io.args = [4, 5] raise AssertionError('"io.args = [4, 5]" must raise TypeError') except TypeError: pass self.assertEqual(io.args, (1, 2, 3)) # None also works, means empty tuple io.args = None loop.run() self.assertEqual(lst, [()]) io.start(reset, io, lst) del io loop.run() self.assertEqual(lst, [(), 25])
def test_reuse_io(self): loop = core.loop(default=False) # Watchers aren't reused once all outstanding # refs go away tty_watcher = loop.io(1, core.WRITE) watcher_handle = tty_watcher._watcher if IS_CFFI else tty_watcher del tty_watcher # XXX: Note there is a cycle in the CFFI code # from watcher_handle._handle -> watcher_handle. # So it doesn't go away until a GC runs. import gc gc.collect() tty_watcher = loop.io(1, core.WRITE) self.assertIsNot(tty_watcher._watcher if IS_CFFI else tty_watcher, watcher_handle) loop.destroy()
def main(): loop = core.loop(default=True) x = loop.timer(0.001) x.start(f) assert x.active, x.pending try: x.priority = 1 raise AssertionError('must not be able to change priority of active watcher') except AttributeError: pass loop.run() assert x.pending == 0, x.pending assert called == [1], called assert x.callback is None, x.callback assert x.args is None, x.args assert x.priority == 0, x x.priority = 1 assert x.priority == 1, x x.stop()
def main(): loop = core.loop(default=True) x = loop.timer(0.001) x.start(f) if hasattr(loop, '_keepaliveset'): assert x in loop._keepaliveset assert x.active, ("active", x.active, "pending", x.pending) try: x.priority = 1 raise AssertionError( 'must not be able to change priority of active watcher') except (AttributeError, ValueError): pass loop.run() assert x.pending == 0, x.pending assert called == [1], called assert x.callback is None, x.callback assert x.args is None, x.args if x.priority is not None: assert x.priority == 0, (x, x.priority) x.priority = 1 assert x.priority == 1, x x.stop() if hasattr(loop, '_keepaliveset'): assert x not in loop._keepaliveset # Again works for a new timer x = loop.timer(0.001, repeat=1) x.again(f, x) if hasattr(loop, '_keepaliveset'): assert x in loop._keepaliveset assert x.args == (x, ), x.args loop.run() assert called == [1, 1], called x.stop() if hasattr(loop, '_keepaliveset'): assert x not in loop._keepaliveset
def main(): loop = core.loop(default=True) x = loop.timer(0.001) x.start(f) if hasattr(loop, '_keepaliveset'): assert x in loop._keepaliveset assert x.active, x.pending try: x.priority = 1 raise AssertionError('must not be able to change priority of active watcher') except AttributeError: pass loop.run() assert x.pending == 0, x.pending assert called == [1], called assert x.callback is None, x.callback assert x.args is None, x.args assert x.priority == 0, x x.priority = 1 assert x.priority == 1, x x.stop() if hasattr(loop, '_keepaliveset'): assert x not in loop._keepaliveset # Again works for a new timer x = loop.timer(0.001, repeat=1) x.again(f, x) if hasattr(loop, '_keepaliveset'): assert x in loop._keepaliveset assert x.args == (x,), x.args loop.run() assert called == [1, 1], called x.stop() if hasattr(loop, '_keepaliveset'): assert x not in loop._keepaliveset
def test_flags_conversion(self): if sys.platform != 'win32': self.assertEqual(core.loop(2, default=False).backend_int, 2) self.assertEqual(core.loop('select', default=False).backend, 'select') self.assertEqual(core._flags_to_int(None), 0) self.assertEqual(core._flags_to_int(['kqueue', 'SELECT']), core.BACKEND_KQUEUE | core.BACKEND_SELECT) self.assertEqual(core._flags_to_list(core.BACKEND_PORT | core.BACKEND_POLL), ['port', 'poll']) try: core.loop(['port', 'blabla']) except ValueError as ex: if sys.version_info[0] > 2: ex.__traceback__ = None else: raise AssertionError("ValueError is not raised") try: core.loop(object()) except TypeError as ex: if sys.version_info[0] > 2: ex.__traceback__ = None else: raise AssertionError("TypeError is not raised")
def test_flags_conversion(self): if sys.platform != 'win32': self.assertEqual(core.loop(2, default=False).backend_int, 2) self.assertEqual(core.loop('select', default=False).backend, 'select') self.assertEqual(core._flags_to_int(None), 0) self.assertEqual(core._flags_to_int(['kqueue', 'SELECT']), core.BACKEND_KQUEUE | core.BACKEND_SELECT) self.assertEqual( core._flags_to_list(core.BACKEND_PORT | core.BACKEND_POLL), ['port', 'poll']) try: core.loop(['port', 'blabla']) except ValueError as ex: if sys.version_info[0] > 2: ex.__traceback__ = None else: raise AssertionError("ValueError is not raised") try: core.loop(object()) except TypeError as ex: if sys.version_info[0] > 2: ex.__traceback__ = None else: raise AssertionError("TypeError is not raised")
# test for issue #210 from gevent import core from gevent.testing.util import alarm alarm(1) log = [] loop = core.loop(default=False) loop.run_callback(log.append, 1) loop.run() assert log == [1], log
import sys from gevent import core, signal loop = core.loop() signal = signal(2, sys.stderr.write, 'INTERRUPT!') print ('must exit immediatelly...') loop.run() # must exit immediatelly print ('...and once more...') loop.run() # repeating does not fail print ('..done') print ('must exit after 0.5 seconds.') timer = loop.timer(0.5) timer.start(lambda: None) loop.run() del loop
def test_signal(self): self.assertRaises(ValueError, core.loop().signal, 1000)
def test_timer(self): self.assertRaises(ValueError, core.loop().timer, 1, -1)
for r in wl: r.send('hello world\r\n') r.close() wlist.remove(r) 4.gevent loop使用 import socket import gevent from gevent.core import loop def f(): s, address = sock.accept() print address s.send("hello world\r\n") loop = loop() sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM) sock.bind(("localhost",8000)) sock.listen(10) io = loop.io(sock.fileno(),1) #1代表read io.start(f) loop.run() 5.gevent recv流程 gevent的socket对象被gevent重新封装,原始socket就是下面的self._sock 我们来看看gevent的socket一次recv做了什么操作。 def recv(self, *args): sock = self._sock # keeping the reference so that fd is not closed during waiting while True: try:
def test_timer_constructor(self): with self.assertRaises(ValueError): core.loop().timer(1, -1)
def _makeOne(self): # pylint: disable=no-member l = core.loop(default=True) l.destroy() del l return core.loop(default=True)
from __future__ import print_function import sys from gevent import core from gevent import signal_handler as signal loop = core.loop(default=False) signal = signal(2, sys.stderr.write, 'INTERRUPT!') print('must exit immediately...') loop.run() # must exit immediately print('...and once more...') loop.run() # repeating does not fail print('..done') print('must exit after 0.5 seconds.') timer = loop.timer(0.5) timer.start(lambda: None) loop.run() timer.close() loop.destroy() del loop
def setUp(self): self.called = [] self.loop = core.loop(default=True) self.timer = self.loop.timer(0.001, repeat=self.repeat)
def _makeOne(self): return core.loop() # pylint:disable=no-member
def __init__(self, connection): self._conn = connection self._buf = "" self.watcher = loop(connection.fileno(), 1) self.watcher.start(self.handle)
def _makeOne(self): return core.loop(default=True) # pylint:disable=no-member
from gevent.core import loop count = 0 def incr(): global count count += 1 loop = loop() loop.callback().start(incr) loop.run() assert count == 1, count
def test_signal_constructor(self): with self.assertRaises(ValueError): core.loop().signal(1000)
from gevent.core import loop count = 0 def incr(): global count count += 1 loop = loop() loop.run_callback(incr) loop.run() assert count == 1, count
from __future__ import print_function import sys from gevent import core, signal loop = core.loop() signal = signal(2, sys.stderr.write, 'INTERRUPT!') print('must exit immediatelly...') loop.run() # must exit immediatelly print('...and once more...') loop.run() # repeating does not fail print('..done') print('must exit after 0.5 seconds.') timer = loop.timer(0.5) timer.start(lambda: None) loop.run() del loop