# 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)