Fix laravel/framework#56317 laravel/framework#54261 & laravel/framework#56318 & prevents laravel/framework#54000

Author: Admin

illuminate/Bus/UniqueLock.php

@@ -3,6 +3,8 @@
 namespace Illuminate\Bus;
 
 use Illuminate\Contracts\Cache\Repository as Cache;
+use Illuminate\Contracts\Queue\ShouldBeUnique;
+use Illuminate\Queue\SerializesModels;
 
 class UniqueLock
 {
@@ -28,10 +30,17 @@ public function __construct(Cache $cache)
      * Attempt to acquire a lock for the given job.
      *
      * @param mixed $job
-     * @return bool
+     * @throws \RuntimeException
      */
-    public function acquire($job)
+    public function acquire($job): bool
     {
+        if (
+            $job instanceof ShouldBeUnique
+            && \in_array(SerializesModels::class, \class_uses_recursive($job::class), true)
+        ) {
+            throw new \RuntimeException('ShouldBeUnique not supported in combination with SerializesModels');
+        }
+
         $uniqueFor = method_exists($job, 'uniqueFor')
             ? $job->uniqueFor()
             : ($job->uniqueFor ?? 0);
@@ -49,7 +58,7 @@ public function acquire($job)
      * @param mixed $job
      * @return void
      */
-    public function release($job)
+    public function release($job): void
     {
         $cache = method_exists($job, 'uniqueVia')
             ? $job->uniqueVia()
@@ -62,9 +71,8 @@ public function release($job)
      * Generate the lock key for the given job.
      *
      * @param mixed $job
-     * @return string
      */
-    protected function getKey($job)
+    protected function getKey($job): string
     {
         $uniqueId = method_exists($job, 'uniqueId')
             ? $job->uniqueId()

illuminate/Pipeline/Pipeline.php

@@ -41,6 +41,13 @@ class Pipeline implements PipelineContract
      */
     protected $method = 'handle';
 
+    /**
+     * The final callback to be executed after the pipeline ends regardless of the outcome.
+     *
+     * @var Closure|null
+     */
+    protected $finally;
+
     /**
      * Create a new class instance.
      *
@@ -118,7 +125,13 @@ public function then(Closure $destination)
             $this->prepareDestination($destination)
         );
 
-        return $pipeline($this->passable);
+        try {
+            return $pipeline($this->passable);
+        } finally {
+            if ($this->finally instanceof Closure) {
+                ($this->finally)($this->passable);
+            }
+        }
     }
 
     /**
@@ -133,6 +146,16 @@ public function thenReturn()
         });
     }
 
+    /**
+     * Set a final callback to be executed after the pipeline ends regardless of the outcome.
+     */
+    public function finally(Closure $callback): static
+    {
+        $this->finally = $callback;
+
+        return $this;
+    }
+
     /**
      * Get the final piece of the Closure onion.
      *

illuminate/Queue/CallQueuedHandler.php

@@ -66,10 +66,6 @@ public function call(Job $job, array $data)
             return;
         }
 
-        if ($command instanceof ShouldBeUniqueUntilProcessing) {
-            $this->ensureUniqueJobLockIsReleased($command);
-        }
-
         $this->dispatchThroughMiddleware($job, $command);
 
         if (!$job->isReleased() && !$command instanceof ShouldBeUniqueUntilProcessing) {
@@ -113,21 +109,40 @@ protected function getCommand(array $data)
      * @param \Illuminate\Contracts\Queue\Job $job
      * @param mixed $command
      * @return mixed
+     * @throws Exception
      */
     protected function dispatchThroughMiddleware(Job $job, $command)
     {
         if ($command instanceof \__PHP_Incomplete_Class) {
             throw new Exception('Job is incomplete class: ' . json_encode($command));
         }
 
+        $lockReleased = false;
+
         return (new Pipeline($this->container))->send($command)
             ->through(
                 array_merge(
                     method_exists($command, 'middleware') ? $command->middleware() : [],
                     $command->middleware ?? []
                 )
             )
-            ->then(function ($command) use ($job) {
+            ->finally(function ($command) use (&$lockReleased): void {
+                if (
+                    !$lockReleased
+                    && $command instanceof ShouldBeUniqueUntilProcessing
+                    && ($command->job ?? null) instanceof Job
+                    && !$command->job->isReleased()
+                ) {
+                    $this->ensureUniqueJobLockIsReleased($command);
+                }
+            })
+            ->then(function ($command) use ($job, &$lockReleased): mixed {
+                if ($command instanceof ShouldBeUniqueUntilProcessing) {
+                    $this->ensureUniqueJobLockIsReleased($command);
+
+                    $lockReleased = true;
+                }
+
                 return $this->dispatcher->dispatchNow(
                     $command,
                     $this->resolveHandler($job, $command)
@@ -252,12 +267,16 @@ protected function handleModelNotFound(Job $job, $e)
      * @param array $data
      * @param \Throwable|null $e
      * @param string $uuid
-     * @return void
+     * @param \Illuminate\Contracts\Queue\Job|null $job
      */
-    public function failed(array $data, $e, string $uuid)
+    public function failed(array $data, $e, string $uuid, ?Job $job = null): void
     {
         $command = $this->getCommand($data);
 
+        if ($job instanceof Job) {
+            $command = $this->setJobInstanceIfNecessary($job, $command);
+        }
+
         if (!$command instanceof ShouldBeUniqueUntilProcessing) {
             $this->ensureUniqueJobLockIsReleased($command);
         }

illuminate/Queue/Jobs/Job.php

@@ -239,7 +239,7 @@ protected function failed($e)
         [$class, $method] = JobName::parse($payload['job']);
 
         if (method_exists($this->instance = $this->resolve($class), 'failed')) {
-            $this->instance->failed($payload['data'], $e, $payload['uuid'] ?? '');
+            $this->instance->failed($payload['data'], $e, $payload['uuid'] ?? '', $this);
         }
     }
 

src/Bus/PendingDispatch.php

@@ -6,6 +6,7 @@
 use Illuminate\Contracts\Bus\Dispatcher;
 use Illuminate\Contracts\Cache\Repository as Cache;
 use Illuminate\Contracts\Queue\ShouldBeUnique;
+use Illuminate\Queue\SerializesModels;
 
 class PendingDispatch
 {
@@ -57,13 +58,18 @@ public function onQueue($queue)
      * Determine if the job should be dispatched.
      *
      * @return bool
+     * @throws \RuntimeException
      */
-    protected function shouldDispatch()
+    protected function shouldDispatch(): bool
     {
         if (!$this->job instanceof ShouldBeUnique) {
             return true;
         }
 
+        if (\in_array(SerializesModels::class, \class_uses_recursive($this->job::class), true)) {
+            throw new \RuntimeException('ShouldBeUnique not supported in combination with SerializesModels');
+        }
+
         $uniqueId = method_exists($this->job, 'uniqueId')
             ? $this->job->uniqueId()
             : ($this->job->uniqueId ?? '');