Deduplicate code using global LockUtil

mvorisek · mvorisek · commit 70fd6d99a06b · 2024-12-06T15:37:06.000+01:00
diff --git a/README.md b/README.md
@@ -343,7 +343,7 @@ The **MySQLMutex** uses MySQL's
 [`GET_LOCK`](https://dev.mysql.com/doc/refman/9.0/en/locking-functions.html#function_get-lock)
 function.
 
-It supports time outs. If the connection to the database server is lost or
+It supports timeouts. If the connection to the database server is lost or
 interrupted, the lock is automatically released.
 
 Note that before MySQL 5.7.5 you cannot use nested locks, any new lock will
@@ -376,7 +376,7 @@ functions.
 Named locks are offered. PostgreSQL locking functions require integers but the
 conversion is handled automatically.
 
-No time outs are supported. If the connection to the database server is lost or
+No timeouts are supported. If the connection to the database server is lost or
 interrupted, the lock is automatically released.
 
 ```php
diff --git a/composer.json b/composer.json
@@ -35,7 +35,8 @@
     "homepage": "https://github.com/malkusch/lock",
     "require": {
         "php": ">=7.4 <8.4",
-        "psr/log": "^1.0 || ^2.0 || ^3.0"
+        "psr/log": "^1.0 || ^2.0 || ^3.0",
+        "symfony/polyfill-php80": "^1.28"
     },
     "require-dev": {
         "ext-memcached": "*",
diff --git a/src/mutex/FlockMutex.php b/src/mutex/FlockMutex.php
@@ -125,7 +125,7 @@ private function lockBusy(): void
     private function acquireNonBlockingLock(): bool
     {
         if (!flock($this->fileHandle, \LOCK_EX | \LOCK_NB, $wouldBlock)) {
-            if ($wouldBlock) { // @phpstan-ignore if.condNotBoolean
+            if ($wouldBlock === 1) {
                 // Another process holds the lock.
                 return false;
             }
diff --git a/src/mutex/MemcachedMutex.php b/src/mutex/MemcachedMutex.php
@@ -19,7 +19,7 @@ class MemcachedMutex extends SpinlockMutex
      * it has to be added with Memcached::addServer().
      *
      * @param string $name    The lock name
-     * @param float  $timeout The time in seconds a lock expires
+     * @param float  $timeout The timeout in seconds a lock expires
      *
      * @throws \LengthException The timeout must be greater than 0
      */
diff --git a/src/mutex/MySQLMutex.php b/src/mutex/MySQLMutex.php
@@ -32,7 +32,7 @@ public function __construct(\PDO $PDO, string $name, float $timeout = 0)
     #[\Override]
     public function lock(): void
     {
-        $statement = $this->pdo->prepare('SELECT GET_LOCK(?,?)');
+        $statement = $this->pdo->prepare('SELECT GET_LOCK(?, ?)');
 
         // MySQL rounds the value to whole seconds, sadly rounds, not ceils
         // TODO MariaDB supports microseconds precision since 10.1.2 version,
diff --git a/src/mutex/PHPRedisMutex.php b/src/mutex/PHPRedisMutex.php
@@ -26,7 +26,7 @@ class PHPRedisMutex extends RedisMutex
      * called already.
      *
      * @param array<\Redis|\RedisCluster> $redisAPIs
-     * @param float                       $timeout   The time in seconds a lock expires after
+     * @param float                       $timeout   The timeout in seconds a lock expires
      *
      * @throws \LengthException The timeout must be greater than 0
      */
diff --git a/src/mutex/PgAdvisoryLockMutex.php b/src/mutex/PgAdvisoryLockMutex.php
@@ -33,7 +33,7 @@ public function __construct(\PDO $PDO, string $name)
     #[\Override]
     public function lock(): void
     {
-        $statement = $this->pdo->prepare('SELECT pg_advisory_lock(?,?)');
+        $statement = $this->pdo->prepare('SELECT pg_advisory_lock(?, ?)');
 
         $statement->execute([
             $this->key1,
@@ -44,7 +44,7 @@ public function lock(): void
     #[\Override]
     public function unlock(): void
     {
-        $statement = $this->pdo->prepare('SELECT pg_advisory_unlock(?,?)');
+        $statement = $this->pdo->prepare('SELECT pg_advisory_unlock(?, ?)');
         $statement->execute([
             $this->key1,
             $this->key2,
diff --git a/src/mutex/PredisMutex.php b/src/mutex/PredisMutex.php
@@ -20,7 +20,7 @@ class PredisMutex extends RedisMutex
      * Sets the Redis connections.
      *
      * @param ClientInterface[] $clients The Redis clients
-     * @param float             $timeout The time in seconds a lock expires
+     * @param float             $timeout The timeout in seconds a lock expires
      *
      * @throws \LengthException The timeout must be greater than 0
      */
diff --git a/src/mutex/RedisMutex.php b/src/mutex/RedisMutex.php
@@ -6,6 +6,7 @@
 
 use malkusch\lock\exception\LockAcquireException;
 use malkusch\lock\exception\LockReleaseException;
+use malkusch\lock\util\LockUtil;
 use Psr\Log\LoggerAwareInterface;
 use Psr\Log\LoggerAwareTrait;
 use Psr\Log\NullLogger;
@@ -29,7 +30,7 @@ abstract class RedisMutex extends SpinlockMutex implements LoggerAwareInterface
      * Sets the Redis APIs.
      *
      * @param array<int, mixed> $redisAPIs
-     * @param float             $timeout   The time in seconds a lock expires
+     * @param float             $timeout   The timeout in seconds a lock expires
      *
      * @throws \LengthException The timeout must be greater than 0
      */
@@ -50,7 +51,7 @@ protected function acquire(string $key, float $expire): bool
         // 2.
         $acquired = 0;
         $errored = 0;
-        $this->token = bin2hex(random_bytes(16)) . md5((string) $time);
+        $this->token = LockUtil::getInstance()->makeRandomToken();
         $exception = null;
         foreach ($this->redisAPIs as $index => $redisAPI) {
             try {
@@ -106,8 +107,8 @@ protected function release(string $key): bool
          *
          * @link https://redis.io/commands/set
          */
-        $script = 'if redis.call("get",KEYS[1]) == ARGV[1] then
-                return redis.call("del",KEYS[1])
+        $script = 'if redis.call("get", KEYS[1]) == ARGV[1] then
+                return redis.call("del", KEYS[1])
             else
                 return 0
             end
diff --git a/src/mutex/SpinlockMutex.php b/src/mutex/SpinlockMutex.php
@@ -7,6 +7,7 @@
 use malkusch\lock\exception\ExecutionOutsideLockException;
 use malkusch\lock\exception\LockAcquireException;
 use malkusch\lock\exception\LockReleaseException;
+use malkusch\lock\util\LockUtil;
 use malkusch\lock\util\Loop;
 
 /**
@@ -16,9 +17,6 @@
  */
 abstract class SpinlockMutex extends LockMutex
 {
-    /** The prefix for the lock key. */
-    private const PREFIX = 'php-malkusch-lock:';
-
     /** @var float The timeout in seconds a lock may live */
     private $timeout;
 
@@ -34,15 +32,15 @@ abstract class SpinlockMutex extends LockMutex
     /**
      * Sets the timeout.
      *
-     * @param float $timeout The time in seconds a lock expires
+     * @param float $timeout The timeout in seconds a lock expires
      *
      * @throws \LengthException The timeout must be greater than 0
      */
     public function __construct(string $name, float $timeout = 3)
     {
         $this->timeout = $timeout;
         $this->loop = new Loop($this->timeout);
-        $this->key = self::PREFIX . $name;
+        $this->key = LockUtil::getInstance()->getKeyPrefix() . ':' . $name;
     }
 
     #[\Override]
@@ -52,7 +50,7 @@ protected function lock(): void
             $this->acquired = microtime(true);
 
             /*
-             * The expiration time for the lock is increased by one second
+             * The expiration timeout for the lock is increased by one second
              * to ensure that we delete only our keys. This will prevent the
              * case that this key expires before the timeout, and another process
              * acquires successfully the same key which would then be deleted
diff --git a/src/util/LockUtil.php b/src/util/LockUtil.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace malkusch\lock\util;
+
+/**
+ * @internal
+ */
+class LockUtil
+{
+    private static ?self $instance = null;
+
+    private function __construct() {}
+
+    final public static function getInstance(): self
+    {
+        if (self::$instance === null) {
+            self::$instance = new self();
+        }
+
+        return self::$instance;
+    }
+
+    /**
+     * @return non-falsy-string
+     */
+    final public function getKeyPrefix(): string
+    {
+        return 'php-malkusch-lock';
+    }
+
+    /**
+     * @return non-falsy-string
+     */
+    public function makeRandomToken(): string
+    {
+        do {
+            $randomBytes = random_bytes(16);
+            $token = bin2hex($randomBytes) . md5($randomBytes . microtime());
+        } while (str_starts_with($token, '0'));
+
+        return $token;
+    }
+
+    /**
+     * @return non-falsy-string
+     */
+    public function makeRandomTemporaryFilePath(string $name = ''): string
+    {
+        return sys_get_temp_dir() . \DIRECTORY_SEPARATOR
+            . $this->getKeyPrefix() . '-'
+            . ($name !== '' ? str_replace(['/', '\\', ':'], '-', $name) . '-' : '')
+            . $this->makeRandomToken() . '.txt';
+    }
+}
diff --git a/src/util/Loop.php b/src/util/Loop.php
@@ -79,7 +79,7 @@ public function execute(callable $code)
     {
         $this->looping = true;
 
-        // At this time, the lock will time out.
+        // At this time, the lock will timeout.
         $deadline = microtime(true) + $this->timeout;
 
         $result = null;
diff --git a/src/util/PcntlTimeout.php b/src/util/PcntlTimeout.php
@@ -45,7 +45,7 @@ public function __construct(int $timeout)
     }
 
     /**
-     * Runs the code and would eventually time out.
+     * Runs the code and would eventually timeout.
      *
      * This method has the side effect, that any signal handler for SIGALRM will
      * be reset to the default hanlder (SIG_DFL). It also expects that there is
diff --git a/tests/mutex/FlockMutexTest.php b/tests/mutex/FlockMutexTest.php
@@ -8,6 +8,7 @@
 use malkusch\lock\exception\DeadlineException;
 use malkusch\lock\exception\TimeoutException;
 use malkusch\lock\mutex\FlockMutex;
+use malkusch\lock\util\LockUtil;
 use malkusch\lock\util\PcntlTimeout;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
@@ -25,7 +26,8 @@ protected function setUp(): void
     {
         parent::setUp();
 
-        $this->file = tempnam(sys_get_temp_dir(), 'flock-');
+        $this->file = LockUtil::getInstance()->makeRandomTemporaryFilePath('flock');
+        touch($this->file);
         $this->mutex = Liberator::liberate(new FlockMutex(fopen($this->file, 'r'), 1)); // @phpstan-ignore assign.propertyType
     }
 
diff --git a/tests/mutex/MutexConcurrencyTest.php b/tests/mutex/MutexConcurrencyTest.php
@@ -14,6 +14,7 @@
 use malkusch\lock\mutex\PredisMutex;
 use malkusch\lock\mutex\SemaphoreMutex;
 use malkusch\lock\mutex\TransactionalMutex;
+use malkusch\lock\util\LockUtil;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\Constraint\IsType;
 use PHPUnit\Framework\TestCase;
@@ -116,7 +117,7 @@ public function testHighContention(\Closure $code, \Closure $mutexFactory, ?\Clo
     public static function provideHighContentionCases(): iterable
     {
         foreach (static::provideExecutionIsSerializedWhenLockedCases() as $name => [$mutexFactory]) {
-            $filename = tempnam(sys_get_temp_dir(), 'php-lock-high-contention');
+            $filename = LockUtil::getInstance()->makeRandomTemporaryFilePath('test-mutex-concurrency');
 
             static::$temporaryFiles[] = $filename;
 
@@ -224,7 +225,7 @@ public function testExecutionIsSerializedWhenLocked(\Closure $mutexFactory): voi
      */
     public static function provideExecutionIsSerializedWhenLockedCases(): iterable
     {
-        $filename = tempnam(sys_get_temp_dir(), 'mutex-concurrency-test');
+        $filename = LockUtil::getInstance()->makeRandomTemporaryFilePath('test-mutex-concurrency');
 
         self::$temporaryFiles[] = $filename;
 
diff --git a/tests/mutex/MutexTest.php b/tests/mutex/MutexTest.php
@@ -169,7 +169,7 @@ static function ($uri) {
                 $pdo = new \PDO(getenv('MYSQL_DSN'), getenv('MYSQL_USER'), getenv('MYSQL_PASSWORD'));
                 $pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
 
-                return new MySQLMutex($pdo, 'test' . time(), self::TIMEOUT);
+                return new MySQLMutex($pdo, 'test', self::TIMEOUT);
             }];
         }
 
diff --git a/tests/mutex/PgAdvisoryLockMutexTest.php b/tests/mutex/PgAdvisoryLockMutexTest.php
@@ -38,7 +38,7 @@ public function testAcquireLock(): void
 
         $this->pdo->expects(self::once())
             ->method('prepare')
-            ->with('SELECT pg_advisory_lock(?,?)')
+            ->with('SELECT pg_advisory_lock(?, ?)')
             ->willReturn($statement);
 
         $statement->expects(self::once())
@@ -70,7 +70,7 @@ public function testReleaseLock(): void
 
         $this->pdo->expects(self::once())
             ->method('prepare')
-            ->with('SELECT pg_advisory_unlock(?,?)')
+            ->with('SELECT pg_advisory_unlock(?, ?)')
             ->willReturn($statement);
 
         $statement->expects(self::once())
diff --git a/tests/util/LockUtilTest.php b/tests/util/LockUtilTest.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace malkusch\lock\Tests\util;
+
+use malkusch\lock\util\LockUtil;
+use PHPUnit\Framework\TestCase;
+
+class LockUtilTest extends TestCase
+{
+    public function testGetInstance(): void
+    {
+        $instance = LockUtil::getInstance();
+
+        self::assertSame(LockUtil::class, get_class($instance));
+        self::assertSame($instance, LockUtil::getInstance());
+    }
+
+    public function testGetKeyPrefix(): void
+    {
+        self::assertSame('php-malkusch-lock', LockUtil::getInstance()->getKeyPrefix());
+    }
+
+    public function testMakeRandomToken(): void
+    {
+        $tokens = [];
+        for ($i = 0; $i < 1_000; ++$i) {
+            $token = LockUtil::getInstance()->makeRandomToken();
+            self::assertMatchesRegularExpression('~^(?!0)[0-9a-f]{64}$~', $token);
+
+            $tokens[] = $token;
+        }
+
+        self::assertSame($tokens, array_unique($tokens));
+    }
+
+    public function testMakeRandomTemporaryFilePath(): void
+    {
+        $pathPrefixRegex = preg_quote(sys_get_temp_dir() . \DIRECTORY_SEPARATOR . LockUtil::getInstance()->getKeyPrefix(), '~');
+
+        $paths = [];
+        for ($i = 0; $i < 1_000; ++$i) {
+            $path = LockUtil::getInstance()->makeRandomTemporaryFilePath();
+            self::assertMatchesRegularExpression('~^' . $pathPrefixRegex . '-\w{64}.txt$~', $path);
+
+            $paths[] = $path;
+        }
+
+        self::assertSame($paths, array_unique($paths));
+
+        self::assertMatchesRegularExpression('~^' . $pathPrefixRegex . '-foo-\w{64}.txt$~', LockUtil::getInstance()->makeRandomTemporaryFilePath('foo'));
+        self::assertMatchesRegularExpression('~^' . $pathPrefixRegex . '-fo-o-\w{64}.txt$~', LockUtil::getInstance()->makeRandomTemporaryFilePath('fo/o'));
+        self::assertMatchesRegularExpression('~^' . $pathPrefixRegex . '-fo-o-\w{64}.txt$~', LockUtil::getInstance()->makeRandomTemporaryFilePath('fo\o'));
+        self::assertMatchesRegularExpression('~^' . $pathPrefixRegex . '-fo-o-\w{64}.txt$~', LockUtil::getInstance()->makeRandomTemporaryFilePath('fo:o'));
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,7 @@ private function lockBusy(): void`
`125`	`125`	`private function acquireNonBlockingLock(): bool`
`126`	`126`	`{`
`127`	`127`	`if (!flock($this->fileHandle, \LOCK_EX \| \LOCK_NB, $wouldBlock)) {`
`128`		`- if ($wouldBlock) { // @phpstan-ignore if.condNotBoolean`
	`128`	`+ if ($wouldBlock === 1) {`
`129`	`129`	`// Another process holds the lock.`
`130`	`130`	`return false;`
`131`	`131`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ class MemcachedMutex extends SpinlockMutex`
`19`	`19`	`* it has to be added with Memcached::addServer().`
`20`	`20`	`*`
`21`	`21`	`* @param string $name The lock name`
`22`		`- * @param float $timeout The time in seconds a lock expires`
	`22`	`+ * @param float $timeout The timeout in seconds a lock expires`
`23`	`23`	`*`
`24`	`24`	`* @throws \LengthException The timeout must be greater than 0`
`25`	`25`	`*/`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ public function __construct(\PDO $PDO, string $name, float $timeout = 0)`
`32`	`32`	`#[\Override]`
`33`	`33`	`public function lock(): void`
`34`	`34`	`{`
`35`		`- $statement = $this->pdo->prepare('SELECT GET_LOCK(?,?)');`
	`35`	`+ $statement = $this->pdo->prepare('SELECT GET_LOCK(?, ?)');`
`36`	`36`
`37`	`37`	`// MySQL rounds the value to whole seconds, sadly rounds, not ceils`
`38`	`38`	`// TODO MariaDB supports microseconds precision since 10.1.2 version,`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ class PHPRedisMutex extends RedisMutex`
`26`	`26`	`* called already.`
`27`	`27`	`*`
`28`	`28`	`* @param array<\Redis\|\RedisCluster> $redisAPIs`
`29`		`- * @param float $timeout The time in seconds a lock expires after`
	`29`	`+ * @param float $timeout The timeout in seconds a lock expires`
`30`	`30`	`*`
`31`	`31`	`* @throws \LengthException The timeout must be greater than 0`
`32`	`32`	`*/`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ class PredisMutex extends RedisMutex`
`20`	`20`	`* Sets the Redis connections.`
`21`	`21`	`*`
`22`	`22`	`* @param ClientInterface[] $clients The Redis clients`
`23`		`- * @param float $timeout The time in seconds a lock expires`
	`23`	`+ * @param float $timeout The timeout in seconds a lock expires`
`24`	`24`	`*`
`25`	`25`	`* @throws \LengthException The timeout must be greater than 0`
`26`	`26`	`*/`