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 test_async2(self):
self.prepare_cb_called = 0
self.check_cb_called = 0
def prepare_cb(prepare):
self.prepare_cb_called += 1
self.thread = threading.Thread(target=thread_cb)
self.thread.start()
def check_cb(check):
self.check_cb_called += 1
self.loop.stop()
def thread_cb():
time.sleep(0.01)
self. async .send()
self. async = pyuv.Async(self.loop)
self.prepare = pyuv.Prepare(self.loop)
self.prepare.start(prepare_cb)
self.check = pyuv.Check(self.loop)
self.check.start(check_cb)
self.loop.run()
self.assertEqual(self.prepare_cb_called, 1)
self.assertEqual(self.check_cb_called, 1)
def test_async1(self):
self.async_cb_called = 0
self.prepare_cb_called = 0
def async_cb(async):
with self.lock:
self.async_cb_called += 1
n = self.async_cb_called
if n == 3:
self.async.close()
self.prepare.close()
def prepare_cb(prepare):
if self.prepare_cb_called:
return
self.prepare_cb_called += 1
self.thread = threading.Thread(target=thread_cb)
self.thread.start()
def thread_cb():
while True:
with self.lock:
n = self.async_cb_called
if n == 3:
break
self.async.send()
self.async = pyuv.Async(self.loop, async_cb)
self.prepare = pyuv.Prepare(self.loop)
self.prepare.start(prepare_cb)
self.lock = threading.Lock()
self.loop.run()
self.assertEqual(self.async_cb_called, 3)
self.assertEqual(self.prepare_cb_called, 1)
def test_stop(self):
self.num_ticks = 10
self.prepare_called = 0
self.timer_called = 0
def timer_cb(handle):
self.timer_called += 1
if self.timer_called == 1:
self.loop.stop()
elif self.timer_called == self.num_ticks:
handle.close()
def prepare_cb(handle):
self.prepare_called += 1
if self.prepare_called == self.num_ticks:
handle.close()
timer = pyuv.Timer(self.loop)
timer.start(timer_cb, 0.1, 0.1)
prepare = pyuv.Prepare(self.loop)
prepare.start(prepare_cb)
self.loop.run(pyuv.UV_RUN_DEFAULT)
self.assertEqual(self.timer_called, 1)
self.assertTrue(self.prepare_called >= 2)
self.loop.run(pyuv.UV_RUN_NOWAIT)
self.assertTrue(self.prepare_called >= 3)
self.loop.run(pyuv.UV_RUN_DEFAULT)
self.assertEqual(self.timer_called, 10)
self.assertEqual(self.prepare_called, 10)
def test_loop_alive(self):
def prepare_cb(handle):
self.assertEqual(self.loop.alive, 1)
handle.close()
prepare = pyuv.Prepare(self.loop)
prepare.start(prepare_cb)
self.loop.run(pyuv.UV_RUN_ONCE)
def __init__(self, loop):
self.loop = loop
self._queue = deque()
self._dispatcher = pyuv.Prepare(self.loop)
self._dispatcher.start(self._send)
if hasattr(self._dispatcher, 'unref'):
self._dispatcher.unref()
self._tick = pyuv.Async(loop, self._spin_up)
self._spinner = pyuv.Idle(self.loop)
def test_prepare1(self):
self.prepare_cb_called = 0
def prepare_cb(prepare):
self.prepare_cb_called += 1
prepare.stop()
prepare.close()
prepare = pyuv.Prepare(self.loop)
prepare.start(prepare_cb)
self.loop.run()
self.assertEqual(self.prepare_cb_called, 1)
def test_run_once(self):
self.cb_called = 0
def prepare_cb(handle):
handle.close()
self.cb_called += 1
for i in range(500):
prepare = pyuv.Prepare(self.loop)
prepare.start(prepare_cb)
self.loop.run(pyuv.UV_RUN_ONCE)
self.assertEqual(self.cb_called, 500)
def __init__(self, loop, max_size=10000):
self.loop = loop
self._events = {}
self._wildcards = set()
self._queue = deque(maxlen=max_size)
self._wqueue = deque(maxlen=max_size)
self._event_dispatcher = pyuv.Prepare(self.loop)
self._event_dispatcher.start(self._send)
self._event_dispatcher.unref()
self._spinner = pyuv.Idle(self.loop)
def test_poll1(self):
self.cb_called = 0
def prepare_cb(handle):
handle.close()
self.cb_called += 1
loop = pyuv.Loop.default_loop()
for i in range(500):
prepare = pyuv.Prepare(loop)
prepare.start(prepare_cb)
loop.poll()
self.assertEqual(self.cb_called, 500)
def initialize(self):
self._loop = pyuv.Loop().default_loop()
self._handlers = {}
self._callbacks = []
self._callback_lock = thread.allocate_lock()
self._timeouts = set()
self._stopped = False
self._closing = False
self._thread_ident = None
self._cb_handle = pyuv.Prepare(self._loop)
self._cb_handle.start(self._prepare_cb)
self._waker = Waker(self._loop)
self._fdwaker = FDWaker()
self._signal_checker = pyuv.util.SignalChecker(self._loop, self._fdwaker.reader.fileno())
def __init__(self, impl=None, _loop=None):
if impl is not None:
raise RuntimeError(
'When using pyuv the poller implementation cannot be specifiedi'
)
self._loop = _loop or pyuv.Loop()
self._handlers = {}
self._callbacks = deque()
self._callback_lock = thread.allocate_lock()
self._timeouts = set()
self._running = False
self._stopped = False
self._thread_ident = None
self._cb_handle = pyuv.Prepare(self._loop)
self._waker = Waker(self._loop)
def test_multihandle1(self):
self.close_cb_called = 0
self.prepare_cb_called = 0
def close_cb(handle):
self.close_cb_called += 1
def prepare_cb(prepare):
self.prepare_cb_called += 1
prepare.stop()
prepare.close(close_cb)
self.idle_cb_called = 0
def idle_cb(idle):
self.idle_cb_called += 1
idle.stop()
idle.close(close_cb)
self.check_cb_called = 0
def check_cb(check):
self.check_cb_called += 1
check.stop()
check.close(close_cb)
self.timer_cb_called = 0
def timer_cb(timer):
self.timer_cb_called += 1
timer.stop()
timer.close(close_cb)
loop = pyuv.Loop.default_loop()
prepare = pyuv.Prepare(loop)
prepare.start(prepare_cb)
idle = pyuv.Idle(loop)
idle.start(idle_cb)
check = pyuv.Check(loop)
check.start(check_cb)
timer = pyuv.Timer(loop)
timer.start(timer_cb, 0.1, 0)
loop.run()
self.assertEqual(self.prepare_cb_called, 1)
self.assertEqual(self.idle_cb_called, 1)
self.assertEqual(self.check_cb_called, 1)
self.assertEqual(self.close_cb_called, 4)
def initialize(self, loop=None, **kwargs):
super(UVLoop, self).initialize(**kwargs)
self._loop = loop or pyuv.Loop()
self._handlers = {}
self._callbacks = []
self._callback_lock = thread.allocate_lock()
#TODO: handle timeouts better
self._timeouts = set()
self._stopped = False
self._running = False
self._closing = False
self._thread_ident = None
self._cb_handle = pyuv.Prepare(self._loop)
self._cb_handle.start(self._prepare_cb)
self._waker = Waker(self._loop)
self._fdwaker = FDWaker()
self._signal_checker = pyuv.util.SignalChecker(
self._loop, self._fdwaker.reader.fileno())
def __init__(self, flags=None, default=True):
if default:
self._loop = pyuv.Loop.default_loop()
else:
self._loop = pyuv.Loop()
self._loop._poll_handles = {}
self._loop.excepthook = functools.partial(self.handle_error, None)
self._callback_watcher = pyuv.Prepare(self._loop)
self._callback_spinner = pyuv.Idle(self._loop)
self._callbacks = []
self._child_watchers = {}
self._watchers = set()
self._sigchld_handle = None
if _signal_check_rfd is not None:
self._signal_checker = pyuv.util.SignalChecker(self._loop, _signal_check_rfd)
self._signal_checker.start()
else:
self._signal_checker = None
def __init__(self, loop, ref=True):
super(Prepare, self).__init__(loop, ref)
self._handle = pyuv.Prepare(self.loop._loop)
import pyuv
import signal
import socket
reader, writer = socket.socketpair()
reader.setblocking(False)
writer.setblocking(False)
loop = pyuv.Loop.default_loop()
prepare = pyuv.Prepare(loop)
signal_checker = pyuv.util.SignalChecker(loop, reader.fileno())
def prepare_cb(handle):
print('Inside prepare_cb()')
def excepthook(typ, val, tb):
print('Inside excepthook()')
if typ is KeyboardInterrupt:
print('The type was KeyboardInterrupt')
prepare.stop()
signal_checker.stop()
def main():
loop.excepthook = excepthook
prepare.start(prepare_cb)
signal.set_wakeup_fd(writer.fileno())
