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)
