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: stack_context.cpython-310.pyc
o �xe�3 � @ s� d Z ddlmZmZmZ ddlZddlZddlmZ G dd� de �Z G dd� dej �Z e � Z G d d � d e�ZG d d � d e�ZG d d� de�Zdd� Zdd� Zdd� Zdd� ZdS )a `StackContext` allows applications to maintain threadlocal-like state that follows execution as it moves to other execution contexts. The motivating examples are to eliminate the need for explicit ``async_callback`` wrappers (as in `tornado.web.RequestHandler`), and to allow some additional context to be kept for logging. This is slightly magic, but it's an extension of the idea that an exception handler is a kind of stack-local state and when that stack is suspended and resumed in a new context that state needs to be preserved. `StackContext` shifts the burden of restoring that state from each call site (e.g. wrapping each `.AsyncHTTPClient` callback in ``async_callback``) to the mechanisms that transfer control from one context to another (e.g. `.AsyncHTTPClient` itself, `.IOLoop`, thread pools, etc). Example usage:: @contextlib.contextmanager def die_on_error(): try: yield except Exception: logging.error("exception in asynchronous operation",exc_info=True) sys.exit(1) with StackContext(die_on_error): # Any exception thrown here *or in callback and its descendants* # will cause the process to exit instead of spinning endlessly # in the ioloop. http_client.fetch(url, callback) ioloop.start() Most applications shouldn't have to work with `StackContext` directly. Here are a few rules of thumb for when it's necessary: * If you're writing an asynchronous library that doesn't rely on a stack_context-aware library like `tornado.ioloop` or `tornado.iostream` (for example, if you're writing a thread pool), use `.stack_context.wrap()` before any asynchronous operations to capture the stack context from where the operation was started. * If you're writing an asynchronous library that has some shared resources (such as a connection pool), create those shared resources within a ``with stack_context.NullContext():`` block. This will prevent ``StackContexts`` from leaking from one request to another. * If you want to write something like an exception handler that will persist across asynchronous calls, create a new `StackContext` (or `ExceptionStackContext`), and make your asynchronous calls in a ``with`` block that references your `StackContext`. � )�absolute_import�division�print_functionN)�raise_exc_infoc @ s e Zd ZdS )� StackContextInconsistentErrorN)�__name__� __module__� __qualname__� r r �R/opt/saltstack/salt/lib/python3.10/site-packages/salt/ext/tornado/stack_context.pyr O s r c @ s e Zd Zdd� ZdS )�_Statec C s t � d f| _d S �N)�tuple�contexts��selfr r r �__init__T s z_State.__init__N)r r r r r r r r r S s r c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )� StackContexta Establishes the given context as a StackContext that will be transferred. Note that the parameter is a callable that returns a context manager, not the context itself. That is, where for a non-transferable context manager you would say:: with my_context(): StackContext takes the function itself rather than its result:: with StackContext(my_context): The result of ``with StackContext() as cb:`` is a deactivation callback. Run this callback when the StackContext is no longer needed to ensure that it is not propagated any further (note that deactivating a context does not affect any instances of that context that are currently pending). This is an advanced feature and not necessary in most applications. c C s || _ g | _d| _d S �NT)�context_factoryr �active)r r r r r r o s zStackContext.__init__c C � d| _ d S �NF�r r r r r � _deactivatet � zStackContext._deactivatec C s | � � }| j�|� |�� d S r )r r �append� __enter__)r �contextr r r �enterx s zStackContext.enterc C s | j �� }|�|||� d S r )r �pop�__exit__)r �type�value� tracebackr r r r �exit} s zStackContext.exitc C sH t j| _| jd | f | f| _| jt _z| �� W | jS | jt _� �Nr )�_stater � old_contexts� new_contextsr r r r r r r � s �zStackContext.__enter__c C sd z | � |||� W tj}| jt_|| jurtd��d | _d S tj}| jt_|| jur.td��d | _w �NzWstack_context inconsistency (may be caused by yield within a "with StackContext" block))r% r' r r( r) r �r r" r# r$ Zfinal_contextsr r r r! � s � � �zStackContext.__exit__N) r r r �__doc__r r r r% r r! r r r r r [ s r c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �ExceptionStackContextaA Specialization of StackContext for exception handling. The supplied ``exception_handler`` function will be called in the event of an uncaught exception in this context. The semantics are similar to a try/finally clause, and intended use cases are to log an error, close a socket, or similar cleanup actions. The ``exc_info`` triple ``(type, value, traceback)`` will be passed to the exception_handler function. If the exception handler returns true, the exception will be consumed and will not be propagated to other exception handlers. c C s || _ d| _d S r )�exception_handlerr )r r. r r r r � s z ExceptionStackContext.__init__c C r r r r r r r r � r z!ExceptionStackContext._deactivatec C s |d ur | � |||�S d S r )r. �r r" r# r$ r r r r% � s �zExceptionStackContext.exitc C s& t j| _| jd | f| _| jt _| jS r& )r' r r( r) r r r r r r � s z ExceptionStackContext.__enter__c C s� z5|d ur | � |||�W tj}| jt_|| jur td��d | _S W tj}| jt_|| jur1td��d | _d S tj}| jt_|| jurFtd��d | _w r* )r. r' r r( r) r r+ r r r r! � s2 �� � � �z ExceptionStackContext.__exit__N) r r r r, r r r% r r! r r r r r- � s r- c @ s e Zd ZdZdd� Zdd� ZdS )� NullContextz�Resets the `StackContext`. Useful when creating a shared resource on demand (e.g. an `.AsyncHTTPClient`) where the stack that caused the creating is not relevant to future operations. c C s t j| _t� d ft _d S r )r' r r( r r r r r r � s zNullContext.__enter__c C s | j t_d S r )r( r' r r/ r r r r! � s zNullContext.__exit__N)r r r r, r r! r r r r r0 � s r0 c C s� t dd� | d D ��}| d }|dur"|js"|jd }|dur"|jr|}|durH|jd }|durB|jr5n |j|_|jd }|dus1|}|dus(||fS )z*Remove deactivated handlers from the chainc S s g | ]}|j r|�qS r r )�.0�hr r r � <listcomp>� s z'_remove_deactivated.<locals>.<listcomp>r � N)r r r( )r Zstack_contexts�head�ctx�parentr r r �_remove_deactivated� s" � �� r8 c sf �du s t �d�r �S tjg� � d d s'� d d s'� �fdd�}d|_|S � �fdd �}d|_|S ) a Returns a callable object that will restore the current `StackContext` when executed. Use this whenever saving a callback to be executed later in a different execution context (either in a different thread or asynchronously in the same thread). N�_wrappedr r4 c s0 zt j}� d t _�| i |��W |t _S |t _w r& )r' r )�args�kwargs� current_state�Z cap_contexts�fnr r � null_wrapper s zwrap.<locals>.null_wrapperTc sN d }z�t j}t� d � � d< }|t _d}d }d}|d }|D ]} z | �� |d7 }W q t�� }| jd }Y q |d u rTz �| i |��}W n t�� }|d }Y |d ur^t||�}n1|dkr�|d8 }|| } z| j|� W n t�� }| jd }Y n|dksbd }|d ur�t||�}|dkr�t |� W |t _|S W |t _|S |t _w )Nr �NNNr4 ) r' r r8 r �sys�exc_infor( �_handle_exceptionr% r ) r: r; �retr< r �exc�topZlast_ctx�stack�n�cr= r r �wrapped sZ � ��zwrap.<locals>.wrapped)�hasattrr' r r9 )r> r? rJ r r= r �wrap s CrL c C sB | d ur z | j |� r d}W n t�� }Y | jd } | d us|S )Nr@ r4 )r% rA rB r( )�tailrE r r r rC c s � � rC c C s. | � |� W d � S 1 sw Y dS )a� Run a coroutine ``func`` in the given `StackContext`. It is not safe to have a ``yield`` statement within a ``with StackContext`` block, so it is difficult to use stack context with `.gen.coroutine`. This helper function runs the function in the correct context while keeping the ``yield`` and ``with`` statements syntactically separate. Example:: @gen.coroutine def incorrect(): with StackContext(ctx): # ERROR: this will raise StackContextInconsistentError yield other_coroutine() @gen.coroutine def correct(): yield run_with_stack_context(StackContext(ctx), other_coroutine) .. versionadded:: 3.1 Nr )r �funcr r r �run_with_stack_contextp s $�rO )r, Z __future__r r r rA � threadingZsalt.ext.tornado.utilr � Exceptionr �localr r' �objectr r- r0 r8 rL rC rO r r r r �<module> s 6 L0c
Save