redlock-py

Warnings

• gotcha The underlying Redlock algorithm has been subject to significant academic and practical critique regarding its safety guarantees, particularly concerning system clock skew, long garbage collection pauses, and the absence of fencing tokens. These issues can potentially lead to violations of mutual exclusion under certain failure conditions.
  Fix: Understand the limitations of Redlock and assess if its 'correctness vs. efficiency' trade-offs are acceptable for your use case. For applications requiring strong correctness guarantees, consider alternative distributed consensus systems like ZooKeeper or etcd, or implement application-level fencing.
• gotcha redlock-py requires a Redis client library (e.g., `redis-py`) to communicate with Redis. This dependency is not automatically installed with `pip install redlock-py` and must be installed separately.
  Fix: Ensure `redis` is installed in your environment: `pip install redlock-py redis`.
• gotcha For the Redlock algorithm to provide its intended fault tolerance and mutual exclusion properties, it *must* be configured with multiple independent Redis instances (an odd number like 3 or 5 is common). Using a single Redis instance or a master-replica setup defeats its purpose and can lead to race conditions due to asynchronous replication.
  Fix: Deploy and configure `redlock-py` with a list of connection details for at least three independent Redis masters. Do not rely on master-replica replication for Redlock's fault tolerance.
• gotcha redlock-py does not natively implement 'fencing tokens,' which are crucial for preventing 'stale' clients (those that experience a pause and mistakenly believe they still hold a lock after it has expired) from writing to shared resources. This can lead to data corruption.
  Fix: If correctness is paramount, consider augmenting your system with an external mechanism for fencing tokens, or use a distributed lock system that inherently provides this feature.
• gotcha The project exhibits low maintenance activity. The PyPI description was last updated in 2016, and the linked GitHub repository shows the last commit in 2021. This might indicate a lack of ongoing support, bug fixes, or compatibility updates for newer Python or Redis versions.
  Fix: Evaluate the project's suitability for long-term production use. Be prepared to maintain the library internally or consider more actively maintained alternatives if regular updates and support are critical.

Install

• pip install redlock-py redis Install redlock-py and Redis client

Imports

• Redlock

  from redlock import Redlock

Quickstart

This quickstart demonstrates how to acquire and release a distributed lock using `redlock-py` with a context manager. It initializes the Redlock manager with Redis connection details and attempts to lock a resource. For a robust Redlock implementation, it's crucial to configure multiple independent Redis instances; the example uses a single instance for simplicity.

import os
from redlock import Redlock
import redis

# Configure Redis connection(s)
# For a true Redlock setup, use multiple independent Redis instances.
# For quickstart, a single local instance is shown.
REDIS_HOST = os.environ.get('REDIS_HOST', 'localhost')
REDIS_PORT = int(os.environ.get('REDIS_PORT', 6379))
REDIS_DB = int(os.environ.get('REDIS_DB', 0))

redis_nodes = [
    {"host": REDIS_HOST, "port": REDIS_PORT, "db": REDIS_DB}
    # For production, add more independent Redis nodes, e.g.:
    # {"host": "redis2.example.com", "port": 6379, "db": 0},
    # {"host": "redis3.example.com", "port": 6379, "db": 0},
]

# Initialize the Redlock manager
dlm = Redlock(redis_nodes)

resource_name = "my_critical_resource"
lock_validity_time_ms = 5000 # Lock will be valid for 5 seconds

try:
    # Acquire the lock using a context manager (recommended)
    print(f"Attempting to acquire lock for '{resource_name}'...")
    with dlm.lock(resource_name, lock_validity_time_ms) as my_lock:
        if my_lock:
            print(f"Lock '{resource_name}' acquired! (Validity: {my_lock.validity}ms)")
            # Your critical section code goes here
            print("Executing critical section...")
            # Simulate work
            import time
            time.sleep(2)
            print("Critical section complete.")
        else:
            print(f"Could not acquire lock for '{resource_name}'. Another process may hold it.")
except redis.exceptions.ConnectionError as e:
    print(f"Error connecting to Redis: {e}. Make sure Redis is running.")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

print("Finished redlock-py quickstart example.")