Current File : //usr/lib64/python2.7/site-packages/tornado/concurrent.pyo
�
��L]c @� s� d Z d d l m Z m Z m Z m Z d d l Z d d l Z d d l Z d d l Z d d l
m Z d d l m
Z
m Z d d l m Z m Z y d d l m Z Wn e k
r� d Z n Xe j � d k o� e j d k Z d e f d � � YZ d
e f d � � YZ d e f d � � YZ e Z e d k r@e Z n e j e f Z d � Z d e f d � � YZ! e! � Z" d � Z# e � Z$ d � Z% d � Z& d S( s� Utilities for working with threads and ``Futures``.
``Futures`` are a pattern for concurrent programming introduced in
Python 3.2 in the `concurrent.futures` package (this package has also
been backported to older versions of Python and can be installed with
``pip install futures``). Tornado will use `concurrent.futures.Future` if
it is available; otherwise it will use a compatible class defined in this
module.
i ( t absolute_importt divisiont print_functiont with_statementN( t app_log( t ExceptionStackContextt wrap( t raise_exc_infot ArgReplacer( t futurest CPythoni i t ReturnValueIgnoredErrorc B� s e Z RS( ( t __name__t
__module__( ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyR / s t _TracebackLoggerc B� s8 e Z d Z d Z d � Z d � Z d � Z d � Z RS( s
Helper to log a traceback upon destruction if not cleared.
This solves a nasty problem with Futures and Tasks that have an
exception set: if nobody asks for the exception, the exception is
never logged. This violates the Zen of Python: 'Errors should
never pass silently. Unless explicitly silenced.'
However, we don't want to log the exception as soon as
set_exception() is called: if the calling code is written
properly, it will get the exception and handle it properly. But
we *do* want to log it if result() or exception() was never called
-- otherwise developers waste a lot of time wondering why their
buggy code fails silently.
An earlier attempt added a __del__() method to the Future class
itself, but this backfired because the presence of __del__()
prevents garbage collection from breaking cycles. A way out of
this catch-22 is to avoid having a __del__() method on the Future
class itself, but instead to have a reference to a helper object
with a __del__() method that logs the traceback, where we ensure
that the helper object doesn't participate in cycles, and only the
Future has a reference to it.
The helper object is added when set_exception() is called. When
the Future is collected, and the helper is present, the helper
object is also collected, and its __del__() method will log the
traceback. When the Future's result() or exception() method is
called (and a helper object is present), it removes the the helper
object, after calling its clear() method to prevent it from
logging.
One downside is that we do a fair amount of work to extract the
traceback from the exception, even when it is never logged. It
would seem cheaper to just store the exception object, but that
references the traceback, which references stack frames, which may
reference the Future, which references the _TracebackLogger, and
then the _TracebackLogger would be included in a cycle, which is
what we're trying to avoid! As an optimization, we don't
immediately format the exception; we only do the work when
activate() is called, which call is delayed until after all the
Future's callbacks have run. Since usually a Future has at least
one callback (typically set by 'yield From') and usually that
callback extracts the callback, thereby removing the need to
format the exception.
PS. I don't claim credit for this solution. I first heard of it
in a discussion about closing files when they are collected.
t exc_infot formatted_tbc C� s | | _ d | _ d S( N( R t NoneR ( t selfR ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt __init__j s c C� s7 | j } | d k r3 d | _ t j | � | _ n d S( N( R R t tracebackt format_exceptionR ( R R ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt activaten s c C� s d | _ d | _ d S( N( R R R ( R ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt cleart s c C� s2 | j r. t j d d j | j � j � � n d S( Ns( Future exception was never retrieved: %st ( R R t errort joint rstrip( R ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt __del__x s ( s exc_infos formatted_tb( R R
t __doc__t __slots__R R R R ( ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyR 6 s 0 t Futurec B� s� e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d d � Z
d d � Z d � Z d
� Z
d � Z d � Z d
� Z d � Z d � Z e r� d � Z n RS( s Placeholder for an asynchronous result.
A ``Future`` encapsulates the result of an asynchronous
operation. In synchronous applications ``Futures`` are used
to wait for the result from a thread or process pool; in
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).
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.
This functionality was previously available in a separate class
``TracebackFuture``, which is now a deprecated alias for this class.
.. versionchanged:: 4.0
`tornado.concurrent.Future` is always a thread-unsafe ``Future``
with support for the ``exc_info`` methods. Previously it would
be an alias for the thread-safe `concurrent.futures.Future`
if that package was available and fall back to the thread-unsafe
implementation if it was not.
.. versionchanged:: 4.1
If a `.Future` contains an error but that error is never observed
(by calling ``result()``, ``exception()``, or ``exc_info()``),
a stack trace will be logged when the `.Future` is garbage collected.
This normally indicates an error in the application, but in cases
where it results in undesired logging it may be necessary to
suppress the logging by ensuring that the exception is observed:
``f.add_done_callback(lambda f: f.exception())``.
c C� s: t | _ d | _ d | _ t | _ d | _ g | _ d S( N( t Falset _doneR t _resultt _exc_infot _log_tracebackt
_tb_loggert
_callbacks( R ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyR � s c C� s t S( s� Cancel the operation, if possible.
Tornado ``Futures`` do not support cancellation, so this method always
returns False.
( R ( R ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt cancel� s c C� s t S( s� Returns True if the operation has been cancelled.
Tornado ``Futures`` do not support cancellation, so this method
always returns False.
( R ( R ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt cancelled� s c C� s | j S( s4 Returns True if this operation is currently running.( R! ( R ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt running� s c C� s | j S( s0 Returns True if the future has finished running.( R! ( R ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt done� s c C� s5 t | _ | j d k r1 | j j � d | _ n d S( N( R R$ R% R R ( R ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt
_clear_tb_log� s
c C� sP | j � | j d k r | j S| j d k r? t | j � n | j � | j S( s8 If the operation succeeded, return its result. If it failed,
re-raise its exception.
This method takes a ``timeout`` argument for compatibility with
`concurrent.futures.Future` but it is an error to call it
before the `Future` is done, so the ``timeout`` is never used.
N( R+ R" R R# R t _check_done( R t timeout( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt result� s
c C� s6 | j � | j d k r$ | j d S| j � d Sd S( s@ If the operation raised an exception, return the `Exception`
object. Otherwise returns None.
This method takes a ``timeout`` argument for compatibility with
`concurrent.futures.Future` but it is an error to call it
before the `Future` is done, so the ``timeout`` is never used.
i N( R+ R# R R, ( R R- ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt exception� s
c C� s* | j r | | � n | j j | � d S( s. Attaches the given callback to the `Future`.
It will be invoked with the `Future` as its argument when the Future
has finished running and its result is available. In Tornado
consider using `.IOLoop.add_future` instead of calling
`add_done_callback` directly.
N( R! R& t append( R t fn( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt add_done_callback� s
c C� s | | _ | j � d S( s� Sets the result of a ``Future``.
It is undefined to call any of the ``set`` methods more than once
on the same object.
N( R" t _set_done( R R. ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt
set_result� s c C� s) | j | j | t | d d � f � d S( s# Sets the exception of a ``Future.``t
__traceback__N( t set_exc_infot __class__t getattrR ( R R/ ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt
set_exception� s c C� s | j � | j S( se Returns a tuple in the same format as `sys.exc_info` or None.
.. versionadded:: 4.0
( R+ R# ( R ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyR s
c C� sq | | _ t | _ t s* t | � | _ n z | j � Wd | j rc | j d k rc | j j � n X| | _ d S( s� Sets the exception information of a ``Future.``
Preserves tracebacks on Python 2.
.. versionadded:: 4.0
N( R# t TrueR$ t _GC_CYCLE_FINALIZERSR R% R3 R R ( R R ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyR6 s c C� s | j s t d � � n d S( Ns1 DummyFuture does not support blocking for results( R! t Exception( R ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyR, # s c C� s_ t | _ xF | j D]; } y | | � Wq t k
rM t j d | | � q Xq Wd | _ d S( Ns Exception in callback %r for %r( R: R! R& R< R R/ R ( R t cb( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyR3 ' s
c C� sE | j s
d St j | j � } t j d | d j | � j � � d S( Ns+ Future %r exception was never retrieved: %sR ( R$ R R R# R R R R ( R t tb( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyR 5 s
N( R R
R R R' R( R) R* R+ R R. R/ R2 R4 R9 R R6 R, R3 R; R ( ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyR ~ s$ #
c C� s
t | t � S( N( t
isinstancet FUTURES( t x( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt is_futureH s t
DummyExecutorc B� s e Z d � Z e d � Z RS( c O� sN t � } y | j | | | � � Wn$ t k
rI | j t j � � n X| S( N( t TracebackFutureR4 R< R6 t sysR ( R R1 t argst kwargst future( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt submitM s
c C� s d S( N( ( R t wait( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt shutdownU s ( R R
RI R: RK ( ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyRC L s c � sx � f d � } | r* � r* t d � � n t | � d k rJ | | d � St | � d k rt t d t | � � � n | S( s+ Decorator to run a synchronous method asynchronously on an executor.
The decorated method may be called with a ``callback`` keyword
argument and returns a future.
The `.IOLoop` and executor to be used are determined by the ``io_loop``
and ``executor`` attributes of ``self``. To use different attributes,
pass keyword arguments to the decorator::
@run_on_executor(executor='_thread_pool')
def foo(self):
pass
.. versionchanged:: 4.2
Added keyword arguments to use alternative attributes.
c � sL � j d d � � � j d d � � t j � � � � � f d � � } | S( Nt executort io_loopc � sb | j d d � � t | � � j � | | | � } � r^ t | � � j | � f d � � n | S( Nt callbackc � s � | j � � S( N( R. ( RH ( RN ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt <lambda>u s ( t popR R8 RI t
add_future( R RF RG RH ( RL R1 RM ( RN s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt wrappero s !( t gett functoolst wraps( R1 RR ( RG ( RL R1 RM s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt run_on_executor_decoratorl s $s* cannot combine positional and keyword argsi i s expected 1 argument, got %d( t
ValueErrort len( RF RG RV ( ( RG s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt run_on_executor[ s c � s4 t � d � � t j � � � � f d � � } | S( sz Decorator to make a function that returns via callback return a
`Future`.
The wrapped function should take a ``callback`` keyword argument
and invoke it with one argument when it has finished. To signal failure,
the function can simply raise an exception (which will be
captured by the `.StackContext` and passed along to the ``Future``).
From the caller's perspective, the callback argument is optional.
If one is given, it will be invoked when the function is complete
with `Future.result()` as an argument. If the function fails, the
callback will not be run and an exception will be raised into the
surrounding `.StackContext`.
If no callback is given, the caller should use the ``Future`` to
wait for the function to complete (perhaps by yielding it in a
`.gen.engine` function, or passing it to `.IOLoop.add_future`).
Usage:
.. testcode::
@return_future
def future_func(arg1, arg2, callback):
# Do stuff (possibly asynchronous)
callback(result)
@gen.engine
def caller(callback):
yield future_func(arg1, arg2)
callback()
..
Note that ``@return_future`` and ``@gen.engine`` can be applied to the
same function, provided ``@return_future`` appears first. However,
consider using ``@gen.coroutine`` instead of this combination.
RN c � s� t � � � j t � f d � | | � \ � } } � f d � } d } t | � �L y. � | | � } | d k r� t d � � n Wn t j � } � n XWd QX| d k r� � j � n � d k r� � f d � } � j t
| � � n � S( Nc � s
� j | � S( N( R4 ( t value( RH ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyRO � s c � s � j | | | f � t S( N( R6 R: ( t typRZ R> ( RH ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt handle_error� s sC @return_future should not be used with functions that return valuesc � s6 | j � } | t k r" � � n � | j � � d S( N( R. t
_NO_RESULT( RH R. ( RN ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt run_callback� s
( RD t replaceR] R R R RE R R. R2 R ( RF RG R\ R R. R^ ( t ft replacer( RN RH s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyRR � s*
( R RT RU ( R` RR ( ( R` Ra s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt
return_future� s '!*c � s# � � f d � } � j | � d S( s� Chain two futures together so that when one completes, so does the other.
The result (success or failure) of ``a`` will be copied to ``b``, unless
``b`` has already been completed or cancelled by the time ``a`` finishes.
c � s� � j � r d St � t � rV t � t � rV � j � d k rV � j � j � � n; � j � d k r~ � j � j � � n � j � j � � d S( N(
R* R? RD R R R6 R/ R9 R4 R. ( RH ( t at b( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt copy� s N( R2 ( Rc Rd Re ( ( Rc Rd s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt chain_future� s ( i i (' R t
__future__R R R R RT t platformR RE t tornado.logR t tornado.stack_contextR R t tornado.utilR R t
concurrentR t ImportErrorR t python_implementationt version_infoR; R< R t objectR R RD R@ RB RC t dummy_executorRY R] Rb Rf ( ( ( s8 /usr/lib64/python2.7/site-packages/tornado/concurrent.pyt <module> s8 "
H� & V
Mini Shell