[12.x] Fix deadlock in cache_locks on cleanup (#58071)

* Update DatabaseLock.php

* add a test

this was a bit painful

* clean up a bit

* cs

Author: jackbayliss

src/Illuminate/Cache/DatabaseLock.php

@@ -3,10 +3,14 @@
 namespace Illuminate\Cache;
 
 use Illuminate\Database\Connection;
+use Illuminate\Database\DetectsConcurrencyErrors;
 use Illuminate\Database\QueryException;
+use Throwable;
 
 class DatabaseLock extends Lock
 {
+    use DetectsConcurrencyErrors;
+
     /**
      * The database connection instance.
      *
@@ -60,6 +64,8 @@ public function __construct(Connection $connection, $table, $name, $seconds, $ow
      * Attempt to acquire the lock.
      *
      * @return bool
+     *
+     * @throws Throwable
      */
     public function acquire()
     {
@@ -85,7 +91,15 @@ public function acquire()
         }
 
         if (random_int(1, $this->lottery[1]) <= $this->lottery[0]) {
-            $this->connection->table($this->table)->where('expiration', '<=', $this->currentTime())->delete();
+            try {
+                $this->connection->table($this->table)
+                    ->where('expiration', '<=', $this->currentTime())
+                    ->delete();
+            } catch (Throwable $e) {
+                if (! $this->causedByConcurrencyError($e)) {
+                    throw $e;
+                }
+            }
         }
 
         return $acquired;

tests/Integration/Database/DatabaseLockTest.php

@@ -2,9 +2,16 @@
 
 namespace Illuminate\Tests\Integration\Database;
 
+use Illuminate\Cache\DatabaseLock;
+use Illuminate\Database\Connection;
+use Illuminate\Database\Query\Builder;
+use Illuminate\Database\QueryException;
 use Illuminate\Support\Facades\Cache;
 use Illuminate\Support\Facades\DB;
+use Mockery as m;
 use Orchestra\Testbench\Attributes\WithMigration;
+use PDOException;
+use PHPUnit\Framework\Attributes\TestWith;
 
 #[WithMigration('cache')]
 class DatabaseLockTest extends DatabaseTestCase
@@ -68,4 +75,36 @@ public function testOtherOwnerDoesNotOwnLockAfterRestore()
         $this->assertTrue($secondLock->isOwnedBy($firstLock->owner()));
         $this->assertFalse($secondLock->isOwnedByCurrentProcess());
     }
+
+    #[TestWith(['Deadlock found when trying to get lock', 1213, true])]
+    #[TestWith(['Table does not exist', 1146, false])]
+    public function testIgnoresConcurrencyException(string $message, int $code, bool $hasConcurrenyError)
+    {
+        $connection = m::mock(Connection::class);
+        $insertBuilder = m::mock(Builder::class);
+        $deleteBuilder = m::mock(Builder::class);
+
+        $insertBuilder->shouldReceive('insert')->once()->andReturn(true);
+
+        $deleteBuilder->shouldReceive('where')->with('expiration', '<=', m::any())->once()->andReturnSelf();
+        $deleteBuilder->shouldReceive('delete')->once()->andThrow(
+            new QueryException(
+                'mysql',
+                'delete from cache_locks where expiration <= ?',
+                [],
+                new PDOException($message, $code)
+            )
+        );
+
+        $connection->shouldReceive('table')->with('cache_locks')->andReturn($insertBuilder, $deleteBuilder);
+
+        $lock = new DatabaseLock($connection, 'cache_locks', 'foo', 0, lottery: [1, 1]);
+
+        if ($hasConcurrenyError) {
+            $this->assertTrue($lock->acquire());
+        } else {
+            $this->expectException(QueryException::class);
+            $this->assertFalse($lock->acquire());
+        }
+    }
 }