golden hour
/opt/saltstack/salt/lib/python3.10/site-packages/salt/ext/tornado/__pycache__
⬆️ Go Up
Upload
File/Folder
Size
Actions
__init__.cpython-310.pyc
378 B
Del
OK
_locale_data.cpython-310.pyc
3.23 KB
Del
OK
auth.cpython-310.pyc
39.18 KB
Del
OK
autoreload.cpython-310.pyc
7.02 KB
Del
OK
concurrent.cpython-310.pyc
17.24 KB
Del
OK
curl_httpclient.cpython-310.pyc
12.8 KB
Del
OK
escape.cpython-310.pyc
9.89 KB
Del
OK
gen.cpython-310.pyc
38.39 KB
Del
OK
http1connection.cpython-310.pyc
19.47 KB
Del
OK
httpclient.cpython-310.pyc
25.19 KB
Del
OK
httpserver.cpython-310.pyc
11.45 KB
Del
OK
httputil.cpython-310.pyc
29.84 KB
Del
OK
ioloop.cpython-310.pyc
33.19 KB
Del
OK
iostream.cpython-310.pyc
42.97 KB
Del
OK
locale.cpython-310.pyc
15.22 KB
Del
OK
locks.cpython-310.pyc
16.61 KB
Del
OK
log.cpython-310.pyc
8.07 KB
Del
OK
netutil.cpython-310.pyc
14.32 KB
Del
OK
options.cpython-310.pyc
19.63 KB
Del
OK
process.cpython-310.pyc
10.27 KB
Del
OK
queues.cpython-310.pyc
11.29 KB
Del
OK
routing.cpython-310.pyc
21.08 KB
Del
OK
simple_httpclient.cpython-310.pyc
16.08 KB
Del
OK
stack_context.cpython-310.pyc
10.65 KB
Del
OK
tcpclient.cpython-310.pyc
6.49 KB
Del
OK
tcpserver.cpython-310.pyc
10.06 KB
Del
OK
template.cpython-310.pyc
30.52 KB
Del
OK
testing.cpython-310.pyc
24.61 KB
Del
OK
util.cpython-310.pyc
13.72 KB
Del
OK
web.cpython-310.pyc
105.22 KB
Del
OK
websocket.cpython-310.pyc
39.08 KB
Del
OK
wsgi.cpython-310.pyc
11.5 KB
Del
OK
Edit: concurrent.cpython-310.pyc
o �xe J � @ s^ d Z ddlmZmZmZ ddlZddlZddlZddlZddl Z ddl m Z ddl m Z mZ ddlmZmZmZ zddlmZ W n eyK dZY nw zddlZW n ey] dZY nw e�� dkohejd kZG d d � d e�ZG d d � d e �Z G dd� de �Z e Z edu r�e Z nej e fZ dd� Z!G dd� de �Z"e"� Z#dd� Z$e � Z%dd� Z&dd� Z'dS )a[ 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 defines a mostly-compatible `Future` class designed for use from coroutines, as well as some utility functions for interacting with the `concurrent.futures` package. � )�absolute_import�division�print_functionN)�app_log)�ExceptionStackContext�wrap)� ArgReplacer� is_finalizing�raise_exc_info)�futures�CPython)� � c @ s e Zd ZdS )�ReturnValueIgnoredErrorN)�__name__� __module__� __qualname__� r r �O/opt/saltstack/salt/lib/python3.10/site-packages/salt/ext/tornado/concurrent.pyr 8 s r c @ s8 e Zd ZdZdZdd� Zdd� Zdd� Zefd d �Z d S ) �_TracebackLoggera 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 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. ��exc_info� formatted_tbc C s || _ d | _d S �Nr ��selfr r r r �__init__t � z_TracebackLogger.__init__c C s( | j }|d urd | _ tj|� | _d S d S r )r � traceback�format_exceptionr r r r r �activatex s �z_TracebackLogger.activatec C s d | _ d | _d S r r �r r r r �clear~ r z_TracebackLogger.clearc C s0 |� s| j rt�dd�| j ��� � d S d S d S )Nz(Future exception was never retrieved: %s� )r r �error�join�rstrip)r r r r r �__del__� s ��z_TracebackLogger.__del__N) r r r �__doc__� __slots__r r r" r r' r r r r r @ s 1r c @ s� e Zd ZdZdd� Zejdkree� d�� ndd� Z dd � Z d d � Z d d � Z dd� Zdd� Zd'dd�Zd'dd�Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zer_efd%d&�ZdS dS )(�Futurea 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( d| _ d | _d | _d| _d | _g | _d S �NF)�_done�_result� _exc_info�_log_traceback� _tb_logger� _callbacksr! r r r r � s zFuture.__init__)r r zF def __await__(self): return (yield self) c c s � | V }t � }|f|_|�r )� StopIteration�args)r �result�er r r � __await__� s �zFuture.__await__c C � dS )z�Cancel the operation, if possible. Tornado ``Futures`` do not support cancellation, so this method always returns False. Fr r! r r r �cancel� � z Future.cancelc C r7 )z�Returns True if the operation has been cancelled. Tornado ``Futures`` do not support cancellation, so this method always returns False. Fr r! r r r � cancelled� r9 zFuture.cancelledc C s | j S )z4Returns True if this operation is currently running.�r, r! r r r �running� s zFuture.runningc C s | j S )z0Returns True if the future has finished running.r; r! r r r �done� s z Future.donec C s( d| _ | jd ur| j�� d | _d S d S r+ )r/ r0 r" r! r r r � _clear_tb_log� s �zFuture._clear_tb_logNc C sJ | � � | jdur | jS | jdur z t| j� W d} nd} w | �� | jS )a8 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 � _check_done�r �timeoutr r r r4 � s z Future.resultc C s( | � � | jdur| jd S | �� dS )a@ 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. N� )r> r. r? r@ r r r � exception� s zFuture.exceptionc C s" | j r || � dS | j�|� dS )a. 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, r1 �append)r �fnr r r �add_done_callback s zFuture.add_done_callbackc C s || _ | �� dS )z�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- � _set_done)r r4 r r r � set_result s zFuture.set_resultc C s | � |j|t|dd�f� dS )z#Sets the exception of a ``Future.``� __traceback__N)� set_exc_info� __class__�getattr)r rC r r r � set_exception$ s �zFuture.set_exceptionc C s | � � | jS )zeReturns a tuple in the same format as `sys.exc_info` or None. .. versionadded:: 4.0 )r> r. r! r r r r * s zFuture.exc_infoc C sl || _ d| _ts t|�| _z| �� W | jr | jdur | j�� n| jr/| jdur0| j�� w w w || _ dS )z�Sets the exception information of a ``Future.`` Preserves tracebacks on Python 2. .. versionadded:: 4.0 TN)r. r/ �_GC_CYCLE_FINALIZERSr r0 rG r r r r r rJ 2 s �� � zFuture.set_exc_infoc C s | j std��d S )Nz1DummyFuture does not support blocking for results)r, � Exceptionr! r r r r? G s �zFuture._check_donec C sH d| _ | jD ]}z|| � W q ty t�d|| � Y qw d | _d S )NTz Exception in callback %r for %r)r, r1 rO r rC )r �cbr r r rG K s � zFuture._set_donec C s8 |� s| j sd S tj| j� }t�d| d�|��� � d S )Nz+Future %r exception was never retrieved: %sr# )r/ r r r. r r$ r% r& )r r �tbr r r r' Y s �zFuture.__del__r ) r r r r( r �sys� version_info�exec�textwrap�dedentr6 r8 r: r< r= r> r4 rC rF rH rM r rJ r? rG rN r r' r r r r r* � s6 $ �� �r* c C s t | t�S r )� isinstance�FUTURES)�xr r r � is_futurep s rZ c @ s e Zd Zdd� Zddd�ZdS )� DummyExecutorc O sD t � }z |�||i |��� W |S ty! |�t�� � Y |S w r )�TracebackFuturerH rO rJ rR r )r rE r3 �kwargs�futurer r r �submitu s ��zDummyExecutor.submitTc C s d S r r )r �waitr r r �shutdown} s zDummyExecutor.shutdownN)T)r r r r_ ra r r r r r[ t s r[ c sR � fdd�}| r� rt d��t| �dkr|| d �S t| �dkr't dt| ���|S )a+ 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 s6 �� dd�� �� dd��t���� ��fdd��}|S )N�executor�io_loopc sN |� dd �� t| ��j�| g|�R i |��}� r%t| ���|� fdd�� |S )N�callbackc s � | � � �S r )r4 �r^ �rd r r �<lambda>� s zUrun_on_executor.<locals>.run_on_executor_decorator.<locals>.wrapper.<locals>.<lambda>)�poprL r_ Z add_future)r r3 r] r^ �rb rE rc rf r �wrapper� s �zCrun_on_executor.<locals>.run_on_executor_decorator.<locals>.wrapper)�get� functools�wraps)rE rj �r] ri r �run_on_executor_decorator� s z2run_on_executor.<locals>.run_on_executor_decoratorz*cannot combine positional and keyword argsrB r zexpected 1 argument, got %d)� ValueError�len)r3 r] ro r rn r �run_on_executor� s rr c s& t � d��t�� �� �fdd��}|S )az 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. rd c s� t � ���tf�fdd� | |�\� } }�fdd�}d }t|��" z�| i |��}|d ur0td��W n t�� }� W d � n1 sDw Y |d urQ��� � d urb� fdd�}��t |�� �S )Nc s � � | �S r )rH )�valuere r r rg � s z0return_future.<locals>.wrapper.<locals>.<lambda>c s � � | ||f� dS )NT)rJ )�typrs rQ re r r � handle_error� s z4return_future.<locals>.wrapper.<locals>.handle_errorzC@return_future should not be used with functions that return valuesc s* | � � }|tu r � � d S � | � � � d S r )r4 � _NO_RESULT)r^ r4 rf r r � run_callback s z4return_future.<locals>.wrapper.<locals>.run_callback) r\ �replacerv r r rR r r4 rF r )r3 r] ru r r4 rw ��fZreplacer)rd r^ r rj � s2 � ��� � z return_future.<locals>.wrapper)r rl rm )rz rj r ry r � return_future� s '.r{ c s � �fdd�}� � |� dS )z�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 sz | � u sJ ��� � r d S t� t�r%t�t�r%� �� d ur%��� �� � d S � �� d ur4��� �� � d S ��� �� � d S r ) r= rW r\ r rJ rC rM rH r4 re ��a�br r �copy s �� zchain_future.<locals>.copyN)rF )r} r~ r r r| r � chain_future s r� )(r( Z __future__r r r rl �platformrR rU r Zsalt.ext.tornado.logr Z salt.ext.tornado.stack_contextr r Zsalt.ext.tornado.utilr r r Z concurrentr � ImportError�typing�python_implementationrS rN rO r �objectr r* r\ rX rZ r[ Zdummy_executorrr rv r{ r� r r r r �<module> sH � �J _ + [
Save