File: //usr/local/lib/python3.9/site-packages/celery/utils/__pycache__/threads.cpython-39.pyc
a
X>hP% � @ sr d Z ddlZddlZddlZddlZddlZddlmZ ddlmZ ddl
m Z zddl m
Z W n� ey� zddlmZ W nf ey� zddlmZ W nB ey� zddlmZ W n ey� ddlmZ Y n0 Y n0 Y n0 Y n0 dZej�d �Zed
d � �ZG d d
� d
ej�Zdd� ZG dd� d�Z G dd� d�Z G dd� d�Z G dd� dej �Z e�rje Z!ne Z!dS )z#Threading primitives and utilities.� N)�contextmanager)� TIMEOUT_MAX��Proxy)�
getcurrent)� get_ident)�bgThread�Local�
LocalStack� LocalManagerr �default_socket_timeout�USE_FAST_LOCALSc c s& t �� }t �| � dV t �|� dS )z7Context temporarily setting the default socket timeout.N)�socket�getdefaulttimeout�setdefaulttimeout)�timeout�prev� r �>/usr/local/lib/python3.9/site-packages/celery/utils/threads.pyr # s
r c sJ e Zd ZdZd� fdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z � Z
S )r zBackground service thread.Nc s6 t � �� t�� | _t�� | _d| _|p.| jj| _ d S )NT)
�super�__init__� threading�Event�_bgThread__is_shutdown�_bgThread__is_stopped�daemon� __class__�__name__�name)�selfr �kwargs�r r r r / s
zbgThread.__init__c C s
t � �d S �N)�NotImplementedError�r r r r �body6 s z
bgThread.bodyc O s& t |j|� tjd� t�d tj� d S )N)�file)�print�format�sys�stderr� traceback� print_exc)r �msg�fmtr r r r �on_crash9 s zbgThread.on_crashc C s� | j }| jj}z�|� s�z
|� W q ty� } zTz0| �d| j|� | �� W tj� � t
� d� ntj� � t
� d� 0 W Y d }~qd }~0 0 qW | �� n
| �� 0 d S )Nz{0!r} crashed: {1!r}� ) r% r �is_set� Exceptionr/ r � _set_stoppedr) r* �flush�os�_exit)r r% Z shutdown_set�excr r r �run= s
�
&z bgThread.runc C s& z| j �� W n ty Y n0 d S r" )r �set� TypeErrorr$ r r r r3 N s zbgThread._set_stoppedc C s* | j �� | j�� | �� r&| �t� dS )zGraceful shutdown.N)r r9 r �wait�is_alive�join�THREAD_TIMEOUT_MAXr$ r r r �stopV s
z
bgThread.stop)N) r �
__module__� __qualname__�__doc__r r% r/ r8 r3 r? �
__classcell__r r r! r r , s r c C s | � � dS )a- Release the contents of the local for the current context.
This makes it possible to use locals without a manager.
With this function one can release :class:`Local` objects as well as
:class:`StackLocal` objects. However it's not possible to
release data held by proxies that way, one always has to retain
a reference to the underlying local object in order to be able
to release it.
Example:
>>> loc = Local()
>>> loc.foo = 42
>>> release_local(loc)
>>> hasattr(loc, 'foo')
False
N)�__release_local__)�localr r r �
release_local^ s rF c @ sL e Zd ZdZdZdd� Zdd� Zdd� Zd d
� Zd d � Z d
d� Z
dd� Z dS )r z
Local object.)� __storage__�__ident_func__c C s t �| di � t �| dt� d S )NrG rH )�object� __setattr__r r$ r r r r x s zLocal.__init__c C s t | j�� �S r" )�iterrG �itemsr$ r r r �__iter__| s zLocal.__iter__c C s
t | |�S )zCreate a proxy for a name.r )r �proxyr r r �__call__ s zLocal.__call__c C s | j �| �� d � d S r" )rG �poprH r$ r r r rD � s zLocal.__release_local__c C s4 z| j | �� | W S ty. t|��Y n0 d S r" �rG rH �KeyError�AttributeError�r r r r r � __getattr__� s zLocal.__getattr__c C sB | � � }| j}z||| |< W n ty< ||i||< Y n0 d S r" )rH rG rR )r r �value�identZstorager r r rJ � s zLocal.__setattr__c C s4 z| j | �� |= W n ty. t|��Y n0 d S r" rQ rT r r r � __delattr__� s zLocal.__delattr__N) r r@ rA rB � __slots__r rM rO rD rU rJ rX r r r r r s s r c @ sv e Zd ZdZdd� Zdd� Zdd� Zdd � Zeee�Z [[d
d � Z
d d
� Z dd� Z dd� Z
edd� �Zedd� �ZdS )� _LocalStacka� Local stack.
This class works similar to a :class:`Local` but keeps a stack
of objects instead. This is best explained with an example::
>>> ls = LocalStack()
>>> ls.push(42)
>>> ls.top
42
>>> ls.push(23)
>>> ls.top
23
>>> ls.pop()
23
>>> ls.top
42
They can be force released by using a :class:`LocalManager` or with
the :func:`release_local` function but the correct way is to pop the
item from the stack after using. When the stack is empty it will
no longer be bound to the current context (and as such released).
By calling the stack without arguments it will return a proxy that
resolves to the topmost item on the stack.
c C s t � | _d S r" )r �_localr$ r r r r � s z_LocalStack.__init__c C s | j �� d S r" )r[ rD r$ r r r rD � s z _LocalStack.__release_local__c C s | j jS r" )r[ rH r$ r r r �_get__ident_func__� s z _LocalStack._get__ident_func__c C s t �| jd|� d S �NrH )rI rJ r[ )r rV r r r �_set__ident_func__� s z _LocalStack._set__ident_func__c s � fdd�}t |�S )Nc s � j } | d u rtd��| S )Nzobject unbound)�top� RuntimeError)�rvr$ r r �_lookup� s z%_LocalStack.__call__.<locals>._lookupr )r rb r r$ r rO � s z_LocalStack.__call__c C s0 t | jdd�}|du r"g | j_}|�|� |S )z Push a new item to the stack.�stackN)�getattrr[ rc �append)r �objra r r r �push� s
z_LocalStack.pushc C sD t | jdd�}|du rdS t|�dkr8t| j� |d S |�� S dS )z�Remove the topmost item from the stack.
Note:
Will return the old value or `None` if the stack was already empty.
rc Nr0 ���)rd r[ �lenrF rP �r rc r r r rP � s
z_LocalStack.popc C s t | jdd �}|rt|�S dS )Nrc r )rd r[ ri rj r r r �__len__� s z_LocalStack.__len__c C s t | jdd �}|d ur|S g S )Nrc )rd r[ rj r r r rc � s z_LocalStack.stackc C s, z| j jd W S ttfy& Y dS 0 dS )ztThe topmost item on the stack.
Note:
If the stack is empty, :const:`None` is returned.
rh N)r[ rc rS �
IndexErrorr$ r r r r_ � s z_LocalStack.topN)r r@ rA rB r rD r\ r^ �propertyrH rO rg rP rk rc r_ r r r r rZ � s
rZ c @ s2 e Zd ZdZd dd�Zdd� Zdd� Zd d
� ZdS ) r a� Local objects cannot manage themselves.
For that you need a local manager.
You can pass a local manager multiple locals or add them
later by appending them to ``manager.locals``. Every time the manager
cleans up, it will clean up all the data left in the locals for this
context.
The ``ident_func`` parameter can be added to override the default ident
function for the wrapped locals.
Nc C sb |d u rg | _ n t|t�r$|g| _ n
t|�| _ |d urX|| _| j D ]}t�|d|� qBnt| _d S r] )�locals�
isinstancer �list�
ident_funcrI rJ r )r rn rq rE r r r r s
zLocalManager.__init__c C s | � � S )a4 Return context identifier.
This is the identifier the local objects use internally
for this context. You cannot override this method to change the
behavior but use it to link other context local objects (such as
SQLAlchemy's scoped sessions) to the Werkzeug locals.
)rq r$ r r r r s zLocalManager.get_identc C s | j D ] }t|� qdS )z�Manually clean up the data in the locals for this context.
Call this at the end of the request or use ``make_middleware()``.
N)rn rF )r rE r r r �cleanup$ s
zLocalManager.cleanupc C s d� | jjt| j��S )Nz<{} storages: {}>)r( r r ri rn r$ r r r �__repr__, s �zLocalManager.__repr__)NN)r r@ rA rB r r rr rs r r r r r � s
r c s0 e Zd Z� fdd�Zedd� �Zdd� Z� ZS )�_FastLocalStackc s( g | _ | j j| _| j j| _t� �� d S r" )rc re rg rP r r r$ r! r r r 3 s
z_FastLocalStack.__init__c C s* z | j d W S ttfy$ Y d S 0 d S )Nrh )rc rS rl r$ r r r r_ 9 s z_FastLocalStack.topc C s
t | j�S r" )ri rc r$ r r r rk @ s z_FastLocalStack.__len__)r r@ rA r rm r_ rk rC r r r! r rt 1 s
rt )"rB r5 r r) r r+ �
contextlibr r r> Z celery.localr Zgreenletr r � ImportError�_thread�thread�
_dummy_thread� dummy_thread�__all__�environ�getr
r �Threadr rF r rZ r rE rt r
r r r r �<module> sD $
2(d2