File: //lib/python3.9/site-packages/redis/asyncio/__pycache__/lock.cpython-39.pyc
a
��b
. � @ sv d dl Z d dlZd dlZd dlZd dlmZ d dlmZmZm Z m
Z
d dl m Z m
Z
erdd dlmZ G dd� d�ZdS )� N)�SimpleNamespace)�
TYPE_CHECKING� Awaitable�Optional�Union)� LockError�LockNotOwnedError)�Redisc @ s2 e Zd ZdZdZdZdZdZdZdZ d,de
e e e
f ee eeee ed �d
d �Zd d
� Zdd� Zdd� Zd-ee ee ee
e e f d�dd�Ze
e e f ed�dd�Zed�dd�Zed�dd �Zed d�d d �Ze dd �d d!�Zd.eeee d#�d$d%�Z ed�d&d'�Z ee d�d(d)�Z ed�d*d+�Z dS )/�Lockz�
A shared, distributed Lock. Using Redis for locking allows the Lock
to be shared across processes and/or machines.
It's left to the user to resolve deadlock issues and make sure
multiple clients play nicely together.
Nz�
local token = redis.call('get', KEYS[1])
if not token or token ~= ARGV[1] then
return 0
end
redis.call('del', KEYS[1])
return 1
a�
local token = redis.call('get', KEYS[1])
if not token or token ~= ARGV[1] then
return 0
end
local expiration = redis.call('pttl', KEYS[1])
if not expiration then
expiration = 0
end
if expiration < 0 then
return 0
end
local newttl = ARGV[2]
if ARGV[3] == "0" then
newttl = ARGV[2] + expiration
end
redis.call('pexpire', KEYS[1], newttl)
return 1
z�
local token = redis.call('get', KEYS[1])
if not token or token ~= ARGV[1] then
return 0
end
redis.call('pexpire', KEYS[1], ARGV[2])
return 1
皙�����?Tr )�redis�name�timeout�sleep�blocking�blocking_timeout� thread_localc C sX || _ || _|| _|| _|| _|| _t|�| _| jr<t� � nt
� | _ d| j _ | � � dS )a�
Create a new Lock instance named ``name`` using the Redis client
supplied by ``redis``.
``timeout`` indicates a maximum life for the lock in seconds.
By default, it will remain locked until release() is called.
``timeout`` can be specified as a float or integer, both representing
the number of seconds to wait.
``sleep`` indicates the amount of time to sleep in seconds per loop
iteration when the lock is in blocking mode and another client is
currently holding the lock.
``blocking`` indicates whether calling ``acquire`` should block until
the lock has been acquired or to fail immediately, causing ``acquire``
to return False and the lock not being acquired. Defaults to True.
Note this value can be overridden by passing a ``blocking``
argument to ``acquire``.
``blocking_timeout`` indicates the maximum amount of time in seconds to
spend trying to acquire the lock. A value of ``None`` indicates
continue trying forever. ``blocking_timeout`` can be specified as a
float or integer, both representing the number of seconds to wait.
``thread_local`` indicates whether the lock token is placed in
thread-local storage. By default, the token is placed in thread local
storage so that a thread only sees its token, not a token set by
another thread. Consider the following timeline:
time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds.
thread-1 sets the token to "abc"
time: 1, thread-2 blocks trying to acquire `my-lock` using the
Lock instance.
time: 5, thread-1 has not yet completed. redis expires the lock
key.
time: 5, thread-2 acquired `my-lock` now that it's available.
thread-2 sets the token to "xyz"
time: 6, thread-1 finishes its work and calls release(). if the
token is *not* stored in thread local storage, then
thread-1 would see the token value as "xyz" and would be
able to successfully release the thread-2's lock.
In some use cases it's necessary to disable thread local storage. For
example, if you have code where one thread acquires a lock and passes
that lock instance to a worker thread to release later. If thread
local storage isn't disabled in this case, the worker thread won't see
the token set by the thread that acquired the lock. Our assumption
is that these cases aren't common and as such default to using
thread local storage.
N)
r r
r r r r �boolr � threading�localr �token�register_scripts)�selfr r
r r r r r � r �6/usr/lib/python3.9/site-packages/redis/asyncio/lock.py�__init__O s <
z
Lock.__init__c C sX | j }| j}|jd u r$|�|j�|_|jd u r<|�|j�|_|jd u rT|�|j�|_d S �N) � __class__r � lua_releaseZregister_script�LUA_RELEASE_SCRIPT�
lua_extend�LUA_EXTEND_SCRIPT�
lua_reacquire�LUA_REACQUIRE_SCRIPT)r �cls�clientr r r r � s
zLock.register_scriptsc � s | � � I d H r| S td��d S )Nz0Unable to acquire lock within the time specified)�acquirer �r r r r �
__aenter__� s zLock.__aenter__c � s | � � I d H d S r )�release)r �exc_type� exc_value� tracebackr r r � __aexit__� s zLock.__aexit__)r r r c � s� t jdd� dkr t�� }nt�� }| j}|du rBt�� j� � }n| j
j � � }|� |�}|du rf| j
}|du rt| j}d}|dur�|�� | }| �|�I dH r�|| j_dS |s�dS |�� | }|dur�||kr�dS t�|�I dH q�dS )as
Use Redis to hold a shared, distributed lock named ``name``.
Returns True once the lock is acquired.
If ``blocking`` is False, always return immediately. If the lock
was acquired, return True, otherwise return False.
``blocking_timeout`` specifies the maximum number of seconds to
wait trying to acquire the lock.
``token`` specifies the token value to be used. If provided, token
must be a bytes object or a string that can be encoded to a bytes
object with the default encoding. If a token isn't specified, a UUID
will be generated.
r � )� � NTF)�sys� version_info�asyncioZget_running_loopZget_event_loopr �uuidZuuid1�hex�encoder �connection_pool� get_encoderr r �time�
do_acquirer r ) r r r r Zloopr �encoderZstop_trying_atZ next_try_atr r r r& � s0
z Lock.acquire)r �returnc � s> | j rt| j d �}nd }| jj| j|d|d�I d H r:dS dS )N�� T)ZnxZpxF)r �intr �setr
)r r r r r r r: � s zLock.do_acquire)r< c � s | j �| j�I dH duS )zU
Returns True if this key is locked by any process, otherwise False.
N)r �getr
r' r r r �locked� s z Lock.lockedc � sP | j �| j�I dH }|r8t|t�s8| j j�� }|�|�}| jj duoN|| jj kS )zS
Returns True if this key is locked by this lock, otherwise False.
N)
r r@ r
�
isinstance�bytesr7 r8 r6 r r )r Z stored_tokenr; r r r �owned� s
z
Lock.ownedc C s* | j j}|du rtd��d| j _| �|�S )z"Releases the already acquired lockNz Cannot release an unlocked lock)r r r �
do_release�r �expected_tokenr r r r) � s
z Lock.release)rG r< c � s. t | j| jg|g| jd�I d H �s*td��d S )N��keys�argsr% z,Cannot release a lock that's no longer owned)r r r
r r rF r r r rE � s �
�zLock.do_releaseF)�additional_time� replace_ttlr< c C s2 | j jdu rtd��| jdu r&td��| �||�S )ah
Adds more time to an already acquired lock.
``additional_time`` can be specified as an integer or a float, both
representing the number of seconds to add.
``replace_ttl`` if False (the default), add `additional_time` to
the lock's existing ttl. If True, replace the lock's ttl with
`additional_time`.
Nz Cannot extend an unlocked lockz$Cannot extend a lock with no timeout)r r r r � do_extend�r rK rL r r r �extend s
z Lock.extendc � sJ t |d �}t| j| jg| jj||r(dp*dg| jd�I d H �sFtd��dS )Nr= �1�0rH z+Cannot extend a lock that's no longer ownedT)r> r r r
r r r r rN r r r rM s �
�zLock.do_extendc C s. | j jdu rtd��| jdu r&td��| �� S )zS
Resets a TTL of an already acquired lock back to a timeout value.
Nz!Cannot reacquire an unlocked lockz'Cannot reacquire a lock with no timeout)r r r r � do_reacquirer' r r r � reacquire% s
zLock.reacquirec � sB t | jd �}t| j| jg| jj|g| jd�I d H �s>td��dS )Nr= rH z.Cannot reacquire a lock that's no longer ownedT) r> r r r" r
r r r r )r r r r r rR / s �
�zLock.do_reacquire)Nr TNT)NNN)F) �__name__�
__module__� __qualname__�__doc__r r r" r r! r# r �strrC �
memoryviewr �floatr r r r( r- r& r: rA rD r r) rE rO rM rS rR r r r r r
sZ
� � G
�� 2
��
r
)r3 r1 r r4 �typesr �typingr r r r Zredis.exceptionsr r Z
redis.asyncior r
r r r r �<module> s