�
L�g� � � � d dl Z d dlZd dlmZmZmZ d dlmZ G d� d� � Z G d� d� � Z G d� d e
� � Z dS )
� N)�Any�Dict�Union)� BaseCachec �~ � e Zd ZU dZi Zeeej f e d< de
dede e e
f fd�Zd� Zd� Zd � Zd
� Zd � Zd S )
�RedLockar
Implementation of `Redlock <https://redis.io/topics/distlock>`_
with a single instance because aiocache is focused on single
instance cache.
This locking has some limitations and shouldn't be used in
situations where consistency is critical. Those locks are aimed for
performance reasons where failing on locking from time to time
is acceptable. TLDR: do NOT use this if you need real resource
exclusion.
Couple of considerations with the implementation:
- If the lease expires and there are calls waiting, all of them
will pass (blocking just happens for the first time).
- When a new call arrives, it will wait always at most lease
time. This means that the call could end up blocked longer
than needed in case the lease from the blocker expires.
Backend specific implementation:
- Redis implements correctly the redlock algorithm. It sets
the key if it doesn't exist. To release, it checks the value
is the same as the instance trying to release and if it is,
it removes the lock. If not it will do nothing
- Memcached follows the same approach with a difference. Due
to memcached lacking a way to execute the operation get and
delete commands atomically, any client is able to release the
lock. This is a limitation that can't be fixed without introducing
race conditions.
- Memory implementation is not distributed, it will only apply
to the process running. Say you have 4 processes running
APIs with aiocache, the locking will apply only per process
(still useful to reduce load per process).
Example usage::
from aiocache import Cache
from aiocache.lock import RedLock
cache = Cache(Cache.REDIS)
async with RedLock(cache, 'key', lease=1): # Calls will wait here
result = await cache.get('key')
if result is not None:
return result
result = await super_expensive_function()
await cache.set('key', result)
In the example, first call will start computing the ``super_expensive_function``
while consecutive calls will block at most 1 second. If the blocking lasts for
more than 1 second, the calls will proceed to also calculate the
result of ``super_expensive_function``.
�_EVENTS�client�key�leasec �t � || _ | j � |dz � � | _ || _ d| _ d S )Nz-lock� )r
� build_keyr r �_value)�selfr
r r s �]/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/aiocache/lock.py�__init__zRedLock.__init__A s6 � � �� ��;�(�(��w� �7�7�����
��� � � � c � �: K � | � � � � d {V ��S �N��_acquire�r s r �
__aenter__zRedLock.__aenter__G �& � � � ��]�]�_�_�$�$�$�$�$�$�$r c � �Z K � t t j � � � � | _ | j � | j | j | j �� � � d {V �� t j � � t j | j < d S # t $ r | �
� � � d {V �� Y d S w xY w)N)�ttl)�str�uuid�uuid4r r
�_addr r �asyncio�Eventr r �
ValueError�_wait_for_releaser s r r zRedLock._acquireJ s� � � � ��$�*�,�,�'�'�� � +��+�"�"�4�8�T�[�d�j�"�I�I� I� I� I� I� I� I� I�(/�
���G�O�D�H� %� %� %��� +� +� +��(�(�*�*� *� *� *� *� *� *� *� *� *� *� +���s �AB �$B*�)B*c � �� K � t j t j | j � � � | j � � � d {V �� d S # t j $ r Y d S t $ r Y d S w xY wr ) r" �wait_forr r r �waitr � TimeoutError�KeyErrorr s r r% zRedLock._wait_for_releaseR s� � � � � ��"�7�?�4�8�#<�#A�#A�#C�#C�T�Z�P�P� P� P� P� P� P� P� P� P� P���#� � � � �D�D�� � � � �D�D� ���s �AA
�
A,� A,�+A,c � �> K � | � � � � d {V �� d S r )�_release�r �exc_type� exc_value� tracebacks r � __aexit__zRedLock.__aexit__Z s, � � � ��m�m�o�o� � � � � � � � � r c � �� K � | j � | j | j � � � d {V ��}|r8t j � | j � � � � � d S d S r )r
�_redlock_releaser r r r �pop�set)r �removeds r r, zRedLock._release] so � � � � � �4�4�T�X�t�{�K�K�K�K�K�K�K�K�� � 0� �O� � ��� )� )� -� -� /� /� /� /� /� 0� 0r N)�__name__�
__module__� __qualname__�__doc__r r r r" r# �__annotations__r r �int�floatr r r r% r1 r, � r r r r s� � � � � � � �4� 4�l )+�G�T�#�w�}�$�
%�*�*�*��y� �s� �5��e��;L� � � � � %� %� %�+� +� +�� � � � � �0� 0� 0� 0� 0r r c �H � e Zd ZdZdedefd�Zd� Zd� Zd� Z de
d e
d
e fd �Z d S )
�OptimisticLocka�
Implementation of
`optimistic lock <https://en.wikipedia.org/wiki/Optimistic_concurrency_control>`_
Optimistic locking assumes multiple transactions can happen at the same time
and they will only fail if before finish, conflicting modifications with other
transactions are found, producing a roll back.
Finding a conflict will end up raising an `aiocache.lock.OptimisticLockError`
exception. A conflict happens when the value at the storage is different from
the one we retrieved when the lock started.
Example usage::
cache = Cache(Cache.REDIS)
# The value stored in 'key' will be checked here
async with OptimisticLock(cache, 'key') as lock:
result = await super_expensive_call()
await lock.cas(result)
If any other call sets the value of ``key`` before the ``lock.cas`` is called,
an :class:`aiocache.lock.OptimisticLockError` will be raised. A way to make
the same call crash would be to change the value inside the lock like::
cache = Cache(Cache.REDIS)
# The value stored in 'key' will be checked here
async with OptimisticLock(cache, 'key') as lock:
result = await super_expensive_call()
await cache.set('random_value') # This will make the `lock.cas` call fail
await lock.cas(result)
If the lock is created with an unexisting key, there will never be conflicts.
r
r c �n � || _ || _ | j � |� � | _ d | _ d S r )r
r r �ns_key�_token)r r
r s r r zOptimisticLock.__init__� s2 � � �� �����k�+�+�C�0�0�� ��� � � r c � �: K � | � � � � d {V ��S r r r s r r zOptimisticLock.__aenter__� r r c � �^ K � | j � | j � � � d {V ��| _ | S r )r
�_getsrB rC r s r r zOptimisticLock._acquire� s6 � � � � �K� -� -�d�k� :� :�:�:�:�:�:�:�� �� r c � �
K � d S r r> r- s r r1 zOptimisticLock.__aexit__� s � � � � �r �value�kwargs�returnc � �x K � | j j | j |fd| j i|��� d{V ��}|st d� � �dS )a
Checks and sets the specified value for the locked key. If the value has changed
since the lock was created, it will raise an :class:`aiocache.lock.OptimisticLockError`
exception.
:raises: :class:`aiocache.lock.OptimisticLockError`
�
_cas_tokenNz(Value has changed since the lock startedT)r
r5 r rC �OptimisticLockError)r rH rI �successs r �caszOptimisticLock.cas� s^ � � � � (�� ����%�Z�Z�D�K�Z�SY�Z�Z�Z�Z�Z�Z�Z�Z��� R�%�&P�Q�Q� Q��tr N)
r7 r8 r9 r: r r r r r r1 r �boolrO r> r r r@ r@ c s� � � � � � �"� "�H�y� �s� � � � � %� %� %�� � �
�
�
� �s� �c� �d� � � � � � r r@ c � � e Zd ZdZdS )rM zC
Raised when a conflict is found during an optimistic lock
N)r7 r8 r9 r: r> r r rM rM � s � � � � � �� � � r rM ) r" r �typingr r r �
aiocache.baser r r@ � ExceptionrM r> r r �<module>rU s� �� ���� � � � � #� #� #� #� #� #� #� #� #� #� #� #� #� #� #� #�X0� X0� X0� X0� X0� X0� X0� X0�v@� @� @� @� @� @� @� @�F� � � � �)� � � � � r