1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
Metadata-Version: 2.1
Name: aioredlock
Version: 0.7.3
Summary: Asyncio implemetation of Redis distributed locks
Home-page: https://github.com/joanvila/aioredlock
Author: Joan Vilà Cuñat
Author-email: vila.joan94@gmail.com
License: MIT
Keywords: redis redlock distributed locks asyncio
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Requires-Python: >=3.6
Provides-Extra: cicd
Provides-Extra: examples
Provides-Extra: package
Provides-Extra: test
License-File: LICENSE.md
aioredlock
==========
.. image:: https://github.com/joanvila/aioredlock/workflows/Tests/badge.svg
:target: https://travis-ci.org/joanvila/aioredlock
.. image:: https://codecov.io/gh/joanvila/aioredlock/branch/master/graph/badge.svg
:target: https://codecov.io/gh/joanvila/aioredlock
.. image:: https://badge.fury.io/py/aioredlock.svg
:target: https://pypi.python.org/pypi/aioredlock
The asyncio redlock_ algorithm implementation.
Redlock and asyncio
-------------------
The redlock algorithm is a distributed lock implementation for Redis_. There are many implementations of it in several languages. In this case, this is the asyncio_ compatible implementation for python 3.5+.
Usage
-----
.. code-block:: python
from aioredlock import Aioredlock, LockError, Sentinel
# Define a list of connections to your Redis instances:
redis_instances = [
('localhost', 6379),
{'host': 'localhost', 'port': 6379, 'db': 1},
'redis://localhost:6379/2',
Sentinel(('localhost', 26379), master='leader', db=3),
Sentinel('redis://localhost:26379/4?master=leader&encoding=utf-8'),
Sentinel('rediss://:password@localhost:26379/5?master=leader&encoding=utf-8&ssl_cert_reqs=CERT_NONE'),
]
# Create a lock manager:
lock_manager = Aioredlock(redis_instances)
# Check wether a resourece acquired by any other redlock instance:
assert not await lock_manager.is_locked("resource_name")
# Try to acquire the lock:
try:
lock = await lock_manager.lock("resource_name", lock_timeout=10)
except LockError:
print('Lock not acquired')
raise
# Now the lock is acquired:
assert lock.valid
assert await lock_manager.is_locked("resource_name")
# Extend lifetime of the lock:
await lock_manager.extend(lock, lock_timeout=10)
# Raises LockError if the lock manager can not extend the lock lifetime
# on more then half of the Redis instances.
# Release the lock:
await lock_manager.unlock(lock)
# Raises LockError if the lock manager can not release the lock
# on more then half of redis instances.
# The released lock become invalid:
assert not lock.valid
assert not await lock_manager.is_locked("resource_name")
# Or you can use the lock as async context manager:
try:
async with await lock_manager.lock("resource_name") as lock:
assert lock.valid is True
# Do your stuff having the lock
await lock.extend() # alias for lock_manager.extend(lock)
# Do more stuff having the lock
assert lock.valid is False # lock will be released by context manager
except LockError:
print('Lock not acquired')
raise
# Clear the connections with Redis:
await lock_manager.destroy()
How it works
------------
The Aioredlock constructor accepts the following optional parameters:
- ``redis_connections``: A list of connections (dictionary of host and port and kwargs for ``aioredis.create_redis_pool()``, or tuple ``(host, port)``, or string Redis URI) where the Redis instances are running. The default value is ``[{'host': 'localhost', 'port': 6379}]``.
- ``retry_count``: An integer representing number of maximum allowed retries to acquire the lock. The default value is ``3`` times.
- ``retry_delay_min`` and ``retry_delay_max``: Float values representing waiting time (in seconds) before the next retry attempt. The default values are ``0.1`` and ``0.3``, respectively.
In order to acquire the lock, the ``lock`` function should be called. If the lock operation is successful, ``lock.valid`` will be true, if the lock is not acquired then the ``LockError`` will be raised.
From that moment, the lock is valid until the ``unlock`` function is called or when the ``lock_timeout`` is reached.
Call the ``extend`` function to reset lifetime of the lock to ``lock_timeout`` interval.
Use the ``is_locked`` function to check if the resource is locked by other redlock instance.
In order to clear all the connections with Redis, the lock_manager ``destroy`` method can be called.
To-do
-----
.. _redlock: https://redis.io/topics/distlock
.. _Redis: https://redis.io
.. _asyncio: https://docs.python.org/3/library/asyncio.html
|
