Implement RedisLock: replace stub with full go-redis/v9 distributed lock

[Copilot]

RedisLock in scale/distributed_lock.go was a non-functional stub returning errors on every call. This implements it fully using github.com/redis/go-redis/v9.

Core implementation

• Acquire — SET key <token> NX PX <ttl> with exponential backoff (16ms→512ms cap) until acquired or ctx cancelled
• TryAcquire — single SET NX attempt; returns (nil, false, nil) cleanly when held (no error)
• Release — Lua check-and-delete ensures only the token holder can release; sync.Once-guarded for idempotency
• Close() — closes the underlying Redis client connection
• Lazy client init via sync.Once on first Acquire/TryAcquire call

New constructor

// Original still works (password="", db=0)
lock := NewRedisLock("localhost:6379")

// Full options
lock := NewRedisLockWithOptions("localhost:6379", "password", 1)

Dependencies

• github.com/redis/go-redis/v9 promoted from indirect → direct
• github.com/alicebob/miniredis/v2 added for tests (in-memory Redis, no real server needed)

Tests

Replaces the stub-error test with coverage of: acquire+release cycle, TryAcquire free/held, idempotent release, wrong-holder Lua safety, TTL expiry via miniredis.FastForward, and context cancellation.

Original prompt

Problem

The scale/distributed_lock.go file contains a RedisLock struct that is a complete stub. Both Acquire() and TryAcquire() return "redis lock not implemented" errors. The PostgreSQL advisory lock implementation (PGAdvisoryLock) in the same file is fully functional, but Redis is not.

Current Code

// scale/distributed_lock.go

// RedisLock implements DistributedLock using Redis SET NX with TTL.
// Requires a Redis client connection. This is a stub implementation;
// the full implementation will be provided when the Redis client is
// integrated as a direct dependency.
type RedisLock struct {
    addr string
}

func NewRedisLock(addr string) *RedisLock {
    return &RedisLock{addr: addr}
}

func (l *RedisLock) Acquire(_ context.Context, key string, _ time.Duration) (func(), error) {
    return nil, fmt.Errorf("redis lock not implemented: configure Redis client for key %s at %s", key, l.addr)
}

func (l *RedisLock) TryAcquire(_ context.Context, key string, _ time.Duration) (func(), bool, error) {
    return nil, false, fmt.Errorf("redis lock not implemented: configure Redis client for key %s at %s", key, l.addr)
}

Requirements

1. Add github.com/redis/go-redis/v9 to go.mod.

2. Implement RedisLock with proper distributed locking:

   • Acquire(ctx, key, ttl):
     • Use SET key value NX PX ttl_ms to acquire the lock.
     • The value should be a unique token (UUID or random string) to ensure only the holder can release.
     • If the lock is already held, retry with exponential backoff until context is cancelled.
     • Return a release function that uses a Lua script to atomically check-and-delete:

       if redis.call("get", KEYS[1]) == ARGV[1] then
           return redis.call("del", KEYS[1])
       else
           return 0
       end

   • TryAcquire(ctx, key, ttl):
     • Same as Acquire but only try once — no retry.
     • Return (release, true, nil) if acquired, (nil, false, nil) if not acquired (no error).

3. Add a Close() method to clean up the Redis client connection.

4. Add connection configuration:

   • Support addr (already present), password, db (database number).
   • Create the Redis client in a Connect() or lazily on first Acquire.

5. Write tests in scale/distributed_lock_test.go:

   • Use github.com/alicebob/miniredis/v2 for an in-memory Redis server (no real Redis needed).
   • Test Acquire + release cycle.
   • Test TryAcquire when lock is free → acquires.
   • Test TryAcquire when lock is held → returns false without error.
   • Test that release function is idempotent (calling twice doesn't panic or error).
   • Test that a different holder cannot release the lock (Lua script safety).
   • Test TTL expiry (miniredis supports FastForward).

6. Ensure all existing tests pass (go test ./...).

7. Follow the same DistributedLock interface that PGAdvisoryLock implements in the same file.

This pull request was created from Copilot chat.

---

🔒 GitHub Advanced Security automatically protects Copilot coding agent pull requests. You can protect all pull requests by enabling Advanced Security for your repositories. Learn more about Advanced Security.