[Messenger] Envelope as first class citizen in middleware too

symfony · ogizanagi · May 16, 2018 · May 20, 2018 · May 20, 2018 · a2d7960cea7b22e6e6498a5d3764e71a638fa34b
commit a2d7960cea7b22e6e6498a5d3764e71a638fa34b
diff --git a/src/Symfony/Bridge/Doctrine/Messenger/DoctrineTransactionMiddleware.php b/src/Symfony/Bridge/Doctrine/Messenger/DoctrineTransactionMiddleware.php
@@ -13,6 +13,7 @@
 
 use Doctrine\Common\Persistence\ManagerRegistry;
 use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\Messenger\Envelope;
 use Symfony\Component\Messenger\Middleware\MiddlewareInterface;
 
 /**
@@ -31,7 +32,7 @@ public function __construct(ManagerRegistry $managerRegistry, ?string $entityMan
         $this->entityManagerName = $entityManagerName;
     }
 
-    public function handle($message, callable $next)
+    public function handle(Envelope $envelope, callable $next)
     {
         $entityManager = $this->managerRegistry->getManager($this->entityManagerName);
 
@@ -41,7 +42,7 @@ public function handle($message, callable $next)
 
         $entityManager->getConnection()->beginTransaction();
         try {
-            $result = $next($message);
+            $result = $next($envelope);
             $entityManager->flush();
             $entityManager->getConnection()->commit();
         } catch (\Throwable $exception) {

diff --git a/src/Symfony/Component/Messenger/Asynchronous/Middleware/SendMessageMiddleware.php b/src/Symfony/Component/Messenger/Asynchronous/Middleware/SendMessageMiddleware.php
@@ -15,14 +15,13 @@
 use Symfony\Component\Messenger\Asynchronous\Routing\SenderLocatorInterface;
 use Symfony\Component\Messenger\Asynchronous\Transport\ReceivedMessage;
 use Symfony\Component\Messenger\Envelope;
-use Symfony\Component\Messenger\EnvelopeAwareInterface;
 use Symfony\Component\Messenger\Middleware\MiddlewareInterface;
 
 /**
  * @author Samuel Roze <[email protected]>
  * @author Tobias Schultze <http://tobion.de>
  */
-class SendMessageMiddleware implements MiddlewareInterface, EnvelopeAwareInterface
+class SendMessageMiddleware implements MiddlewareInterface
 {
     private $senderLocator;
     private $messagesToSendAndHandleMapping;
@@ -36,12 +35,11 @@ public function __construct(SenderLocatorInterface $senderLocator, array $messag
     /**
      * {@inheritdoc}
      */
-    public function handle($message, callable $next)
+    public function handle(Envelope $envelope, callable $next)
     {
-        $envelope = Envelope::wrap($message);
         if ($envelope->get(ReceivedMessage::class)) {
             // It's a received message. Do not send it back:
-            return $next($message);
+            return $next($envelope);
         }
 
         $sender = $this->senderLocator->getSenderForMessage($envelope->getMessage());
@@ -54,7 +52,7 @@ public function handle($message, callable $next)
             }
         }
 
-        return $next($message);
+        return $next($envelope);
     }
 
     private function mustSendAndHandle($message): bool

diff --git a/src/Symfony/Component/Messenger/EnvelopeAwareInterface.php b/src/Symfony/Component/Messenger/EnvelopeAwareInterface.php
diff --git a/src/Symfony/Component/Messenger/MessageBus.php b/src/Symfony/Component/Messenger/MessageBus.php
@@ -44,10 +44,10 @@ public function dispatch($message)
             throw new InvalidArgumentException(sprintf('Invalid type for message argument. Expected object, but got "%s".', \gettype($message)));
         }
 
-        return \call_user_func($this->callableForNextMiddleware(0, Envelope::wrap($message)), $message);
+        return \call_user_func($this->callableForNextMiddleware(0), Envelope::wrap($message));
     }
 
-    private function callableForNextMiddleware(int $index, Envelope $currentEnvelope): callable
+    private function callableForNextMiddleware(int $index): callable
     {
         if (null === $this->indexedMiddlewareHandlers) {
             $this->indexedMiddlewareHandlers = \is_array($this->middlewareHandlers) ? array_values($this->middlewareHandlers) : iterator_to_array($this->middlewareHandlers, false);
@@ -59,19 +59,8 @@ private function callableForNextMiddleware(int $index, Envelope $currentEnvelope
 
         $middleware = $this->indexedMiddlewareHandlers[$index];
 
-        return function ($message) use ($middleware, $index, $currentEnvelope) {
-            if ($message instanceof Envelope) {
-                $currentEnvelope = $message;
-            } else {
-                $message = $currentEnvelope->withMessage($message);
-            }
-
-            if (!$middleware instanceof EnvelopeAwareInterface) {
-                // Do not provide the envelope if the middleware cannot read it:
-                $message = $message->getMessage();
-            }
-
-            return $middleware->handle($message, $this->callableForNextMiddleware($index + 1, $currentEnvelope));
+        return function (Envelope $envelope) use ($middleware, $index) {
+            return $middleware->handle($envelope, $this->callableForNextMiddleware($index + 1));
         };
     }
 }
diff --git a/src/Symfony/Component/Messenger/Middleware/AllowNoHandlerMiddleware.php b/src/Symfony/Component/Messenger/Middleware/AllowNoHandlerMiddleware.php
@@ -11,17 +11,18 @@
 
 namespace Symfony\Component\Messenger\Middleware;
 
+use Symfony\Component\Messenger\Envelope;
 use Symfony\Component\Messenger\Exception\NoHandlerForMessageException;
 
 /**
  * @author Samuel Roze <[email protected]>
  */
 class AllowNoHandlerMiddleware implements MiddlewareInterface
 {
-    public function handle($message, callable $next)
+    public function handle(Envelope $envelope, callable $next)
     {
         try {
-            return $next($message);
+            return $next($envelope);
         } catch (NoHandlerForMessageException $e) {
             // We allow not having a handler for this message.
         }

diff --git a/src/Symfony/Component/Messenger/Middleware/HandleMessageMiddleware.php b/src/Symfony/Component/Messenger/Middleware/HandleMessageMiddleware.php
@@ -11,6 +11,7 @@
 
 namespace Symfony\Component\Messenger\Middleware;
 
+use Symfony\Component\Messenger\Envelope;
 use Symfony\Component\Messenger\Handler\Locator\HandlerLocatorInterface;
 
 /**
@@ -28,12 +29,13 @@ public function __construct(HandlerLocatorInterface $messageHandlerResolver)
     /**
      * {@inheritdoc}
      */
-    public function handle($message, callable $next)
+    public function handle(Envelope $envelope, callable $next)
     {
+        $message = $envelope->getMessage();
         $handler = $this->messageHandlerResolver->resolve($message);
         $result = $handler($message);
 
-        $next($message);
+        $next($envelope);
 
         return $result;
     }

diff --git a/src/Symfony/Component/Messenger/Middleware/LoggingMiddleware.php b/src/Symfony/Component/Messenger/Middleware/LoggingMiddleware.php
@@ -12,6 +12,7 @@
 namespace Symfony\Component\Messenger\Middleware;
 
 use Psr\Log\LoggerInterface;
+use Symfony\Component\Messenger\Envelope;
 
 /**
  * @author Samuel Roze <[email protected]>
@@ -28,12 +29,14 @@ public function __construct(LoggerInterface $logger)
     /**
      * {@inheritdoc}
      */
-    public function handle($message, callable $next)
+    public function handle(Envelope $envelope, callable $next)
     {
+        $message = $envelope->getMessage();
+
         $this->logger->debug('Starting handling message {class}', $this->createContext($message));
 
         try {
-            $result = $next($message);
+            $result = $next($envelope);
         } catch (\Throwable $e) {
             $this->logger->warning('An exception occurred while handling message {class}', array_merge(
                 $this->createContext($message),

diff --git a/src/Symfony/Component/Messenger/Middleware/MiddlewareInterface.php b/src/Symfony/Component/Messenger/Middleware/MiddlewareInterface.php
@@ -11,6 +11,8 @@
 
 namespace Symfony\Component\Messenger\Middleware;
 
+use Symfony\Component\Messenger\Envelope;
+
 /**
  * @author Samuel Roze <[email protected]>
  *
@@ -19,9 +21,9 @@
 interface MiddlewareInterface
 {
     /**
-     * @param object $message
+     * @param Envelope $envelope
      *
      * @return mixed
      */
-    public function handle($message, callable $next);
+    public function handle(Envelope $envelope, callable $next);
 }
diff --git a/src/Symfony/Component/Messenger/Middleware/ValidationMiddleware.php b/src/Symfony/Component/Messenger/Middleware/ValidationMiddleware.php
@@ -12,15 +12,14 @@
 namespace Symfony\Component\Messenger\Middleware;
 
 use Symfony\Component\Messenger\Envelope;
-use Symfony\Component\Messenger\EnvelopeAwareInterface;
 use Symfony\Component\Messenger\Exception\ValidationFailedException;
 use Symfony\Component\Messenger\Middleware\Configuration\ValidationConfiguration;
 use Symfony\Component\Validator\Validator\ValidatorInterface;
 
 /**
  * @author Tobias Nyholm <[email protected]>
  */
-class ValidationMiddleware implements MiddlewareInterface, EnvelopeAwareInterface
+class ValidationMiddleware implements MiddlewareInterface
 {
     private $validator;
 
@@ -29,21 +28,20 @@ public function __construct(ValidatorInterface $validator)
         $this->validator = $validator;
     }
 
-    public function handle($message, callable $next)
+    public function handle(Envelope $envelope, callable $next)
     {
-        $envelope = Envelope::wrap($message);
-        $subject = $envelope->getMessage();
+        $message = $envelope->getMessage();
         $groups = null;
         /** @var ValidationConfiguration|null $validationConfig */
         if ($validationConfig = $envelope->get(ValidationConfiguration::class)) {
             $groups = $validationConfig->getGroups();
         }
 
-        $violations = $this->validator->validate($subject, null, $groups);
+        $violations = $this->validator->validate($message, null, $groups);
         if (\count($violations)) {
-            throw new ValidationFailedException($subject, $violations);
+            throw new ValidationFailedException($message, $violations);
         }
 
-        return $next($message);
+        return $next($envelope);
     }
 }
diff --git a/src/Symfony/Component/Messenger/Tests/Asynchronous/Middleware/SendMessageMiddlewareTest.php b/src/Symfony/Component/Messenger/Tests/Asynchronous/Middleware/SendMessageMiddlewareTest.php
@@ -24,20 +24,6 @@
 class SendMessageMiddlewareTest extends TestCase
 {
     public function testItSendsTheMessageToAssignedSender()
-    {
-        $message = new DummyMessage('Hey');
-        $sender = $this->getMockBuilder(SenderInterface::class)->getMock();
-        $next = $this->createPartialMock(\stdClass::class, array('__invoke'));
-
-        $middleware = new SendMessageMiddleware(new InMemorySenderLocator($sender));
-
-        $sender->expects($this->once())->method('send')->with(Envelope::wrap($message));
-        $next->expects($this->never())->method($this->anything());
-
-        $middleware->handle($message, $next);
-    }
-
-    public function testItSendsTheMessageToAssignedSenderWithPreWrappedMessage()
     {
         $envelope = Envelope::wrap(new DummyMessage('Hey'));
         $sender = $this->getMockBuilder(SenderInterface::class)->getMock();
@@ -53,78 +39,78 @@ public function testItSendsTheMessageToAssignedSenderWithPreWrappedMessage()
 
     public function testItAlsoCallsTheNextMiddlewareBasedOnTheMessageClass()
     {
-        $message = new DummyMessage('Hey');
+        $envelope = Envelope::wrap(new DummyMessage('Hey'));
         $sender = $this->getMockBuilder(SenderInterface::class)->getMock();
         $next = $this->createPartialMock(\stdClass::class, array('__invoke'));
 
         $middleware = new SendMessageMiddleware(new InMemorySenderLocator($sender), array(
             DummyMessage::class => true,
         ));
 
-        $sender->expects($this->once())->method('send')->with(Envelope::wrap($message));
+        $sender->expects($this->once())->method('send')->with($envelope);
         $next->expects($this->once())->method($this->anything());
 
-        $middleware->handle($message, $next);
+        $middleware->handle($envelope, $next);
     }
 
     public function testItAlsoCallsTheNextMiddlewareBasedOnTheMessageParentClass()
     {
-        $message = new ChildDummyMessage('Hey');
+        $envelope = Envelope::wrap(new ChildDummyMessage('Hey'));
         $sender = $this->getMockBuilder(SenderInterface::class)->getMock();
         $next = $this->createPartialMock(\stdClass::class, array('__invoke'));
 
         $middleware = new SendMessageMiddleware(new InMemorySenderLocator($sender), array(
             DummyMessage::class => true,
         ));
 
-        $sender->expects($this->once())->method('send')->with(Envelope::wrap($message));
+        $sender->expects($this->once())->method('send')->with($envelope);
         $next->expects($this->once())->method($this->anything());
 
-        $middleware->handle($message, $next);
+        $middleware->handle($envelope, $next);
     }
 
     public function testItAlsoCallsTheNextMiddlewareBasedOnTheMessageInterface()
     {
-        $message = new DummyMessage('Hey');
+        $envelope = Envelope::wrap(new DummyMessage('Hey'));
         $sender = $this->getMockBuilder(SenderInterface::class)->getMock();
         $next = $this->createPartialMock(\stdClass::class, array('__invoke'));
 
         $middleware = new SendMessageMiddleware(new InMemorySenderLocator($sender), array(
             DummyMessageInterface::class => true,
         ));
 
-        $sender->expects($this->once())->method('send')->with(Envelope::wrap($message));
+        $sender->expects($this->once())->method('send')->with($envelope);
         $next->expects($this->once())->method($this->anything());
 
-        $middleware->handle($message, $next);
+        $middleware->handle($envelope, $next);
     }
 
     public function testItAlsoCallsTheNextMiddlewareBasedOnWildcard()
     {
-        $message = new DummyMessage('Hey');
+        $envelope = Envelope::wrap(new DummyMessage('Hey'));
         $sender = $this->getMockBuilder(SenderInterface::class)->getMock();
         $next = $this->createPartialMock(\stdClass::class, array('__invoke'));
 
         $middleware = new SendMessageMiddleware(new InMemorySenderLocator($sender), array(
             '*' => true,
         ));
 
-        $sender->expects($this->once())->method('send')->with(Envelope::wrap($message));
-        $next->expects($this->once())->method($this->anything());
+        $sender->expects($this->once())->method('send')->with($envelope);
+        $next->expects($this->once())->method($this->anything())->with($envelope);
 
-        $middleware->handle($message, $next);
+        $middleware->handle($envelope, $next);
     }
 
     public function testItCallsTheNextMiddlewareWhenNoSenderForThisMessage()
     {
-        $message = new DummyMessage('Hey');
+        $envelope = Envelope::wrap(new DummyMessage('Hey'));
         $next = $this->createPartialMock(\stdClass::class, array('__invoke'));
 
         $middleware = new SendMessageMiddleware(new InMemorySenderLocator(null));
 
-        $next->expects($this->once())->method($this->anything());
+        $next->expects($this->once())->method($this->anything())->with($envelope);
 
-        $middleware->handle($message, $next);
+        $middleware->handle($envelope, $next);
     }
 
     public function testItSkipsReceivedMessages()

diff --git a/src/Symfony/Component/Messenger/Tests/DependencyInjection/MessengerPassTest.php b/src/Symfony/Component/Messenger/Tests/DependencyInjection/MessengerPassTest.php
@@ -687,8 +687,8 @@ public function __invoke()
 
 class UselessMiddleware implements MiddlewareInterface
 {
-    public function handle($message, callable $next)
+    public function handle(Envelope $envelope, callable $next)
     {
-        return $next($message);
+        return $next($envelope);
     }
 }