def test_str(self): result = toro.AsyncResult() str(result) result.set('fizzle') self.assertTrue('fizzle' in str(result)) self.assertFalse('waiters' in str(result)) result = toro.AsyncResult() result.get() self.assertTrue('waiters' in str(result))
def test_multiple_waiters(self): # tests that multiple waiters get their results back q = toro.Queue() @gen.coroutine def waiter(q, evt): evt.set((yield q.get())) sendings = ['1', '2', '3', '4'] evts = [toro.AsyncResult() for x in sendings] for i, x in enumerate(sendings): waiter(q, evts[i]) # start task @gen.coroutine def collect_pending_results(): results = set() for e in evts: if e.ready(): # Won't block x = yield e.get() results.add(x) raise gen.Return(len(results)) yield q.put(sendings[0]) self.assertEquals((yield collect_pending_results()), 1) yield q.put(sendings[1]) self.assertEquals((yield collect_pending_results()), 2) yield q.put(sendings[2]) yield q.put(sendings[3]) self.assertEquals((yield collect_pending_results()), 4)
def fetch(self, request, **kwargs): '''Fetch a document. Args: request (Request): An instance of :class:`Request`. kwargs: Any keyword arguments to pass to :func:`Connection.fetch`. Returns: Response: An instance of :class:`Response`. Raises: Exception: See :meth:`.http.connection.Connection.fetch`. ''' _logger.debug('Client fetch request {0}.'.format(request)) if 'recorder' not in kwargs: kwargs['recorder'] = self._recorder elif self._recorder: kwargs['recorder'] = DemuxRecorder( (kwargs['recorder'], self._recorder)) async_result = toro.AsyncResult() yield self._connection_pool.put(request, kwargs, async_result) response = yield async_result.get() if isinstance(response, Exception): raise response from response else: raise tornado.gen.Return(response)
def wait_page_event(self, event_name, timeout=900): '''Wait until given event occurs. Args: event_name (str): The event name. timeout (float): Time out in seconds. Returns: dict: ''' async_result = toro.AsyncResult() def page_event_cb(rpc_info): if rpc_info['event'] == event_name: async_result.set(rpc_info) self.page_event.handle(page_event_cb) deadline = datetime.timedelta(seconds=timeout) if timeout else None try: rpc_info = yield async_result.get(deadline) except toro.Timeout as error: raise PhantomJSRPCTimedOut('Waiting for event timed out.') \ from error self.page_event.unhandle(page_event_cb) raise tornado.gen.Return(rpc_info)
def test_raises_after_timeout(self): start = time.time() with assert_raises(toro.Timeout): async_result = toro.AsyncResult(self.io_loop) yield async_result.get(deadline=timedelta(seconds=0.1)) duration = time.time() - start self.assertAlmostEqual(0.1, duration, places=1)
def sleep(seconds): '''Sleep asynchronously.''' assert seconds >= 0.0 io_loop = tornado.ioloop.IOLoop.current() try: yield toro.AsyncResult().get(io_loop.time() + seconds) except toro.Timeout: pass
def test_get_callback(self): # Test that callbacks registered with get() run immediately after set() result = toro.AsyncResult(io_loop=self.io_loop) history = [] result.get().add_done_callback(make_callback('get1', history)) result.get().add_done_callback(make_callback('get2', history)) result.set('foo') history.append('set') self.assertEqual(['get1', 'get2', 'set'], history)
def set_connected(self, target): """ registers target as being connected :param target: string identifying a given target this method will add target to the connected list and create an empty event buffer """ log.debug("set_connected(%s)" % (target, )) self._connected[self] = target self._lock[target] = toro.AsyncResult()
def _put_rpc_info(self, rpc_info): '''Put the PPC info and AsyncResult into the mapping. Returns: AsyncResult: An instance of :class:`toro.AsyncResult`. ''' async_result = toro.AsyncResult() self._rpc_reply_map[rpc_info['id']] = async_result self._out_queue.put(json.dumps(rpc_info)) return async_result
def test_get_timeout(self): result = toro.AsyncResult(io_loop=self.io_loop) start = time.time() with assert_raises(toro.Timeout): yield result.get(deadline=timedelta(seconds=0.1)) duration = time.time() - start self.assertAlmostEqual(0.1, duration, places=1) self.assertFalse(result.ready()) # Timed-out waiter doesn't cause error result.set('foo') self.assertTrue(result.ready()) value = yield result.get(deadline=timedelta(seconds=.01)) self.assertEqual('foo', value)
def _wait_event(self, events, timeout=None): '''Set the events to listen for and wait for it to occur.''' assert self._state != State.not_yet_connected deadline = datetime.timedelta(seconds=timeout) if timeout else None self._event_result = toro.AsyncResult() self._update_handler(events) try: events = yield self._event_result.get(deadline) except toro.Timeout as error: msg = 'Connection timed out (Events: 0x{events_code:x}).' if events & READ and not events & WRITE: msg = 'Read timed out (Events: 0x{events_code:x}).' elif events & WRITE and not events & READ: msg = 'Write timed out (Events: 0x{events_code:x}).' raise NetworkTimedOut(msg.format(events_code=events)) from error raise tornado.gen.Return(events)
def test_set(self): result = toro.AsyncResult(io_loop=self.io_loop) self.assertFalse(result.ready()) self.io_loop.add_timeout(time.time() + 0.1, partial(result.set, 'hello')) start = time.time() value = yield result.get() duration = time.time() - start self.assertAlmostEqual(0.1, duration, places=1) self.assertTrue(result.ready()) self.assertEqual('hello', value) # Second and third get()'s work too self.assertEqual('hello', (yield result.get())) self.assertEqual('hello', (yield result.get())) # Non-blocking get() works self.assertEqual('hello', result.get_nowait()) # set() only allowed once self.assertRaises(toro.AlreadySet, result.set, 'whatever')
def wait_page_event(self, event_name, deadline=None): '''Wait until given event occurs. Args: event_name (str): The event name. Returns: dict: ''' async_result = toro.AsyncResult() def page_event_cb(rpc_info): if rpc_info['event'] == event_name: async_result.set(rpc_info) self.page_event.handle(page_event_cb) rpc_info = yield async_result.get(deadline) self.page_event.unhandle(page_event_cb) raise tornado.gen.Return(rpc_info)
def wait_future(future, seconds=None): '''Wait for a future to complete with timeouts. Args: future: a Future seconds: The time in seconds before the coroutine is timed out Raises: :class:`TimedOut` when the coroutine does not finish in time ''' if seconds is None: result = yield future raise tornado.gen.Return(result) assert seconds >= 0.0 io_loop = tornado.ioloop.IOLoop.current() async_result = toro.AsyncResult() io_loop.add_future(future, async_result.set) try: future = yield async_result.get(io_loop.time() + seconds) result = future.result() except toro.Timeout as error: raise TimedOut() from error raise tornado.gen.Return(result)
def test_get_nowait(self): self.assertRaises(toro.NotReady, toro.AsyncResult().get_nowait)