Reduced dependency to voryx/Thruway

Author: Mathieu Lemoine

AbstractAsyncEventDispatcher.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Enqueue\AsyncEventDispatcher;
+
+use Symfony\Component\EventDispatcher\Event;
+use Symfony\Component\EventDispatcher\EventDispatcher;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+use Symfony\Contracts\EventDispatcher\Event as ContractEvent;
+
+abstract class AbstractAsyncEventDispatcher extends EventDispatcher implements EventDispatcherInterface
+{
+    /**
+     * @var EventDispatcherInterface
+     */
+    protected $trueEventDispatcher;
+
+    /**
+     * @var AsyncListener
+     */
+    protected $asyncListener;
+
+    /**
+     * @param EventDispatcherInterface $trueEventDispatcher
+     * @param AsyncListener            $asyncListener
+     */
+    public function __construct(EventDispatcherInterface $trueEventDispatcher, AsyncListener $asyncListener)
+    {
+        $this->trueEventDispatcher = $trueEventDispatcher;
+        $this->asyncListener = $asyncListener;
+    }
+
+    /**
+     * This method dispatches only those listeners that were marked as async.
+     *
+     * @param string                   $eventName
+     * @param ContractEvent|Event|null $event
+     */
+    public function dispatchAsyncListenersOnly($eventName, $event = null)
+    {
+        try {
+            $this->asyncListener->syncMode($eventName);
+
+            $this->parentDispatch($event, $eventName);
+        } finally {
+            $this->asyncListener->resetSyncMode();
+        }
+    }
+
+    abstract protected function parentDispatch($event, $eventName);
+}

AbstractAsyncListener.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace Enqueue\AsyncEventDispatcher;
+
+use Interop\Queue\Context;
+use Interop\Queue\Queue;
+use Symfony\Component\EventDispatcher\Event;
+
+abstract class AbstractAsyncListener
+{
+    /**
+     * @var Context
+     */
+    protected $context;
+
+    /**
+     * @var Registry
+     */
+    protected $registry;
+
+    /**
+     * @var Queue
+     */
+    protected $eventQueue;
+
+    /**
+     * @var bool
+     */
+    protected $syncMode;
+
+    /**
+     * @param Context      $context
+     * @param Registry     $registry
+     * @param Queue|string $eventQueue
+     */
+    public function __construct(Context $context, Registry $registry, $eventQueue)
+    {
+        $this->context = $context;
+        $this->registry = $registry;
+        $this->eventQueue = $eventQueue instanceof Queue ? $eventQueue : $context->createQueue($eventQueue);
+    }
+
+    public function resetSyncMode()
+    {
+        $this->syncMode = [];
+    }
+
+    /**
+     * @param string $eventName
+     */
+    public function syncMode($eventName)
+    {
+        $this->syncMode[$eventName] = true;
+    }
+
+    /**
+     * @param string $eventName
+     *
+     * @return bool
+     */
+    public function isSyncMode($eventName)
+    {
+        return isset($this->syncMode[$eventName]);
+    }
+}

AbstractPhpSerializerEventTransformer.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Enqueue\AsyncEventDispatcher;
+
+use Interop\Queue\Context;
+use Interop\Queue\Message;
+use Symfony\Component\EventDispatcher\Event;
+use Symfony\Component\EventDispatcher\LegacyEventDispatcherProxy;
+use Symfony\Contracts\EventDispatcher\Event as ContractEvent;
+
+abstract class AbstractPhpSerializerEventTransformer
+{
+    /**
+     * @var Context
+     */
+    protected $context;
+
+    /**
+     * @param Context $context
+     */
+    public function __construct(Context $context)
+    {
+        $this->context = $context;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function toEvent($eventName, Message $message)
+    {
+        return unserialize($message->getBody());
+    }
+}

AsyncEventDispatcher.php

@@ -3,55 +3,69 @@
 namespace Enqueue\AsyncEventDispatcher;
 
 use Symfony\Component\EventDispatcher\Event;
-use Symfony\Component\EventDispatcher\EventDispatcher;
-use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+use Symfony\Component\EventDispatcher\LegacyEventDispatcherProxy;
 
-class AsyncEventDispatcher extends EventDispatcher
-{
+if (class_exists(Event::class) && !class_exists(LegacyEventDispatcherProxy::class)) {
     /**
-     * @var EventDispatcherInterface
+     * Symfony < 4.3
      */
-    private $trueEventDispatcher;
+    class AsyncEventDispatcher extends AbstractAsyncEventDispatcher
+    {
+        /**
+         * {@inheritdoc}
+         */
+        public function dispatch($eventName, Event $event = null)
+        {
+            $this->parentDispatch($event, $eventName);
 
-    /**
-     * @var AsyncListener
-     */
-    private $asyncListener;
+            $this->trueEventDispatcher->dispatch($eventName, $event);
+        }
 
-    /**
-     * @param EventDispatcherInterface $trueEventDispatcher
-     * @param AsyncListener            $asyncListener
-     */
-    public function __construct(EventDispatcherInterface $trueEventDispatcher, AsyncListener $asyncListener)
-    {
-        $this->trueEventDispatcher = $trueEventDispatcher;
-        $this->asyncListener = $asyncListener;
+        protected function parentDispatch($event, $eventName)
+        {
+            parent::dispatch($eventName, $event);
+        }
     }
-
+} elseif (class_exists(Event::class)) {
     /**
-     * This method dispatches only those listeners that were marked as async.
-     *
-     * @param string     $eventName
-     * @param Event|null $event
+     * Symfony >= 4.3 and < 5.0
      */
-    public function dispatchAsyncListenersOnly($eventName, Event $event = null)
+    class AsyncEventDispatcher extends AbstractAsyncEventDispatcher
     {
-        try {
-            $this->asyncListener->syncMode($eventName);
+        /**
+         * {@inheritdoc}
+         */
+        public function dispatch($event, $eventName = null)
+        {
+            $this->parentDispatch($event, $eventName);
 
-            parent::dispatch($eventName, $event);
-        } finally {
-            $this->asyncListener->resetSyncMode();
+            return $this->trueEventDispatcher->dispatch($event, $eventName);
         }
-    }
 
+        protected function parentDispatch($event, $eventName)
+        {
+            parent::dispatch($event, $eventName);
+        }
+    }
+} else {
     /**
-     * {@inheritdoc}
+     * Symfony >= 5.0
      */
-    public function dispatch($eventName, Event $event = null)
+    class AsyncEventDispatcher extends AbstractAsyncEventDispatcher
     {
-        parent::dispatch($eventName, $event);
+        /**
+         * {@inheritdoc}
+         */
+        public function dispatch(object $event, string $eventName = null): object
+        {
+            $this->parentDispatch($event, $eventName);
+
+            return $this->trueEventDispatcher->dispatch($event, $eventName);
+        }
 
-        $this->trueEventDispatcher->dispatch($eventName, $event);
+        protected function parentDispatch($event, $eventName)
+        {
+            return parent::dispatch($event, $eventName);
+        }
     }
 }