Ë
|
|
çúhØ1 ã ó d dl Z d dlZd dlZd dlZd dlmZmZ d dlm Z m
|
Z
|
d dl m Z m Z d dlmZ e j e« Z G d d« Zy)é N)ÚSimpleNamespaceÚ TracebackType)ÚOptionalÚType)Ú LockErrorÚLockNotOwnedError)ÚNumberc ób e Zd ZdZdZdZdZdZdZdZ d#de
|
de e de d e d
|
e e d e d e fd Zd$dZd%dZde ee de e de e ddfdZ d&de e d e e d
|
e e de e
|
fdZde
|
de fdZde fdZde fdZd$dZde
|
ddfd Zd'd e d e de fd Zd e d e de fd Z de fd!Z de fd"Z y)(Ú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
|
ÚnameÚtimeoutÚsleepÚblockingÚblocking_timeoutÚ thread_localÚraise_on_release_errorc ó& || _ || _ || _ || _ || _ || _ t |« | _ || _ | j rt j « n t « | _
|
d| j _ | j « y)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.
|
|
``raise_on_release_error`` indicates whether to raise an exception when
|
the lock is no longer owned when exiting the context manager. By default,
|
this is True, meaning an exception will be raised. If False, the warning
|
will be logged and the exception will be suppressed.
|
|
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)Úredisr r r r r Úboolr r Ú threadingÚlocalr ÚtokenÚregister_scripts) Úselfr r r r r r r r s õ] H:\项ç®\archive\æµè¯ç»\èæ¬\Change_password\venv_build\Lib\site-packages\redis/lock.pyÚ__init__z Lock.__init__O sx ðD
|
Ø Ø Ø
|
Ø Ø 0Ô Ü Ó .ÔØ&<Ô#Ø*.×*;Ò*;Y__Ô&Ä ÓAR
|
Ø
|
|
ÔØ × Ñ Õ ó Úreturnc ó> | j }| j }|j |j |j « |_ |j
|
|j |j « |_ |j !|j |j « |_ y y )N) Ú __class__r Ú lua_releaseÚregister_scriptÚLUA_RELEASE_SCRIPTÚ
|
lua_extendÚLUA_EXTEND_SCRIPTÚ lua_reacquireÚLUA_REACQUIRE_SCRIPT)r ÚclsÚclients r r zLock.register_scripts s ØnnØØ ??Ð "Ø $× 4Ñ 4°S×5KÑ5KÓ LCOØ >>Ð !Ø #× 3Ñ 3°C×4IÑ4IÓ JCNØ × Ñ Ð $Ø &× 6Ñ 6°s×7OÑ7OÓ PCÕ ð %r c óT | j « r| S t d| j ¬« )Nz0Unable to acquire lock within the time specified©Ú lock_name)Úacquirer r ©r s r Ú __enter__zLock.__enter__§ s' Ø <<>ØKÜØ >Øiiô
|
ð
|
r Úexc_typeÚ exc_valueÚ tracebackc ó | j « y # t $ r% | j r t j d« Y y w xY w)NzBLock was unlocked or no longer owned when exiting context manager.)Úreleaser r ÚloggerÚwarning)r r0 r1 r2 s r Ú__exit__z Lock.__exit__¯ s: ð Ø LLNøÜò Ø×*Ò*ØÜ NNØTö ð ús +AÁ Ar c óø | | j }|-t j « j j « }n+| j
|
j « }|j |« }| | j }| | j }d}|t j « |z } | j |« r|| j _ y|syt j « |z }|||kD ryt j |« [)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.
|
NTF)r ÚuuidÚuuid1ÚhexÚencoder Ú get_encoderr r Úmod_timeÚ monotonicÚ
|
do_acquirer r )r r r r r ÚencoderÚstop_trying_atÚ next_try_ats r r- z Lock.acquire¾ sé ð, =ØJJEØ =ÜJJL×$Ñ$×+Ñ+Ó-Eàjj×,Ñ,Ó.GØNN 5Ó)EØ Ð Ø}}HØ Ð #Ø #× 4Ñ 4Ð Ø Ø Ð 'Ü %× /Ñ /Ó 1Ð4DÑ DNØØuÔ%Ø#(
|
|
Ô ØÙØ Ü"×,Ñ,Ó.°Ñ6KØ Ð)¨k¸NÒ.JØ Ü NN5Ô !ð r c ó¦ | j rt | j dz « }nd }| j j | j |d|¬« ryy)Néè T)ÚnxÚpxF)r Úintr Úsetr )r r r s r r@ zLock.do_acquireí sC Ø <<ä$,,¨Ñ-Ó.GàGØ ::>>$)) U¨t¸>Ô @ØØr c óP | j j | j « duS )zU
|
Returns True if this key is locked by any process, otherwise False.
|
N)r Úgetr r. s r Úlockedz Lock.locked÷ s ð zz~~diiÓ(°Ð4Ð4r c ó, | j j | j « }|r;t |t « s+| j j « }|j |« }| j j duxr || j j k( S )zS
|
Returns True if this key is locked by this lock, otherwise False.
|
N) r rK r Ú
|
isinstanceÚbytesr= r< r r )r Ú stored_tokenrA s r Úownedz
|
Lock.ownedý sq ð zz~~ d§i¡iÓ0 ñ ¤
|
¨<¼Ô ?Øjj×,Ñ,Ó.GØ">>¨,Ó7LØzz× Ñ tÐ+ÒP° ÀÇ
|
Á
|
×@PÑ@PÑ0PÐPr c ó¦ | j j }|t d| j ¬« d| j _ | j |« y)z4
|
Releases the already acquired lock
|
Nz>Cannot release a lock that's not owned or is already unlocked.r+ )r r r r Ú
|
do_release©r Úexpected_tokens r r4 z Lock.release sJ ð ×)Ñ)Ø Ð !ÜØPØ ))ôð ð
|
|
ÔØ Õ'r rU c ó t | j | j g|g| j ¬« « st d| j ¬« y )N©ÚkeysÚargsr) z,Cannot release a lock that's no longer ownedr+ )r r! r r r rT s r rS zLock.do_release sJ ÜØ × Ñ 4§9¡9 +°^Ð4DÈTÏZÉZÐ Ó Xô
|
ô $Ø>Ø ))ôð ð
|
r Úadditional_timeÚ replace_ttlc óÆ | j j t d| j ¬« | j t d| j ¬« | j ||« 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`.
|
z Cannot extend an unlocked lockr+ z$Cannot extend a lock with no timeout)r r r r r Ú do_extend©r rZ r[ s r Úextendz Lock.extend sS ð ::× Ñ Ð #ÜÐ <ÈÏ É ÔRÐ RØ <<Ð ÜÐ BÈdÏiÉiÔXÐ XØ~~o¨{Ó;Ð;r c óè t |dz « }t | j | j g| j j
|
||rdndg| j ¬« « st d| j ¬« y)NrE Ú1Ú0rW z+Cannot extend a lock that's no longer ownedr+ T)rH r r$ r r r r r r^ s r r] zLock.do_extend0 sq Ü o°Ñ 4Ó5ÜØ OOØii[Øjj×&Ñ&¨Á ¹ÐQTÐUØzzð ó ô
|
ô $Ø=Ø ))ôð ð r c ó | j j t d| j ¬« | j t d| j ¬« | j « S )zS
|
Resets a TTL of an already acquired lock back to a timeout value.
|
z!Cannot reacquire an unlocked lockr+ z'Cannot reacquire a lock with no timeout)r r r r r Ú do_reacquirer. s r Ú reacquirezLock.reacquire? sX ð ::× Ñ Ð #ÜÐ ?È4Ï9É9ÔUÐ UØ <<Ð ÜØ9Ø ))ôð ð × Ñ Ó"Ð"r c óò t | j dz « }t | j | j g| j
|
j |g| j ¬« « st d| j ¬« y)NrE rW z.Cannot reacquire a lock that's no longer ownedr+ T) rH r r r& r r r r r )r r s r rd zLock.do_reacquireL sn Üdll TÑ)Ó*ÜØ × Ñ Øii[¨¯
|
©
|
×(8Ñ(8¸'Ð'BÈ4Ï:É:ð ó ô
|
ô
|
$Ø@Ø ))ôð ð r )Ng¹?TNTT)r N)r r )NNNN)F) Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r! r$ r& r# r% r' Ústrr r r r r r/ r Ú BaseExceptionr r7 r- r@ rL rQ r4 rS r_ r] re rd © r r r r sÉ ñð KØJØMð
|
Ðð Ðð2 Ðð %)ØØ Ø-1Ø !Ø'+ñL ð ðL ð &Ñ!ð L ð
|
ð L ð ð L ð # 6Ñ*ðL ð ðL ð !%óL ó\Qó
|
ð à4 Ñ.Ñ/ð ð MÑ*ð ð MÑ*ð ð
|
|
ó ð" #'Ø#'Ø-1Ø #ñ -"àÑ ð-"ð 4.ð-"ð # 6Ñ*ð -"ð
|
}ó -"ð^ ð ¨ó ð5ó 5ð
|
Qtó
|
Qó (ð¨ð °ó ñ< fð <¸4ð <ÈDó <ð" ¨ð ¸dð Àtó ð #4ó #ð dô r r )Úloggingr Útimer> r9 Útypesr r Útypingr r Úredis.exceptionsr r Ú redis.typingr Ú getLoggerrg r5 r rm r r ú<module>ru s; ðÛ Û Û Û ß 0ß !ç 9Ý à × Ñ 8Ó $÷Iò Ir
|
