[10.x] Move ShouldBeUnique locking from PendingDispatch to Dispatcher

src/Illuminate/Bus/Dispatcher.php

@@ -4,8 +4,10 @@
 
 use Closure;
 use Illuminate\Contracts\Bus\QueueingDispatcher;
+use Illuminate\Contracts\Cache\Repository as Cache;
 use Illuminate\Contracts\Container\Container;
 use Illuminate\Contracts\Queue\Queue;
+use Illuminate\Contracts\Queue\ShouldBeUnique;
 use Illuminate\Contracts\Queue\ShouldQueue;
 use Illuminate\Foundation\Bus\PendingChain;
 use Illuminate\Pipeline\Pipeline;
@@ -85,14 +87,19 @@ public function dispatch($command)
      *
      * @param  mixed  $command
      * @param  mixed  $handler
+     * @param  bool  $checkLocks
      * @return mixed
      */
-    public function dispatchSync($command, $handler = null)
+    public function dispatchSync($command, $handler = null, $checkLocks = true)
     {
         if ($this->queueResolver &&
             $this->commandShouldBeQueued($command) &&
             method_exists($command, 'onConnection')) {
-            return $this->dispatchToQueue($command->onConnection('sync'));
+            return $this->dispatchToQueue($command->onConnection('sync'), $checkLocks);
+        }
+
+        if($checkLocks && ! $this->shouldDispatch($command)) {
+            return null;
         }
 
         return $this->dispatchNow($command, $handler);
@@ -194,6 +201,27 @@ public function getCommandHandler($command)
         return false;
     }
 
+    /**
+     * Determine if the job should be dispatched.
+     *
+     * @param mixed $command
+     * @param bool $shouldLock
+     * @return bool
+     */
+    protected function shouldDispatch($command, $shouldLock = true)
+    {
+        if (! $command instanceof ShouldBeUnique) {
+            return true;
+        }
+
+        $lock = (new UniqueLock(\Illuminate\Container\Container::getInstance()->make(Cache::class)));
+        if ($shouldLock) {
+            return $lock->acquire($command);
+        } else {
+            return ! $lock->isAcquired($command);
+        }
+    }
+
     /**
      * Determine if the given command should be queued.
      *
@@ -209,12 +237,17 @@ protected function commandShouldBeQueued($command)
      * Dispatch a command to its appropriate handler behind a queue.
      *
      * @param  mixed  $command
+     * @param  bool  $checkLocks
      * @return mixed
      *
      * @throws \RuntimeException
      */
-    public function dispatchToQueue($command)
+    public function dispatchToQueue($command, $checkLocks = true)
     {
+        if($checkLocks && ! $this->shouldDispatch($command)) {
+            return null;
+        }
+
         $connection = $command->connection ?? null;
 
         $queue = call_user_func($this->queueResolver, $connection);
@@ -263,8 +296,12 @@ protected function pushCommandToQueue($queue, $command)
      */
     public function dispatchAfterResponse($command, $handler = null)
     {
+        if(! $this->shouldDispatch($command)) {
+            return;
+        }
+
         $this->container->terminating(function () use ($command, $handler) {
-            $this->dispatchSync($command, $handler);
+            $this->dispatchSync($command, $handler, false);
         });
     }
 

src/Illuminate/Bus/UniqueLock.php

@@ -43,6 +43,21 @@ public function acquire($job)
         return (bool) $cache->lock($this->getKey($job), $uniqueFor)->get();
     }
 
+    /**
+     * Check if the lock for the given job is already acquired.
+     *
+     * @param  mixed  $job
+     * @return bool
+     */
+    public function isAcquired($job)
+    {
+        $cache = method_exists($job, 'uniqueVia')
+                    ? $job->uniqueVia()
+                    : $this->cache;
+
+        return (bool) $cache->lock($this->getKey($job))->get();
+    }
+
     /**
      * Release the lock for the given job.
      *

src/Illuminate/Console/Scheduling/Schedule.php

@@ -212,10 +212,6 @@ protected function dispatchUniqueJobToQueue($job, $queue, $connection)
             throw new RuntimeException('Cache driver not available. Scheduling unique jobs not supported.');
         }
 
-        if (! (new UniqueLock(Container::getInstance()->make(Cache::class)))->acquire($job)) {
-            return;
-        }
-
         $this->getDispatcher()->dispatch(
             $job->onConnection($connection)->onQueue($queue)
         );

src/Illuminate/Foundation/Bus/PendingDispatch.php

@@ -2,11 +2,7 @@
 
 namespace Illuminate\Foundation\Bus;
 
-use Illuminate\Bus\UniqueLock;
-use Illuminate\Container\Container;
 use Illuminate\Contracts\Bus\Dispatcher;
-use Illuminate\Contracts\Cache\Repository as Cache;
-use Illuminate\Contracts\Queue\ShouldBeUnique;
 
 class PendingDispatch
 {
@@ -149,21 +145,6 @@ public function afterResponse()
         return $this;
     }
 
-    /**
-     * Determine if the job should be dispatched.
-     *
-     * @return bool
-     */
-    protected function shouldDispatch()
-    {
-        if (! $this->job instanceof ShouldBeUnique) {
-            return true;
-        }
-
-        return (new UniqueLock(Container::getInstance()->make(Cache::class)))
-                    ->acquire($this->job);
-    }
-
     /**
      * Dynamically proxy methods to the underlying job.
      *
@@ -185,9 +166,7 @@ public function __call($method, $parameters)
      */
     public function __destruct()
     {
-        if (! $this->shouldDispatch()) {
-            return;
-        } elseif ($this->afterResponse) {
+        if ($this->afterResponse) {
             app(Dispatcher::class)->dispatchAfterResponse($this->job);
         } else {
             app(Dispatcher::class)->dispatch($this->job);