[12.x] Ability to refresh cache locks

src/Illuminate/Bus/UniqueLock.php

@@ -57,6 +57,20 @@ public function release($job)
         $cache->lock($this->getKey($job))->forceRelease();
     }
 
+    /**
+     * Refresh the lock for the given job.
+     */
+    public function refresh(mixed $job, ?int $seconds = null): bool
+    {
+        $cache = method_exists($job, 'uniqueVia')
+            ? $job->uniqueVia()
+            : $this->cache;
+
+        $lock = $cache->lock($this->getKey($job));
+
+        return method_exists($lock, 'refresh') && $lock->refresh($seconds);
+    }
+
     /**
      * Generate the lock key for the given job.
      *

src/Illuminate/Cache/ArrayLock.php

@@ -102,4 +102,23 @@ public function forceRelease()
     {
         unset($this->store->locks[$this->name]);
     }
+
+    /**
+     * Attempt to refresh the lock for the given number of seconds.
+     *
+     * @param  int|null  $seconds
+     * @return bool
+     */
+    public function refresh($seconds = null)
+    {
+        if (! $this->isOwnedByCurrentProcess()) {
+            return false;
+        }
+
+        $seconds ??= $this->seconds;
+
+        $this->store->locks[$this->name]['expiresAt'] = $seconds === 0 ? null : Carbon::now()->addSeconds($seconds);
+
+        return true;
+    }
 }

src/Illuminate/Cache/DatabaseLock.php

@@ -170,6 +170,24 @@ protected function getCurrentOwner()
         return $this->connection->table($this->table)->where('key', $this->name)->first()?->owner;
     }
 
+    /**
+     * Attempt to refresh the lock for the given number of seconds.
+     *
+     * @param  int|null  $seconds
+     * @return bool
+     */
+    public function refresh($seconds = null)
+    {
+        $seconds ??= $this->seconds;
+
+        $this->seconds = $seconds;
+
+        return $this->connection->table($this->table)
+            ->where('key', $this->name)
+            ->where('owner', $this->owner)
+            ->update(['expiration' => $this->expiresAt()]) >= 1;
+    }
+
     /**
      * Get the name of the database connection being used to manage the lock.
      *

src/Illuminate/Cache/DynamoDbLock.php

@@ -73,4 +73,21 @@ protected function getCurrentOwner()
     {
         return $this->dynamo->get($this->name);
     }
+
+    /**
+     * Attempt to refresh the lock for the given number of seconds.
+     *
+     * @param  int|null  $seconds
+     * @return bool
+     */
+    public function refresh($seconds = null)
+    {
+        $seconds ??= $this->seconds;
+
+        if ($seconds <= 0) {
+            $seconds = 86400;
+        }
+
+        return $this->dynamo->refreshIfOwned($this->name, $this->owner, $seconds);
+    }
 }

src/Illuminate/Cache/DynamoDbStore.php

@@ -506,4 +506,52 @@ public function getClient()
     {
         return $this->dynamo;
     }
+
+    /**
+     * Atomically refresh the expiration of a key if it matches the expected owner.
+     *
+     * @param  string  $key
+     * @param  mixed  $expectedOwner
+     * @param  int  $seconds
+     * @return bool
+     */
+    public function refreshIfOwned($key, $expectedOwner, $seconds)
+    {
+        try {
+            $this->dynamo->updateItem([
+                'TableName' => $this->table,
+                'Key' => [
+                    $this->keyAttribute => [
+                        'S' => $this->prefix.$key,
+                    ],
+                ],
+                'ConditionExpression' => 'attribute_exists(#key) AND #value = :owner AND #expires_at > :now',
+                'UpdateExpression' => 'SET #expires_at = :expires_at',
+                'ExpressionAttributeNames' => [
+                    '#key' => $this->keyAttribute,
+                    '#value' => $this->valueAttribute,
+                    '#expires_at' => $this->expirationAttribute,
+                ],
+                'ExpressionAttributeValues' => [
+                    ':owner' => [
+                        $this->type($expectedOwner) => $this->serialize($expectedOwner),
+                    ],
+                    ':now' => [
+                        'N' => (string) $this->currentTime(),
+                    ],
+                    ':expires_at' => [
+                        'N' => (string) $this->toTimestamp($seconds),
+                    ],
+                ],
+            ]);
+
+            return true;
+        } catch (DynamoDbException $e) {
+            if (str_contains($e->getMessage(), 'ConditionalCheckFailed')) {
+                return false;
+            }
+
+            throw $e;
+        }
+    }
 }

src/Illuminate/Cache/FileLock.php

@@ -13,4 +13,19 @@ public function acquire()
     {
         return $this->store->add($this->name, $this->owner, $this->seconds);
     }
+
+    /**
+     * Attempt to refresh the lock for the given number of seconds.
+     *
+     * @param  int|null  $seconds
+     * @return bool
+     */
+    public function refresh($seconds = null)
+    {
+        return $this->store->refreshIfOwned(
+            $this->name,
+            $this->owner,
+            $seconds ?? $this->seconds
+        );
+    }
 }

src/Illuminate/Cache/FileStore.php

@@ -409,6 +409,54 @@ public function setLockDirectory($lockDirectory)
         return $this;
     }
 
+    /**
+     * Atomically refresh the expiration of a cache key if it matches the expected owner.
+     *
+     * @param  string  $key
+     * @param  mixed  $expectedOwner
+     * @param  int  $seconds
+     * @return bool
+     */
+    public function refreshIfOwned($key, $expectedOwner, $seconds)
+    {
+        $this->ensureCacheDirectoryExists($path = $this->path($key));
+
+        $file = new LockableFile($path, 'c+');
+
+        try {
+            $file->getExclusiveLock();
+        } catch (LockTimeoutException) {
+            $file->close();
+
+            return false;
+        }
+
+        $contents = $file->read();
+
+        if (strlen($contents) < 10) {
+            $file->close();
+
+            return false;
+        }
+
+        $expire = substr($contents, 0, 10);
+        $currentOwner = unserialize(substr($contents, 10));
+
+        if ($currentOwner !== $expectedOwner || $this->currentTime() >= $expire) {
+            $file->close();
+
+            return false;
+        }
+
+        $file->truncate()
+            ->write($this->expiration($seconds).serialize($expectedOwner))
+            ->close();
+
+        $this->ensurePermissionsAreCorrect($path);
+
+        return true;
+    }
+
     /**
      * Get the cache key prefix.
      *

src/Illuminate/Cache/Lock.php

@@ -179,4 +179,15 @@ public function betweenBlockedAttemptsSleepFor($milliseconds)
 
         return $this;
     }
+
+    /**
+     * Attempt to refresh the lock for the given number of seconds.
+     *
+     * @param  int|null  $seconds
+     * @return bool
+     */
+    public function refresh($seconds = null)
+    {
+        throw new \RuntimeException('This lock driver does not support refreshing locks.');
+    }
 }

src/Illuminate/Cache/LuaScripts.php

@@ -36,6 +36,26 @@ public static function releaseLock()
 else
     return 0
 end
+LUA;
+    }
+
+    /**
+     * Get the Lua script to atomically refresh a lock's expiration.
+     *
+     * KEYS[1] - The name of the lock
+     * ARGV[1] - The owner key of the lock instance trying to refresh it
+     * ARGV[2] - The number of seconds the lock should be valid
+     *
+     * @return string
+     */
+    public static function refreshLock()
+    {
+        return <<<'LUA'
+if redis.call("get",KEYS[1]) == ARGV[1] then
+    return redis.call("expire",KEYS[1],ARGV[2])
+else
+    return 0
+end
 LUA;
     }
 }

src/Illuminate/Cache/MemcachedLock.php

@@ -71,4 +71,23 @@ protected function getCurrentOwner()
     {
         return $this->memcached->get($this->name);
     }
+
+    /**
+     * Attempt to refresh the lock for the given number of seconds.
+     *
+     * @param  int|null  $seconds
+     * @return bool
+     */
+    public function refresh($seconds = null)
+    {
+        $seconds ??= $this->seconds;
+
+        $value = $this->memcached->get($this->name, null, \Memcached::GET_EXTENDED);
+
+        if ($value === false || ($value['value'] ?? null) !== $this->owner) {
+            return false;
+        }
+
+        return $this->memcached->cas($value['cas'], $this->name, $this->owner, $seconds);
+    }
 }

src/Illuminate/Cache/NoLock.php

@@ -43,4 +43,15 @@ protected function getCurrentOwner()
     {
         return $this->owner;
     }
+
+    /**
+     * Attempt to refresh the lock for the given number of seconds.
+     *
+     * @param  int|null  $seconds
+     * @return bool
+     */
+    public function refresh($seconds = null)
+    {
+        return true;
+    }
 }

src/Illuminate/Cache/PhpRedisLock.php

@@ -31,4 +31,19 @@ public function release()
             ...$this->redis->pack([$this->owner])
         );
     }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function refresh($seconds = null)
+    {
+        $seconds ??= $this->seconds;
+
+        return (bool) $this->redis->eval(
+            LuaScripts::refreshLock(),
+            1,
+            $this->name,
+            ...$this->redis->pack([$this->owner, $seconds])
+        );
+    }
 }

src/Illuminate/Cache/RedisLock.php

@@ -70,6 +70,21 @@ protected function getCurrentOwner()
         return $this->redis->get($this->name);
     }
 
+    /**
+     * Attempt to refresh the lock for the given number of seconds.
+     *
+     * @param  int|null  $seconds
+     * @return bool
+     */
+    public function refresh($seconds = null)
+    {
+        $seconds ??= $this->seconds;
+
+        return (bool) $this->redis->eval(
+            LuaScripts::refreshLock(), 1, $this->name, $this->owner, $seconds
+        );
+    }
+
     /**
      * Get the name of the Redis connection being used to manage the lock.
      *

tests/Integration/Cache/FileCacheLockTest.php

@@ -137,6 +137,51 @@ public function testExceptionIfBlockCanNotAcquireLock()
         Cache::lock('foo', 10)->block(5);
     }
 
+    public function testLockCanBeRefreshed()
+    {
+        $lock = Cache::lock('foo', 10);
+        $this->assertTrue($lock->get());
+
+        // Refresh the lock for another 20 seconds
+        $this->assertTrue($lock->refresh(20));
+
+        // Lock should still be held
+        $this->assertFalse(Cache::lock('foo', 10)->get());
+
+        $lock->release();
+    }
+
+    public function testLockCannotBeRefreshedByAnotherOwner()
+    {
+        $firstLock = Cache::lock('foo', 10);
+        $this->assertTrue($firstLock->get());
+
+        // Create a new lock with a different owner
+        $secondLock = Cache::store('file')->restoreLock('foo', 'other_owner');
+
+        // Second lock should not be able to refresh
+        $this->assertFalse($secondLock->refresh(20));
+
+        // Original lock should still be able to refresh
+        $this->assertTrue($firstLock->refresh(20));
+
+        $firstLock->release();
+    }
+
+    public function testLockRefreshWithDefaultSeconds()
+    {
+        $lock = Cache::lock('foo', 10);
+        $this->assertTrue($lock->get());
+
+        // Refresh without specifying seconds should use the original duration
+        $this->assertTrue($lock->refresh());
+
+        // Lock should still be held
+        $this->assertFalse(Cache::lock('foo', 10)->get());
+
+        $lock->release();
+    }
+
     protected function tearDown(): void
     {
         try {