.. automethod:: Future.result
.. automethod:: Future.exception
- .. automethod:: Future.exc_info
.. automethod:: Future.add_done_callback
.. automethod:: Future.done
- .. automethod:: Future.running
.. automethod:: Future.cancel
.. automethod:: Future.cancelled
.. automethod:: Future.set_result
.. automethod:: Future.set_exception
- .. automethod:: Future.set_exc_info
.. testsetup::
+ import tornado.auth
import tornado.web
Cookies and secure cookies
except ImportError:
futures = None
+try:
+ import asyncio
+except ImportError:
+ asyncio = None
+
try:
import typing
except ImportError:
Tornado they are normally used with `.IOLoop.add_future` or by
yielding them in a `.gen.coroutine`.
- `tornado.concurrent.Future` is similar to
- `concurrent.futures.Future`, but not thread-safe (and therefore
- faster for use with single-threaded event loops).
+ `tornado.concurrent.Future` is an alias for `asyncio.Future` when
+ that package is available (Python 3.4+). Unlike
+ `concurrent.futures.Future`, the ``Futures`` used by Tornado and
+ `asyncio` are not thread-safe (and therefore faster for use with
+ single-threaded event loops).
- In addition to ``exception`` and ``set_exception``, methods ``exc_info``
- and ``set_exc_info`` are supported to capture tracebacks in Python 2.
- The traceback is automatically available in Python 3, but in the
- Python 2 futures backport this information is discarded.
+ In addition to ``exception`` and ``set_exception``, Tornado's
+ ``Future`` implementation supports storing an ``exc_info`` triple
+ to support better tracebacks on Python 2. To set an ``exc_info``
+ triple, use `future_set_exc_info`, and to retrieve one, call
+ `result()` (which will raise it).
.. versionchanged:: 4.0
`tornado.concurrent.Future` is always a thread-unsafe ``Future``
``f.add_done_callback(lambda f: f.exception())``.
.. versionchanged:: 5.0
- This class was previoiusly available under the name ``TracebackFuture``.
- This name, which was deprecated since version 4.0, has been removed.
+
+ This class was previoiusly available under the name
+ ``TracebackFuture``. This name, which was deprecated since
+ version 4.0, has been removed. When `asyncio` is available
+ ``tornado.concurrent.Future`` is now an alias for
+ `asyncio.Future`. Like `asyncio.Future`, callbacks are now
+ always scheduled on the `.IOLoop` and are never run
+ synchronously.
+
"""
def __init__(self):
self._done = False
`add_done_callback` directly.
"""
if self._done:
- fn(self)
+ from tornado.ioloop import IOLoop
+ IOLoop.current().add_callback(fn, self)
else:
self._callbacks.append(fn)
def _set_done(self):
self._done = True
+ from tornado.ioloop import IOLoop
+ loop = IOLoop.current()
for cb in self._callbacks:
- try:
- cb(self)
- except Exception:
- app_log.exception('Exception in callback %r for %r',
- cb, self)
+ loop.add_callback(cb, self)
self._callbacks = None
# On Python 3.3 or older, objects with a destructor part of a reference
self, ''.join(tb).rstrip())
+if asyncio is not None:
+ Future = asyncio.Future # noqa
+
if futures is None:
FUTURES = Future # type: typing.Union[type, typing.Tuple[type, ...]]
else:
future, exc_info=True)
def timeout_callback():
- result.set_exception(TimeoutError("Timeout"))
+ if not result.done():
+ result.set_exception(TimeoutError("Timeout"))
# In case the wrapped future goes on to fail, log it.
future_add_done_callback(future, error_callback)
timeout_handle = io_loop.add_timeout(
.. versionadded:: 4.0
.. deprecated:: 4.5
- ``yield None`` is now equivalent to ``yield gen.moment``.
+ ``yield None`` (or ``yield`` with no argument) is now equivalent to
+ ``yield gen.moment``.
"""
moment.set_result(None)
self.future = Future()
future_set_exc_info(self.future, sys.exc_info())
- if not self.future.done() or self.future is moment:
+ if self.future is moment:
+ self.io_loop.add_callback(self.run)
+ return False
+ elif not self.future.done():
def inner(f):
# Break a reference cycle to speed GC.
f = None # noqa
if singledispatch is not None:
convert_yielded = singledispatch(convert_yielded)
-
- try:
- # If we can import t.p.asyncio, do it for its side effect
- # (registering asyncio.Future with convert_yielded).
- # It's ugly to do this here, but it prevents a cryptic
- # infinite recursion in _wrap_awaitable.
- # Note that even with this, asyncio integration is unlikely
- # to work unless the application also configures AsyncIOLoop,
- # but at least the error messages in that case are more
- # comprehensible than a stack overflow.
- import tornado.platform.asyncio
- except ImportError:
- pass
- else:
- # Reference the imported module to make pyflakes happy.
- tornado
self._ssl_connect_future = None
for future in futures:
future.set_exception(StreamClosedError(real_error=self.error))
+ future.exception()
if self._close_callback is not None:
cb = self._close_callback
self._close_callback = None
The method raises `tornado.util.TimeoutError` if there's no notification
before the deadline.
+
+ .. versionchanged:: 5.0
+ Previously, waiters could be notified synchronously from within
+ `notify`. Now, the notification will always be received on the
+ next iteration of the `.IOLoop`.
"""
def __init__(self):
self._waiters.append(waiter)
if timeout:
def on_timeout():
- waiter.set_result(False)
+ if not waiter.done():
+ waiter.set_result(False)
self._garbage_collect()
io_loop = ioloop.IOLoop.current()
timeout_handle = io_loop.add_timeout(timeout, on_timeout)
@gen.coroutine
def simulator(futures):
for f in futures:
+ # simulate the asynchronous passage of time
+ yield gen.moment
yield gen.moment
f.set_result(None)
self._waiters.append(waiter)
if timeout:
def on_timeout():
- waiter.set_exception(gen.TimeoutError())
+ if not waiter.done():
+ waiter.set_exception(gen.TimeoutError())
self._garbage_collect()
io_loop = ioloop.IOLoop.current()
timeout_handle = io_loop.add_timeout(timeout, on_timeout)
def start(self):
old_current = IOLoop.current(instance=False)
+ try:
+ old_asyncio = asyncio.get_event_loop()
+ except RuntimeError:
+ old_asyncio = None
try:
self._setup_logging()
self.make_current()
+ # This is automatic in 3.5, but must be done manually in 3.4.
+ asyncio.set_event_loop(self.asyncio_loop)
self.asyncio_loop.run_forever()
finally:
if old_current is None:
IOLoop.clear_current()
else:
old_current.make_current()
+ asyncio.set_event_loop(old_asyncio)
def stop(self):
self.asyncio_loop.stop()
"""Convert an `asyncio.Future` to a `tornado.concurrent.Future`.
.. versionadded:: 4.1
+
+ .. deprecated:: 5.0
+ Tornado ``Futures`` have been merged with `asyncio.Future`,
+ so this method is now a no-op.
"""
- tf = tornado.concurrent.Future()
- tornado.concurrent.chain_future(asyncio_future, tf)
- return tf
+ return asyncio_future
def to_asyncio_future(tornado_future):
.. versionchanged:: 4.3
Now accepts any yieldable object, not just
`tornado.concurrent.Future`.
- """
- tornado_future = convert_yielded(tornado_future)
- af = asyncio.Future()
- tornado.concurrent.chain_future(tornado_future, af)
- return af
-
-if hasattr(convert_yielded, 'register'):
- convert_yielded.register(asyncio.Future, to_tornado_future) # type: ignore
+ .. deprecated:: 5.0
+ Tornado ``Futures`` have been merged with `asyncio.Future`,
+ so this method is now equivalent to `tornado.gen.convert_yielded`.
+ """
+ return convert_yielded(tornado_future)
def _set_timeout(future, timeout):
if timeout:
def on_timeout():
- future.set_exception(gen.TimeoutError())
+ if not future.done():
+ future.set_exception(gen.TimeoutError())
io_loop = ioloop.IOLoop.current()
timeout_handle = io_loop.add_timeout(timeout, on_timeout)
future.add_done_callback(
42)
# Asyncio only supports coroutines that yield asyncio-compatible
- # Futures.
- with self.assertRaises(RuntimeError):
+ # Futures (which our Future is since 5.0).
+ self.assertEqual(
asyncio.get_event_loop().run_until_complete(
- native_coroutine_without_adapter())
+ native_coroutine_without_adapter()),
+ 42)
self.assertEqual(
asyncio.get_event_loop().run_until_complete(
native_coroutine_with_adapter()),
@gen_test
def test_uncaught_exception_log(self):
+ if IOLoop.configured_class().__name__.endswith('AsyncIOLoop'):
+ # Install an exception handler that mirrors our
+ # non-asyncio logging behavior.
+ def exc_handler(loop, context):
+ app_log.error('%s: %s', context['message'],
+ type(context.get('exception')))
+ self.io_loop.asyncio_loop.set_exception_handler(exc_handler)
@gen.coroutine
def f():
yield gen.moment
from tornado.escape import utf8
from tornado.httpclient import HTTPRequest
+from tornado.locks import Event
from tornado.stack_context import ExceptionStackContext
-from tornado.testing import AsyncHTTPTestCase
+from tornado.testing import AsyncHTTPTestCase, gen_test
from tornado.test import httpclient_test
from tornado.test.util import unittest
from tornado.web import Application, RequestHandler
defaults=dict(allow_ipv6=False),
**kwargs)
+ @gen_test
def test_prepare_curl_callback_stack_context(self):
exc_info = []
+ error_event = Event()
def error_handler(typ, value, tb):
exc_info.append((typ, value, tb))
- self.stop()
+ error_event.set()
return True
with ExceptionStackContext(error_handler):
- request = HTTPRequest(self.get_url('/'),
+ request = HTTPRequest(self.get_url('/custom_reason'),
prepare_curl_callback=lambda curl: 1 / 0)
- self.http_client.fetch(request, callback=self.stop)
- self.wait()
+ yield [error_event.wait(), self.http_client.fetch(request)]
self.assertEqual(1, len(exc_info))
self.assertIs(exc_info[0][0], ZeroDivisionError)
self.finished = True
@skipNotCPython
+ @unittest.skipIf((3,) < sys.version_info < (3,6),
+ "asyncio.Future has reference cycles")
def test_coroutine_refcounting(self):
# On CPython, tasks and their arguments should be released immediately
# without waiting for garbage collection.
chunks.append(chunk)
def finish(self):
+ conn.detach()
callback((self.start_line, self.headers, b''.join(chunks)))
conn = HTTP1Connection(stream, True)
conn.read_response(Delegate())
def tearDown(self):
self.stream.close()
+ self.io_loop.run_sync(self.server.close_all_connections)
self.server.stop()
shutil.rmtree(self.tmpdir)
super(UnixSocketTest, self).tearDown()
self.history.append(key)
future.add_done_callback(callback)
+ def loop_briefly(self):
+ """Run all queued callbacks on the IOLoop.
+
+ In these tests, this method is used after calling notify() to
+ preserve the pre-5.0 behavior in which callbacks ran
+ synchronously.
+ """
+ self.io_loop.add_callback(self.stop)
+ self.wait()
+
def test_repr(self):
c = locks.Condition()
self.assertIn('Condition', repr(c))
self.record_done(c.wait(), 'wait1')
self.record_done(c.wait(), 'wait2')
c.notify(1)
+ self.loop_briefly()
self.history.append('notify1')
c.notify(1)
+ self.loop_briefly()
self.history.append('notify2')
self.assertEqual(['wait1', 'notify1', 'wait2', 'notify2'],
self.history)
self.record_done(c.wait(), i)
c.notify(3)
+ self.loop_briefly()
# Callbacks execute in the order they were registered.
self.assertEqual(list(range(3)), self.history)
c.notify(1)
+ self.loop_briefly()
self.assertEqual(list(range(4)), self.history)
c.notify(2)
+ self.loop_briefly()
self.assertEqual(list(range(6)), self.history)
def test_notify_all(self):
self.record_done(c.wait(), i)
c.notify_all()
+ self.loop_briefly()
self.history.append('notify_all')
# Callbacks execute in the order they were registered.
self.assertEqual(['timeout', 0, 2], self.history)
self.assertEqual(['timeout', 0, 2], self.history)
c.notify()
+ yield
self.assertEqual(['timeout', 0, 2, 3], self.history)
@gen_test
self.assertEqual(['timeout'], self.history)
c.notify_all()
+ yield
self.assertEqual(['timeout', 0, 2], self.history)
@gen_test
# resolving third future.
futures[1].add_done_callback(lambda _: c.notify())
c.notify(2)
+ yield
self.assertTrue(all(f.done() for f in futures))
@gen_test
# Twisted 15.0.0 triggers some warnings on py3 with -bb.
warnings.filterwarnings("ignore", category=BytesWarning,
module=r"twisted\..*")
+ if (3,) < sys.version_info < (3, 6):
+ # Prior to 3.6, async ResourceWarnings were rather noisy
+ # and even
+ # `python3.4 -W error -c 'import asyncio; asyncio.get_event_loop()'`
+ # would generate a warning.
+ warnings.filterwarnings("ignore", category=ResourceWarning,
+ module=r"asyncio\..*")
logging.getLogger("tornado.access").setLevel(logging.CRITICAL)
else:
self.streams.pop(addr)
future.set_exception(IOError())
+ # Run the loop to allow callbacks to be run.
+ self.io_loop.add_callback(self.stop)
+ self.wait()
def assert_connector_streams_closed(self, conn):
for stream in conn.streams:
class TestServer(TCPServer):
@gen.coroutine
def handle_stream(self, stream, address):
- yield gen.moment
+ yield stream.read_bytes(len(b'hello'))
stream.close()
1 / 0
client = IOStream(socket.socket())
with ExpectLog(app_log, "Exception in callback"):
yield client.connect(('localhost', port))
+ yield client.write(b'hello')
yield client.read_until_close()
yield gen.moment
finally:
else:
import thread
+try:
+ import asyncio
+except ImportError:
+ asyncio = None
skipIfNoTwisted = unittest.skipUnless(have_twisted,
"twisted module not present")
@skipIfNoTwisted
class ConvertDeferredTest(unittest.TestCase):
+ def setUp(self):
+ if asyncio is not None:
+ asyncio.set_event_loop(asyncio.new_event_loop())
+
+ def tearDown(self):
+ if asyncio is not None:
+ asyncio.set_event_loop(None)
+
def test_success(self):
@inlineCallbacks
def fn():
else:
from cStringIO import StringIO
+try:
+ import asyncio
+except ImportError:
+ asyncio = None
+
+
try:
from collections.abc import Generator as GeneratorType # type: ignore
except ImportError:
super(AsyncTestCase, self).setUp()
self.io_loop = self.get_new_ioloop()
self.io_loop.make_current()
+ if hasattr(self.io_loop, 'asyncio_loop'):
+ # Ensure that asyncio's current event loop matches ours.
+ asyncio.set_event_loop(self.io_loop.asyncio_loop)
def tearDown(self):
# Clean up Subprocess, so it can be used again with a new ioloop.
# set FD_CLOEXEC on its file descriptors)
self.io_loop.close(all_fds=True)
super(AsyncTestCase, self).tearDown()
+ if hasattr(self.io_loop, 'asyncio_loop'):
+ asyncio.set_event_loop(None)
# In case an exception escaped or the StackContext caught an exception
# when there wasn't a wait() to re-raise it, do so here.
# This is our last chance to raise an exception in a way that the
projects / thirdparty / tornado.git / commitdiff
