Skip to content

fix(lock): implement Redlock single-instance pattern in LockManagerService#537

Open
romanetar wants to merge 1 commit intomainfrom
fix/release-on-failed-acquire-and-add-ownership-tokens
Open

fix(lock): implement Redlock single-instance pattern in LockManagerService#537
romanetar wants to merge 1 commit intomainfrom
fix/release-on-failed-acquire-and-add-ownership-tokens

Conversation

@romanetar
Copy link
Copy Markdown
Collaborator

@romanetar romanetar commented May 4, 2026

ref https://app.clickup.com/t/86b9f3a22

Recommended actions for a follow-up ticket:

  1. Move the SendAttendeeInvitationEmail::dispatch call outside the lock callback (dispatch after the lock is released).
  2. Consider a tighter explicit lifetime (e.g. 30 s) that matches the realistic worst-case DB write time rather than the 3600 s default.
  3. Fix the missing . in the key: 'ticket_type.' . $type_id . '.promo_code.' . $promo_code_val . '.sell.lock'.

Summary by CodeRabbit

  • New Features

    • Added atomic compare-and-delete for cache entries.
    • Locks now use per-call ownership tokens and only release when owned.
    • Lock acquisition uses exponential backoff with retries.
  • Tests

    • Added tests verifying lock ownership, no-op release when not acquired, proper cleanup of tokens, and single-attempt lock creation.

@coderabbitai
Copy link
Copy Markdown

coderabbitai Bot commented May 4, 2026

Review Change Stack

📝 Walkthrough

Walkthrough

The PR adds an atomic compare-and-delete cache method to the ICacheService, implements it in Redis via a Lua eval, updates Redis conditional set usages, and refactors LockManagerService to use per-call random ownership tokens, exponential backoff for acquisition, and ownership-aware releases; tests validate the ownership behavior.

Changes

Ownership-Based Distributed Locking

Layer / File(s) Summary
Interface Contract
Libs/Utils/ICacheService.php
New deleteIfValueMatches(string $key, string $expectedValue): bool method declares atomic compare-and-delete semantics for conditional key deletion.
Redis Conditional Sets
app/Services/Utils/RedisCacheService.php
incCounter and addSingleValue now use SET ... NX (with optional EX) for init/set-if-missing; TTL applied only on successful conditional set.
Atomic Redis Delete
app/Services/Utils/RedisCacheService.php
Added deleteIfValueMatches implemented with a Lua EVAL script to atomically compare the stored value and delete when equal; wrapped with existing retry logic.
LockManager State
app/Services/Utils/LockManagerService.php
Introduces private $tokens map and adjusted backoff constants/comments.
Acquire with Token & Backoff
app/Services/Utils/LockManagerService.php
acquireLock() generates a per-call random token, retries addSingleValue with exponential backoff, stores token on success, and throws UnacquiredLockException after retries.
Ownership-aware Release
app/Services/Utils/LockManagerService.php
releaseLock() checks token ownership and calls deleteIfValueMatches(name, token) only when owned, then unsets the token; otherwise it's a no-op.
Wrapper Guarding Release
app/Services/Utils/LockManagerService.php
lock() sets an $acquired flag and only calls releaseLock() in finally when acquisition succeeded.
Tests / Verification
tests/Unit/Services/LockManagerServiceOwnershipTest.php
New tests assert failed acquirers do not delete others' locks, release without acquire is a no-op, tokens are cleared after successful cycles, and addSingleValue is invoked once with token and lifetime.

Sequence Diagram

sequenceDiagram
    participant Client
    participant LMS as LockManagerService
    participant RCS as RedisCacheService
    participant Redis

    rect rgba(100, 150, 200, 0.5)
    Note over Client,Redis: Lock Acquisition (Success Path)
    Client->>LMS: acquireLock(name, lifetime)
    LMS->>LMS: Generate token = random_bytes(16)
    loop Exponential Backoff Retry Loop
        LMS->>RCS: addSingleValue(name, token, lifetime)
        RCS->>Redis: SET name token NX EX lifetime
        Redis-->>RCS: OK (or nil)
        alt First attempt succeeds
            RCS-->>LMS: true
            LMS->>LMS: Store $tokens[name] = token
            LMS-->>Client: Acquisition complete
        else Retry needed
            RCS-->>LMS: false
            LMS->>LMS: Sleep with exponential backoff
        end
    end
    end

    rect rgba(200, 150, 100, 0.5)
    Note over Client,Redis: Lock Release (Ownership Check)
    Client->>LMS: releaseLock(name)
    LMS->>LMS: Check $tokens[name] exists?
    alt Owned by this process
        LMS->>RCS: deleteIfValueMatches(name, token)
        RCS->>Redis: EVAL Lua script (compare & delete)
        Redis->>Redis: GET name == token?
        alt Values match
            Redis->>Redis: DEL name
            Redis-->>RCS: 1 (deleted)
        else Mismatch (lock stolen)
            Redis-->>RCS: 0 (not deleted)
        end
        RCS-->>LMS: true/false
        LMS->>LMS: Unset $tokens[name]
        LMS-->>Client: Released
    else Not owned
        LMS-->>Client: Return (no-op)
    end
    end
Loading

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~45 minutes

Poem

🐰 I nibble tokens in the night,
Small bytes of luck that hold on tight,
Lua checks and backoff leaps,
No stolen keys in midnight keeps,
Owners sleep while rabbits write.

🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 warning)

Check name Status Explanation Resolution
Docstring Coverage ⚠️ Warning Docstring coverage is 58.82% which is insufficient. The required threshold is 80.00%. Write docstrings for the functions missing them to satisfy the coverage threshold.
✅ Passed checks (4 passed)
Check name Status Explanation
Description Check ✅ Passed Check skipped - CodeRabbit’s high-level summary is enabled.
Title check ✅ Passed The title directly describes the main implementation: adding Redlock single-instance pattern with ownership tokens to LockManagerService, which aligns with the core changes in the PR (token-based lock ownership, atomic compare-and-delete, retry logic).
Linked Issues check ✅ Passed Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check ✅ Passed Check skipped because no linked issues were found for this pull request.

✏️ Tip: You can configure your own custom pre-merge checks in the settings.

✨ Finishing Touches
📝 Generate docstrings
  • Create stacked PR
  • Commit on current branch
🧪 Generate unit tests (beta)
  • Create PR with unit tests
  • Commit unit tests in branch fix/release-on-failed-acquire-and-add-ownership-tokens

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

Comment @coderabbitai help to get the list of available commands and usage tips.

@github-actions
Copy link
Copy Markdown

github-actions Bot commented May 4, 2026

📘 OpenAPI / Swagger preview

➡️ https://OpenStackweb.github.io/summit-api/openapi/pr-537/

This page is automatically updated on each push to this PR.

@romanetar romanetar requested a review from smarcet May 4, 2026 14:42
Copy link
Copy Markdown

@coderabbitai coderabbitai Bot left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🧹 Nitpick comments (1)
app/Services/Utils/LockManagerService.php (1)

62-70: 💤 Low value

Minor: Unnecessary sleep before throwing on final retry.

When attempt >= MaxRetries - 1, the code still executes usleep before throwing. This adds ~400ms of unnecessary delay on the final failed attempt.

Consider moving the retry check before the sleep:

Suggested reorder
-        $wait_interval = (int)(self::BackOffBaseInterval * (self::BackOffMultiplier ** $attempt));
-        Log::debug(sprintf("LockManagerService::acquireLock name %s retrying in %s µs (attempt %s)", $name, $wait_interval, $attempt));
-        usleep($wait_interval);
         if ($attempt >= (self::MaxRetries - 1)) {
             Log::error(sprintf("LockManagerService::acquireLock name %s lifetime %s ERROR MAX RETRIES attempt %s", $name, $lifetime, $attempt));
             throw new UnacquiredLockException(sprintf("lock name %s", $name));
         }
+        $wait_interval = (int)(self::BackOffBaseInterval * (self::BackOffMultiplier ** $attempt));
+        Log::debug(sprintf("LockManagerService::acquireLock name %s retrying in %s µs (attempt %s)", $name, $wait_interval, $attempt));
+        usleep($wait_interval);
         ++$attempt;
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.

In `@app/Services/Utils/LockManagerService.php` around lines 62 - 70, The loop in
LockManagerService::acquireLock sleeps (usleep) even when $attempt >=
(self::MaxRetries - 1), causing an unnecessary delay before throwing
UnacquiredLockException; reorder the logic so the check for final retry (if
$attempt >= (self::MaxRetries - 1)) occurs before calling usleep and before
incrementing $attempt, log and throw immediately on final attempt, otherwise
perform the usleep, increment $attempt and continue the loop to preserve backoff
behavior.
🤖 Prompt for all review comments with AI agents
Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@app/Services/Utils/LockManagerService.php`:
- Around line 62-70: The loop in LockManagerService::acquireLock sleeps (usleep)
even when $attempt >= (self::MaxRetries - 1), causing an unnecessary delay
before throwing UnacquiredLockException; reorder the logic so the check for
final retry (if $attempt >= (self::MaxRetries - 1)) occurs before calling usleep
and before incrementing $attempt, log and throw immediately on final attempt,
otherwise perform the usleep, increment $attempt and continue the loop to
preserve backoff behavior.

ℹ️ Review info
⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: a4fb76b4-55ed-4ec3-a248-fdf0d070fc95

📥 Commits

Reviewing files that changed from the base of the PR and between c39160a and b3dbd7a.

📒 Files selected for processing (4)
  • Libs/Utils/ICacheService.php
  • app/Services/Utils/LockManagerService.php
  • app/Services/Utils/RedisCacheService.php
  • tests/Unit/Services/LockManagerServiceOwnershipTest.php

…rvice

Signed-off-by: romanetar <roman_ag@hotmail.com>
@romanetar romanetar force-pushed the fix/release-on-failed-acquire-and-add-ownership-tokens branch from b3dbd7a to acb8447 Compare May 7, 2026 17:33
@github-actions
Copy link
Copy Markdown

github-actions Bot commented May 7, 2026

📘 OpenAPI / Swagger preview

➡️ https://OpenStackweb.github.io/summit-api/openapi/pr-537/

This page is automatically updated on each push to this PR.

Copy link
Copy Markdown

@coderabbitai coderabbitai Bot left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🧹 Nitpick comments (1)
tests/Unit/Services/LockManagerServiceOwnershipTest.php (1)

139-144: 💤 Low value

Consider asserting the token is non-empty for stronger ownership guarantee coverage.

Mockery::type('string') accepts any string including ''. A complementary assertion with Mockery::on(fn($v) => strlen($v) >= 16) (or similar) would confirm the service is actually generating a meaningful random token rather than an empty or trivial value.

♻️ Tighter token constraint
-              ->with('test.lock', Mockery::type('string'), 3600)
+              ->with('test.lock', Mockery::on(fn(string $v) => strlen($v) >= 16), 3600)
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@tests/Unit/Services/LockManagerServiceOwnershipTest.php` around lines 139 -
144, Replace the loose Mockery::type('string') expectation in
LockManagerServiceOwnershipTest (the mock of ICacheService used with
addSingleValue) with a stricter constraint that asserts the token is
non-empty/strong (e.g. Mockery::on(fn($v) => is_string($v) && strlen($v) >= 16))
or add an additional expectation using Mockery::on to verify token length,
keeping the same call to addSingleValue and the deleteIfValueMatches
expectation; target the mock for addSingleValue on the ICacheService to ensure
the generated token is meaningful rather than allowing an empty string.
🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Nitpick comments:
In `@tests/Unit/Services/LockManagerServiceOwnershipTest.php`:
- Around line 139-144: Replace the loose Mockery::type('string') expectation in
LockManagerServiceOwnershipTest (the mock of ICacheService used with
addSingleValue) with a stricter constraint that asserts the token is
non-empty/strong (e.g. Mockery::on(fn($v) => is_string($v) && strlen($v) >= 16))
or add an additional expectation using Mockery::on to verify token length,
keeping the same call to addSingleValue and the deleteIfValueMatches
expectation; target the mock for addSingleValue on the ICacheService to ensure
the generated token is meaningful rather than allowing an empty string.

ℹ️ Review info
⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: 757f3521-79bb-45c3-a48d-09cc2ce97243

📥 Commits

Reviewing files that changed from the base of the PR and between b3dbd7a and acb8447.

📒 Files selected for processing (4)
  • Libs/Utils/ICacheService.php
  • app/Services/Utils/LockManagerService.php
  • app/Services/Utils/RedisCacheService.php
  • tests/Unit/Services/LockManagerServiceOwnershipTest.php
🚧 Files skipped from review as they are similar to previous changes (3)
  • app/Services/Utils/RedisCacheService.php
  • app/Services/Utils/LockManagerService.php
  • Libs/Utils/ICacheService.php

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant