vendor/symfony/event-dispatcher/Debug/TraceableEventDispatcher.php line 143

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of the Symfony package.
  4.  *
  5.  * (c) Fabien Potencier <fabien@symfony.com>
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  10. namespace Symfony\Component\EventDispatcher\Debug;
  11. use Psr\Log\LoggerInterface;
  12. use Symfony\Component\EventDispatcher\Event;
  13. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  14. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  15. use Symfony\Component\Stopwatch\Stopwatch;
  16. /**
  17.  * Collects some data about event listeners.
  18.  *
  19.  * This event dispatcher delegates the dispatching to another one.
  20.  *
  21.  * @author Fabien Potencier <fabien@symfony.com>
  22.  */
  23. class TraceableEventDispatcher implements TraceableEventDispatcherInterface
  24. {
  25.     protected $logger;
  26.     protected $stopwatch;
  27.     private $callStack;
  28.     private $dispatcher;
  29.     private $wrappedListeners;
  30.     public function __construct(EventDispatcherInterface $dispatcherStopwatch $stopwatchLoggerInterface $logger null)
  31.     {
  32.         $this->dispatcher $dispatcher;
  33.         $this->stopwatch $stopwatch;
  34.         $this->logger $logger;
  35.         $this->wrappedListeners = [];
  36.     }
  37.     /**
  38.      * {@inheritdoc}
  39.      */
  40.     public function addListener($eventName$listener$priority 0)
  41.     {
  42.         $this->dispatcher->addListener($eventName$listener$priority);
  43.     }
  44.     /**
  45.      * {@inheritdoc}
  46.      */
  47.     public function addSubscriber(EventSubscriberInterface $subscriber)
  48.     {
  49.         $this->dispatcher->addSubscriber($subscriber);
  50.     }
  51.     /**
  52.      * {@inheritdoc}
  53.      */
  54.     public function removeListener($eventName$listener)
  55.     {
  56.         if (isset($this->wrappedListeners[$eventName])) {
  57.             foreach ($this->wrappedListeners[$eventName] as $index => $wrappedListener) {
  58.                 if ($wrappedListener->getWrappedListener() === $listener) {
  59.                     $listener $wrappedListener;
  60.                     unset($this->wrappedListeners[$eventName][$index]);
  61.                     break;
  62.                 }
  63.             }
  64.         }
  65.         return $this->dispatcher->removeListener($eventName$listener);
  66.     }
  67.     /**
  68.      * {@inheritdoc}
  69.      */
  70.     public function removeSubscriber(EventSubscriberInterface $subscriber)
  71.     {
  72.         return $this->dispatcher->removeSubscriber($subscriber);
  73.     }
  74.     /**
  75.      * {@inheritdoc}
  76.      */
  77.     public function getListeners($eventName null)
  78.     {
  79.         return $this->dispatcher->getListeners($eventName);
  80.     }
  81.     /**
  82.      * {@inheritdoc}
  83.      */
  84.     public function getListenerPriority($eventName$listener)
  85.     {
  86.         // we might have wrapped listeners for the event (if called while dispatching)
  87.         // in that case get the priority by wrapper
  88.         if (isset($this->wrappedListeners[$eventName])) {
  89.             foreach ($this->wrappedListeners[$eventName] as $index => $wrappedListener) {
  90.                 if ($wrappedListener->getWrappedListener() === $listener) {
  91.                     return $this->dispatcher->getListenerPriority($eventName$wrappedListener);
  92.                 }
  93.             }
  94.         }
  95.         return $this->dispatcher->getListenerPriority($eventName$listener);
  96.     }
  97.     /**
  98.      * {@inheritdoc}
  99.      */
  100.     public function hasListeners($eventName null)
  101.     {
  102.         return $this->dispatcher->hasListeners($eventName);
  103.     }
  104.     /**
  105.      * {@inheritdoc}
  106.      */
  107.     public function dispatch($eventNameEvent $event null)
  108.     {
  109.         if (null === $this->callStack) {
  110.             $this->callStack = new \SplObjectStorage();
  111.         }
  112.         if (null === $event) {
  113.             $event = new Event();
  114.         }
  115.         if (null !== $this->logger && $event->isPropagationStopped()) {
  116.             $this->logger->debug(sprintf('The "%s" event is already stopped. No listeners have been called.'$eventName));
  117.         }
  118.         $this->preProcess($eventName);
  119.         try {
  120.             $this->preDispatch($eventName$event);
  121.             try {
  122.                 $e $this->stopwatch->start($eventName'section');
  123.                 try {
  124.                     $this->dispatcher->dispatch($eventName$event);
  125.                 } finally {
  126.                     if ($e->isStarted()) {
  127.                         $e->stop();
  128.                     }
  129.                 }
  130.             } finally {
  131.                 $this->postDispatch($eventName$event);
  132.             }
  133.         } finally {
  134.             $this->postProcess($eventName);
  135.         }
  136.         return $event;
  137.     }
  138.     /**
  139.      * {@inheritdoc}
  140.      */
  141.     public function getCalledListeners()
  142.     {
  143.         if (null === $this->callStack) {
  144.             return [];
  145.         }
  146.         $called = [];
  147.         foreach ($this->callStack as $listener) {
  148.             list($eventName) = $this->callStack->getInfo();
  149.             $called[] = $listener->getInfo($eventName);
  150.         }
  151.         return $called;
  152.     }
  153.     /**
  154.      * {@inheritdoc}
  155.      */
  156.     public function getNotCalledListeners()
  157.     {
  158.         try {
  159.             $allListeners $this->getListeners();
  160.         } catch (\Exception $e) {
  161.             if (null !== $this->logger) {
  162.                 $this->logger->info('An exception was thrown while getting the uncalled listeners.', ['exception' => $e]);
  163.             }
  164.             // unable to retrieve the uncalled listeners
  165.             return [];
  166.         }
  167.         $notCalled = [];
  168.         foreach ($allListeners as $eventName => $listeners) {
  169.             foreach ($listeners as $listener) {
  170.                 $called false;
  171.                 if (null !== $this->callStack) {
  172.                     foreach ($this->callStack as $calledListener) {
  173.                         if ($calledListener->getWrappedListener() === $listener) {
  174.                             $called true;
  175.                             break;
  176.                         }
  177.                     }
  178.                 }
  179.                 if (!$called) {
  180.                     if (!$listener instanceof WrappedListener) {
  181.                         $listener = new WrappedListener($listenernull$this->stopwatch$this);
  182.                     }
  183.                     $notCalled[] = $listener->getInfo($eventName);
  184.                 }
  185.             }
  186.         }
  187.         uasort($notCalled, [$this'sortNotCalledListeners']);
  188.         return $notCalled;
  189.     }
  190.     public function reset()
  191.     {
  192.         $this->callStack null;
  193.     }
  194.     /**
  195.      * Proxies all method calls to the original event dispatcher.
  196.      *
  197.      * @param string $method    The method name
  198.      * @param array  $arguments The method arguments
  199.      *
  200.      * @return mixed
  201.      */
  202.     public function __call($method$arguments)
  203.     {
  204.         return \call_user_func_array([$this->dispatcher$method], $arguments);
  205.     }
  206.     /**
  207.      * Called before dispatching the event.
  208.      *
  209.      * @param string $eventName The event name
  210.      * @param Event  $event     The event
  211.      */
  212.     protected function preDispatch($eventNameEvent $event)
  213.     {
  214.     }
  215.     /**
  216.      * Called after dispatching the event.
  217.      *
  218.      * @param string $eventName The event name
  219.      * @param Event  $event     The event
  220.      */
  221.     protected function postDispatch($eventNameEvent $event)
  222.     {
  223.     }
  224.     private function preProcess($eventName)
  225.     {
  226.         foreach ($this->dispatcher->getListeners($eventName) as $listener) {
  227.             $priority $this->getListenerPriority($eventName$listener);
  228.             $wrappedListener = new WrappedListener($listener instanceof WrappedListener $listener->getWrappedListener() : $listenernull$this->stopwatch$this);
  229.             $this->wrappedListeners[$eventName][] = $wrappedListener;
  230.             $this->dispatcher->removeListener($eventName$listener);
  231.             $this->dispatcher->addListener($eventName$wrappedListener$priority);
  232.             $this->callStack->attach($wrappedListener, [$eventName]);
  233.         }
  234.     }
  235.     private function postProcess($eventName)
  236.     {
  237.         unset($this->wrappedListeners[$eventName]);
  238.         $skipped false;
  239.         foreach ($this->dispatcher->getListeners($eventName) as $listener) {
  240.             if (!$listener instanceof WrappedListener) { // #12845: a new listener was added during dispatch.
  241.                 continue;
  242.             }
  243.             // Unwrap listener
  244.             $priority $this->getListenerPriority($eventName$listener);
  245.             $this->dispatcher->removeListener($eventName$listener);
  246.             $this->dispatcher->addListener($eventName$listener->getWrappedListener(), $priority);
  247.             if (null !== $this->logger) {
  248.                 $context = ['event' => $eventName'listener' => $listener->getPretty()];
  249.             }
  250.             if ($listener->wasCalled()) {
  251.                 if (null !== $this->logger) {
  252.                     $this->logger->debug('Notified event "{event}" to listener "{listener}".'$context);
  253.                 }
  254.             } else {
  255.                 $this->callStack->detach($listener);
  256.             }
  257.             if (null !== $this->logger && $skipped) {
  258.                 $this->logger->debug('Listener "{listener}" was not called for event "{event}".'$context);
  259.             }
  260.             if ($listener->stoppedPropagation()) {
  261.                 if (null !== $this->logger) {
  262.                     $this->logger->debug('Listener "{listener}" stopped propagation of the event "{event}".'$context);
  263.                 }
  264.                 $skipped true;
  265.             }
  266.         }
  267.     }
  268.     private function sortNotCalledListeners(array $a, array $b)
  269.     {
  270.         if (!== $cmp strcmp($a['event'], $b['event'])) {
  271.             return $cmp;
  272.         }
  273.         if (\is_int($a['priority']) && !\is_int($b['priority'])) {
  274.             return 1;
  275.         }
  276.         if (!\is_int($a['priority']) && \is_int($b['priority'])) {
  277.             return -1;
  278.         }
  279.         if ($a['priority'] === $b['priority']) {
  280.             return 0;
  281.         }
  282.         if ($a['priority'] > $b['priority']) {
  283.             return -1;
  284.         }
  285.         return 1;
  286.     }
  287. }