tasks/DIST6_distributed_lock/spec.md

DIST6: Distributed Lock

Goal

A Python implementation of a Redis-style distributed lock has 4 correctness bugs that cause data corruption under real-world conditions (GC pauses, network delays, concurrent access). Fix all bugs while keeping existing tests green.

Requirements

1. Fix all 4 bugs in distributed_lock.py
2. All existing tests must continue to pass: pytest tests/
3. The lock must be safe under GC pauses, network delays, and concurrent clients

Bug 1: No Fencing Token

The acquire() method returns True/False but does not return a fencing token (monotonically increasing integer). Without a fencing token, a client that experiences a GC pause cannot prove it still holds the lock when it resumes. A second client may have acquired and released the lock during the pause, and the first client's writes corrupt shared state.

Fix: acquire() must return a fencing token (or None on failure). The token must be a monotonically increasing integer stored alongside the lock. Protected resources should reject operations with stale fencing tokens.

Bug 2: Stale TTL Calculation

The acquire() method captures start_time = time.time() at the beginning, then sets the lock with ttl = start_time + lock_timeout. If the network round-trip to the backend takes significant time, the actual TTL remaining after the lock is set is shorter than expected. Under high latency, the lock may expire before the client finishes its critical section.

Fix: capture the time AFTER the lock is successfully set, or subtract the elapsed time from the TTL.

Bug 3: Fixed Retry Delay

When acquire() fails due to contention, it retries after a fixed delay (e.g., 100ms). Under high contention, multiple clients retry simultaneously, creating thundering herd. The retry should use exponential backoff with jitter.

Fix: replace fixed delay with exponential backoff (e.g., base * 2^attempt) plus random jitter.

Bug 4: Release Without Ownership Check

The release() method deletes the lock key without checking whether the calling client is the current lock holder. If Client A's lock expires, Client B acquires it, then Client A calls release(), it deletes Client B's lock.

Fix: store the owner identity with the lock and only delete if the caller matches the current owner.

Supporting Files

• distributed_lock.py — lock implementation (4 bugs)
• mock_redis.py — simulated Redis backend for testing
• tests/test_lock.py — existing tests (must all pass)
• config.py — lock configuration (TTL, retry settings, node names)