refactor: refactored CriticalSection

feat: added support for nonblocking mode

src/CriticalSection.php

@@ -2,37 +2,42 @@
 
 namespace PetrKnap\CriticalSection;
 
+use PetrKnap\CriticalSection\Exception\CouldNotEnterCriticalSection;
+use PetrKnap\CriticalSection\Exception\CouldNotLeaveCriticalSection;
 use Symfony\Component\Lock\Exception\LockAcquiringException;
 use Symfony\Component\Lock\Exception\LockConflictedException;
 use Symfony\Component\Lock\Exception\LockReleasingException;
 use Symfony\Component\Lock\LockInterface;
 
-final class CriticalSection
+final class CriticalSection implements CriticalSectionInterface
 {
     protected function __construct(
         private LockInterface $lock,
+        private bool $isLocking,
     ) {
     }
 
-    public static function withLock(LockInterface $lock): self
+    public static function withLock(LockInterface $lock, bool $isBlocking = true): CriticalSectionInterface
     {
-        return new self($lock);
+        return new self($lock, $isBlocking);
     }
 
-    public function __invoke(callable $callable, mixed ...$args): mixed
+    public function __invoke(callable $criticalSection)
     {
         try {
-            $this->lock->acquire(true);
+            if($this->lock->acquire(blocking: $this->isLocking) === false) {
+                return null;
+            }
         } catch (LockConflictedException | LockAcquiringException $acquiringException) {
-            throw new CriticalSectionCouldNotAcquireLock(previous: $acquiringException);
+            throw new CouldNotEnterCriticalSection(previous: $acquiringException);
         }
         try {
-            return $callable(...$args);
+            return $criticalSection();
         } finally {
             try {
                 $this->lock->release();
             } catch (LockReleasingException $releasingException) {
-                throw new CriticalSectionCouldNotReleaseLock(previous: $releasingException);
+                throw new CouldNotLeaveCriticalSection(previous: $releasingException);
             }
         }
     }

src/CriticalSectionInterface.php

@@ -0,0 +1,22 @@
+<?php declare(strict_types=1);
+
+namespace PetrKnap\CriticalSection;
+
+use PetrKnap\CriticalSection\Exception\CouldNotEnterCriticalSection;
+use PetrKnap\CriticalSection\Exception\CouldNotLeaveCriticalSection;
+use Throwable;
+
+/**
+ * @template T
+ */
+interface CriticalSectionInterface
+{
+    /**
+     * @param callable(): T $criticalSection
+     * @return ?T from the critical section
+     * @throws CouldNotEnterCriticalSection
+     * @throws CouldNotLeaveCriticalSection
+     * @throws Throwable from the critical section
+     */
+    public function __invoke(callable $criticalSection);
+}

src/Exception/CouldNotEnterCriticalSection.php

@@ -0,0 +1,9 @@
+<?php declare(strict_types=1);
+
+namespace PetrKnap\CriticalSection\Exception;
+
+use RuntimeException;
+
+final class CouldNotEnterCriticalSection extends RuntimeException implements CriticalSectionException
+{
+}

src/Exception/CouldNotLeaveCriticalSection.php

@@ -0,0 +1,9 @@
+<?php declare(strict_types=1);
+
+namespace PetrKnap\CriticalSection\Exception;
+
+use RuntimeException;
+
+final class CouldNotLeaveCriticalSection extends RuntimeException implements CriticalSectionException
+{
+}

src/CriticalSectionException.php → src/Exception/CriticalSectionException.php

@@ -1,6 +1,6 @@
 <?php declare(strict_types=1);
 
-namespace PetrKnap\CriticalSection;
+namespace PetrKnap\CriticalSection\Exception;
 
 interface CriticalSectionException
 {

tests/CriticalSectionTest.php

@@ -1,17 +1,22 @@
-<?php declare(strict_types=1);
+<?php /** @noinspection PhpUnhandledExceptionInspection */
+
+declare(strict_types=1);
 
 namespace PetrKnap\CriticalSection;
 
 use Exception;
+use PetrKnap\CriticalSection\Exception\CouldNotEnterCriticalSection;
+use PetrKnap\CriticalSection\Exception\CouldNotLeaveCriticalSection;
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Lock\Exception\LockAcquiringException;
 use Symfony\Component\Lock\Exception\LockConflictedException;
 use Symfony\Component\Lock\Exception\LockReleasingException;
 use Symfony\Component\Lock\LockInterface;
+use Symfony\Component\Lock\NoLock;
 
 class CriticalSectionTest extends TestCase
 {
-    public function testAcquiresLockBeforeCallableIsExecuted(): void
+    public function testAcquiresLockBeforeCriticalSectionIsExecuted(): void
     {
         $shared = new \stdClass();
         $lock = self::createMock(LockInterface::class);
@@ -27,21 +32,22 @@ public function testAcquiresLockBeforeCallableIsExecuted(): void
         });
     }
 
-    public function testReturnsValueReturnedByExecutedCallable(): void
+    public function testReturnsValueReturnedByExecutedCriticalSection(): void
     {
-        $lock = self::createMock(LockInterface::class);
+        $lock = new NoLock();
         $expected = new \stdClass();
 
         self::assertSame($expected, CriticalSection::withLock($lock)(function () use ($expected) {
             return $expected;
         }));
     }
 
-    public function testReleasesLockAfterCallableWasExecuted(): void
+    public function testReleasesLockAfterCriticalSectionWasExecuted(): void
     {
         $shared = new \stdClass();
         $shared->isLocked = true;
         $lock = self::createMock(LockInterface::class);
+        $lock->method('acquire')->willReturn(true);
         $lock->expects(self::once())
             ->method('release')
             ->willReturnCallback(function () use ($shared) {
@@ -55,11 +61,12 @@ public function testReleasesLockAfterCallableWasExecuted(): void
         self::assertFalse($shared->isLocked);
     }
 
-    public function testReleasesLockAndThrowsWhenCallableThrows(): void
+    public function testReleasesLockAndThrowsWhenCriticalSectionThrows(): void
     {
         $shared = new \stdClass();
         $shared->isLocked = true;
         $lock = self::createMock(LockInterface::class);
+        $lock->method('acquire')->willReturn(true);
         $lock->expects(self::once())
             ->method('release')
             ->willReturnCallback(function () use ($shared) {
@@ -79,6 +86,18 @@ public function testReleasesLockAndThrowsWhenCallableThrows(): void
         }
     }
 
+    public function testSkipsCriticalSectionWhenItIsOccupiedInNonBlockingMode(): void
+    {
+        $lock = self::createMock(LockInterface::class);
+        $lock->expects(self::once())
+            ->method('acquire')
+            ->willReturn(false);
+
+        self::assertNull(CriticalSection::withLock($lock)(function (): bool {
+            return true;
+        }));
+    }
+
     /** @dataProvider dataThrowsWhenLockThrowsOnAcquire */
     public function testThrowsWhenLockThrowsOnAcquire(Exception $lockException): void
     {
@@ -87,7 +106,7 @@ public function testThrowsWhenLockThrowsOnAcquire(Exception $lockException): voi
             ->method('acquire')
             ->willThrowException($lockException);
 
-        self::expectException(CriticalSectionCouldNotAcquireLock::class);
+        self::expectException(CouldNotEnterCriticalSection::class);
         CriticalSection::withLock($lock)(function () {
         });
     }
@@ -106,11 +125,12 @@ public static function dataThrowsWhenLockThrowsOnAcquire(): iterable
     public function testThrowsWhenLockThrowsOnRelease(): void
     {
         $lock = self::createMock(LockInterface::class);
+        $lock->method('acquire')->willReturn(true);
         $lock->expects(self::once())
             ->method('release')
             ->willThrowException(new LockReleasingException());
 
-        self::expectException(CriticalSectionCouldNotReleaseLock::class);
+        self::expectException(CouldNotLeaveCriticalSection::class);
         CriticalSection::withLock($lock)(function () {
         });
     }