async def locate(self, permid): if not self._db: return None fur = futures.Future() def _(res): fur.set_result(toJsonObject(res)) self._db.getraw(permid, _)
def sock_connect(self, sock, address): """XXX""" # That address better not require a lookup! We're not calling # self.getaddrinfo() for you here. But verifying this is # complicated; the socket module doesn't have a pattern for # IPv6 addresses (there are too many forms, apparently). fut = futures.Future(loop=self) self._sock_connect(fut, False, sock, address) return fut
def _waitForReadyRead(self, func_name): if self._waiter is not None: raise RuntimeError('%s() called while another coroutine is ' 'already waiting for incoming data' % func_name) self._waiter = futures.Future(loop=self._loop) try: yield from self._waiter finally: self._waiter = None
def test_constructor_homogenous_futures(self): children = [futures.Future(loop=self.other_loop) for i in range(3)] fut = tasks.gather(*children) self.assertIs(fut._loop, self.other_loop) self._run_loop(self.other_loop) self.assertFalse(fut.done()) fut = tasks.gather(*children, loop=self.other_loop) self.assertIs(fut._loop, self.other_loop) self._run_loop(self.other_loop) self.assertFalse(fut.done())
def __init__(self, req): super().__init__() self._req = req self._headers = {} self.code = 200 self.body = None self.raw = None self.mime = None self._f = futures.Future() self._obj = None
def test_get_with_putters(self): q = queues.Queue(1, loop=self.loop) q.put_nowait(1) waiter = futures.Future(loop=self.loop) q._putters.append((2, waiter)) res = self.loop.run_until_complete(q.get()) self.assertEqual(1, res) self.assertTrue(waiter.done()) self.assertIsNone(waiter.result())
def test_yield_vs_yield_from(self): fut = futures.Future(loop=self.loop) @tasks.coroutine def wait_for_future(): yield fut task = wait_for_future() with self.assertRaises(RuntimeError): self.loop.run_until_complete(task) self.assertFalse(fut.done())
def mqtt_unsubscribe(self, topics, packet_id): """ :param topics: array of topics ['/a/b', ...] :return: """ unsubscribe = UnsubscribePacket.build(topics, packet_id) yield from self._send_packet(unsubscribe) waiter = futures.Future(loop=self._loop) self._unsubscriptions_waiter[unsubscribe.variable_header.packet_id] = waiter yield from waiter del self._unsubscriptions_waiter[unsubscribe.variable_header.packet_id]
def mqtt_subscribe(self, topics, packet_id): """ :param topics: array of topics [{'filter':'/a/b', 'qos': 0x00}, ...] :return: """ subscribe = SubscribePacket.build(topics, packet_id) yield from self.outgoing_queue.put(subscribe) waiter = futures.Future(loop=self._loop) self._subscriptions_waiter[ subscribe.variable_header.packet_id] = waiter return_codes = yield from waiter del self._subscriptions_waiter[subscribe.variable_header.packet_id] return return_codes
def test_exception_marking(self): # Test for the first line marked "Mark exception retrieved." @tasks.coroutine def inner(f): yield from f raise RuntimeError('should not be ignored') a = futures.Future(loop=self.one_loop) b = futures.Future(loop=self.one_loop) @tasks.coroutine def outer(): yield from tasks.gather(inner(a), inner(b), loop=self.one_loop) f = tasks. async (outer(), loop=self.one_loop) test_utils.run_briefly(self.one_loop) a.set_result(None) test_utils.run_briefly(self.one_loop) b.set_result(None) test_utils.run_briefly(self.one_loop) self.assertIsInstance(f.exception(), RuntimeError)
def test_cancel_task_catching(self): fut1 = futures.Future(loop=self.loop) fut2 = futures.Future(loop=self.loop) @tasks.coroutine def task(): yield from fut1 try: yield from fut2 except futures.CancelledError: return 42 t = tasks.Task(task(), loop=self.loop) test_utils.run_briefly(self.loop) self.assertIs(t._fut_waiter, fut1) # White-box test. fut1.set_result(None) test_utils.run_briefly(self.loop) self.assertIs(t._fut_waiter, fut2) # White-box test. t.cancel() self.assertTrue(fut2.cancelled()) res = self.loop.run_until_complete(t) self.assertEqual(res, 42) self.assertFalse(t.cancelled())
def _check_success(self, **kwargs): a, b, c = [futures.Future(loop=self.one_loop) for i in range(3)] fut = tasks.gather(*self.wrap_futures(a, b, c), **kwargs) cb = Mock() fut.add_done_callback(cb) b.set_result(1) a.set_result(2) self._run_loop(self.one_loop) self.assertEqual(cb.called, False) self.assertFalse(fut.done()) c.set_result(3) self._run_loop(self.one_loop) cb.assert_called_once_with(fut) self.assertEqual(fut.result(), [2, 1, 3])
def run_in_executor(self, executor, callback, *args): if isinstance(callback, asyncio.Handle): assert not args assert not isinstance(callback, asyncio.TimerHandle) if callback.cancelled: f = futures.Future() f.set_result(None) return f callback, args = callback.callback, callback.args if executor is None: executor = self._default_executor if executor is None: executor = concurrent.futures.ThreadPoolExecutor(_MAX_WORKERS) self._default_executor = executor return self.wrap_future(executor.submit(callback, *args))
def test_cancel_inner_future(self): f = futures.Future(loop=self.loop) @tasks.coroutine def task(): yield from f return 12 t = tasks.Task(task(), loop=self.loop) test_utils.run_briefly(self.loop) # start task f.cancel() with self.assertRaises(futures.CancelledError): self.loop.run_until_complete(t) self.assertTrue(f.cancelled()) self.assertTrue(t.cancelled())
def test_coroutine_non_gen_function_return_future(self): fut = futures.Future(loop=self.loop) @tasks.coroutine def func(): return fut @tasks.coroutine def coro(): fut.set_result('test') t1 = tasks.Task(func(), loop=self.loop) t2 = tasks.Task(coro(), loop=self.loop) res = self.loop.run_until_complete(t1) self.assertEqual(res, 'test') self.assertIsNone(t2.result())
def test_one_cancellation(self): a, b, c, d, e = [futures.Future(loop=self.one_loop) for i in range(5)] fut = tasks.gather(a, b, c, d, e) cb = Mock() fut.add_done_callback(cb) a.set_result(1) b.cancel() self._run_loop(self.one_loop) self.assertTrue(fut.done()) cb.assert_called_once_with(fut) self.assertFalse(fut.cancelled()) self.assertIsInstance(fut.exception(), futures.CancelledError) # Does nothing c.set_result(3) d.cancel() e.set_exception(RuntimeError())
def test_one_exception(self): a, b, c, d, e = [futures.Future(loop=self.one_loop) for i in range(5)] fut = tasks.gather(*self.wrap_futures(a, b, c, d, e)) cb = Mock() fut.add_done_callback(cb) exc = ZeroDivisionError() a.set_result(1) b.set_exception(exc) self._run_loop(self.one_loop) self.assertTrue(fut.done()) cb.assert_called_once_with(fut) self.assertIs(fut.exception(), exc) # Does nothing c.set_result(3) d.cancel() e.set_exception(RuntimeError())
def test_cancel_race(self): # Several tasks: # - A acquires the lock # - B is blocked in aqcuire() # - C is blocked in aqcuire() # # Now, concurrently: # - B is cancelled # - A releases the lock # # If B's waiter is marked cancelled but not yet removed from # _waiters, A's release() call will crash when trying to set # B's waiter; instead, it should move on to C's waiter. # Setup: A has the lock, b and c are waiting. lock = locks.Lock(loop=self.loop) @tasks.coroutine def lockit(name, blocker): yield from lock.acquire() try: if blocker is not None: yield from blocker finally: lock.release() fa = futures.Future(loop=self.loop) ta = tasks.Task(lockit('A', fa), loop=self.loop) test_utils.run_briefly(self.loop) self.assertTrue(lock.locked()) tb = tasks.Task(lockit('B', None), loop=self.loop) test_utils.run_briefly(self.loop) self.assertEqual(len(lock._waiters), 1) tc = tasks.Task(lockit('C', None), loop=self.loop) test_utils.run_briefly(self.loop) self.assertEqual(len(lock._waiters), 2) # Create the race and check. # Without the fix this failed at the last assert. fa.set_result(None) tb.cancel() self.assertTrue(lock._waiters[0].cancelled()) test_utils.run_briefly(self.loop) self.assertFalse(lock.locked()) self.assertTrue(ta.done()) self.assertTrue(tb.cancelled()) self.assertTrue(tc.done())
def test_task_cancel_waiter_future(self): fut = futures.Future(loop=self.loop) @tasks.coroutine def coro(): yield from fut task = tasks.Task(coro(), loop=self.loop) test_utils.run_briefly(self.loop) self.assertIs(task._fut_waiter, fut) task.cancel() test_utils.run_briefly(self.loop) self.assertRaises(futures.CancelledError, self.loop.run_until_complete, task) self.assertIsNone(task._fut_waiter) self.assertTrue(fut.cancelled())
def connect_pipe(loop, protocol_factory, name): protocol = protocol_factory() waiter = futures.Future(loop=loop) def connect_cb(handle, error): if error is not None: waiter.set_exception(ConnectionError(error, pyuv.errno.strerror(error))) else: waiter.set_result(None) handle = pyuv.Pipe(loop._loop) handle.connect(name, connect_cb) yield from waiter transport = PipeTransport(loop, protocol, handle) return transport, protocol
def mqtt_subscribe(self, topics, packet_id): """ :param topics: array of topics [{'filter':'/a/b', 'qos': 0x00}, ...] :return: """ # Build and send SUBSCRIBE message subscribe = SubscribePacket.build(topics, packet_id) yield from self._send_packet(subscribe) # Wait for SUBACK is received waiter = futures.Future(loop=self._loop) self._subscriptions_waiter[subscribe.variable_header.packet_id] = waiter return_codes = yield from waiter del self._subscriptions_waiter[subscribe.variable_header.packet_id] return return_codes
def test_return_exceptions(self): a, b, c, d = [futures.Future(loop=self.one_loop) for i in range(4)] fut = tasks.gather(*self.wrap_futures(a, b, c, d), return_exceptions=True) cb = Mock() fut.add_done_callback(cb) exc = ZeroDivisionError() exc2 = RuntimeError() b.set_result(1) c.set_exception(exc) a.set_result(3) self._run_loop(self.one_loop) self.assertFalse(fut.done()) d.set_exception(exc2) self._run_loop(self.one_loop) self.assertTrue(fut.done()) cb.assert_called_once_with(fut) self.assertEqual(fut.result(), [3, 1, exc, exc2])
def test_async_future(self): f_orig = futures.Future(loop=self.loop) f_orig.set_result('ko') f = tasks. async (f_orig) self.loop.run_until_complete(f) self.assertTrue(f.done()) self.assertEqual(f.result(), 'ko') self.assertIs(f, f_orig) loop = events.new_event_loop() with self.assertRaises(ValueError): f = tasks. async (f_orig, loop=loop) loop.close() f = tasks. async (f_orig, loop=self.loop) self.assertIs(f, f_orig)
def connect_tcp(loop, protocol_factory, addr, bindaddr=None): protocol = protocol_factory() waiter = futures.Future(loop=loop) def connect_cb(handle, error): if error is not None: waiter.set_exception(ConnectionError(error, pyuv.errno.strerror(error))) else: waiter.set_result(None) handle = pyuv.TCP(loop._loop) if bindaddr is not None: handle.bind((interface, port)) handle.connect(addr, connect_cb) yield from waiter addr = handle.getpeername() transport = TCPTransport(loop, protocol, handle, extra={'addr': addr}) return transport, protocol
def test_run_once_in_executor_plain(self): def cb(): pass h = events.Handle(cb, ()) f = futures.Future(loop=self.loop) executor = unittest.mock.Mock() executor.submit.return_value = f self.loop.set_default_executor(executor) res = self.loop.run_in_executor(None, h) self.assertIs(f, res) executor = unittest.mock.Mock() executor.submit.return_value = f res = self.loop.run_in_executor(executor, h) self.assertIs(f, res) self.assertTrue(executor.submit.called) f.cancel() # Don't complain about abandoned Future.
def test_result_exception_one_cancellation(self): a, b, c, d, e, f = [ futures.Future(loop=self.one_loop) for i in range(6) ] fut = tasks.gather(a, b, c, d, e, f, return_exceptions=True) cb = Mock() fut.add_done_callback(cb) a.set_result(1) zde = ZeroDivisionError() b.set_exception(zde) c.cancel() self._run_loop(self.one_loop) self.assertFalse(fut.done()) d.set_result(3) e.cancel() rte = RuntimeError() f.set_exception(rte) res = self.one_loop.run_until_complete(fut) self.assertIsInstance(res[2], futures.CancelledError) self.assertIsInstance(res[4], futures.CancelledError) res[2] = res[4] = None self.assertEqual(res, [1, zde, None, 3, None, rte]) cb.assert_called_once_with(fut)
def create_future(self): """Create a Future object attached to the loop. Copied from ``BaseEventLoop.create_future`` """ return futures.Future(loop=self)
def __init__(self, create_future=False): self.state = 'INITIAL' self.nbytes = 0 if create_future: self.done = futures.Future()
def mock_getaddrinfo(*args, **kwds): f = futures.Future(loop=self.loop) f.set_result([(socket.AF_INET, socket.SOCK_STREAM, socket.SOL_TCP, '', ('1.2.3.4', 80))]) return f
async def start(self): await super().start() if self._disconnect_waiter is None: self._disconnect_waiter = futures.Future(loop=self._loop)