vendor/friendsofsymfony/http-cache/src/SymfonyCache/EventDispatchingHttpCache.php line 89

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the FOSHttpCache package.
  5.  *
  6.  * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace FOS\HttpCache\SymfonyCache;
  14. use Symfony\Component\EventDispatcher\EventDispatcher;
  15. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  16. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  17. use Symfony\Component\HttpFoundation\Request;
  18. use Symfony\Component\HttpFoundation\Response;
  19. use Symfony\Component\HttpKernel\HttpKernelInterface;
  21. /**
  22.  * Trait for enhanced Symfony reverse proxy based on the symfony kernel component.
  23.  *
  24.  * Your kernel needs to implement CacheInvalidatorInterface and redeclare the
  25.  * fetch method as public. (The latter is needed because the trait declaring it
  26.  * public does not satisfy the interface for whatever reason. See also
  27.  * http://stackoverflow.com/questions/31877844/php-trait-exposing-a-method-and-interfaces )
  28.  *
  29.  * CacheInvalidator kernels support event listeners that can act on the
  30.  * events defined in FOS\HttpCache\SymfonyCache\Events and may alter the
  31.  * request flow.
  32.  *
  33.  * If your kernel overwrites any of the methods defined in this trait, make
  34.  * sure to also call the trait method. You might get into issues with the order
  35.  * of events, in which case you will need to copy event triggering into your
  36.  * kernel.
  37.  *
  38.  * @author Jérôme Vieilledent <lolautruche@gmail.com> (courtesy of eZ Systems AS)
  39.  * @author David Buchmann <mail@davidbu.ch>
  40.  *
  41.  * {@inheritdoc}
  42.  */
  43. trait EventDispatchingHttpCache
  44. {
  45.     /**
  46.      * @var EventDispatcherInterface
  47.      */
  48.     private $eventDispatcher;
  50.     /**
  51.      * Get event dispatcher.
  52.      *
  53.      * @return EventDispatcherInterface
  54.      */
  55.     public function getEventDispatcher()
  56.     {
  57.         if (!$this->eventDispatcher) {
  58.             $this->eventDispatcher = new EventDispatcher();
  59.         }
  61.         return $this->eventDispatcher;
  62.     }
  64.     /**
  65.      * Add an event subscriber.
  66.      *
  67.      * @see EventDispatcherInterface::addSubscriber
  68.      */
  69.     public function addSubscriber(EventSubscriberInterface $subscriber)
  70.     {
  71.         $this->getEventDispatcher()->addSubscriber($subscriber);
  72.     }
  74.     /**
  75.      * Add an event listener to this HttpCache.
  76.      *
  77.      * @see EventDispatcherInterface::addListener
  78.      */
  79.     public function addListener($eventName, $listener, $priority = 0)
  80.     {
  81.         $this->getEventDispatcher()->addListener($eventName, $listener, $priority);
  82.     }
  84.     /**
  85.      * {@inheritdoc}
  86.      *
  87.      * Adding the Events::PRE_HANDLE and Events::POST_HANDLE events.
  88.      */
  89.     public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true): Response
  90.     {
  91.         // trigger loading the CacheEvent to avoid fatal error when HttpKernel::loadClassCache is used.
  92.         class_exists(CacheEvent::class);
  94.         if ($response = $this->dispatch(Events::PRE_HANDLE, $request, null, $type)) {
  95.             return $this->dispatch(Events::POST_HANDLE, $request, $response, $type);
  96.         }
  98.         $response = parent::handle($request, $type, $catch);
  100.         return $this->dispatch(Events::POST_HANDLE, $request, $response, $type);
  101.     }
  103.     /**
  104.      * {@inheritdoc}
  105.      *
  106.      * Trigger event to alter response before storing it in the cache.
  107.      */
  108.     protected function store(Request $request, Response $response)
  109.     {
  110.         $response = $this->dispatch(Events::PRE_STORE, $request, $response);
  112.         parent::store($request, $response);
  113.     }
  115.     /**
  116.      * {@inheritdoc}
  117.      *
  118.      * Adding the Events::PRE_INVALIDATE event.
  119.      */
  120.     protected function invalidate(Request $request, $catch = false): Response
  121.     {
  122.         if ($response = $this->dispatch(Events::PRE_INVALIDATE, $request)) {
  123.             return $response;
  124.         }
  126.         return parent::invalidate($request, $catch);
  127.     }
  129.     /**
  130.      * Dispatch an event if there are any listeners.
  131.      *
  132.      * @param string        $name        Name of the event to trigger. One of the constants in FOS\HttpCache\SymfonyCache\Events
  133.      * @param Response|null $response    If already available
  134.      * @param int           $requestType The request type (default HttpKernelInterface::MASTER_REQUEST)
  135.      *
  136.      * @return Response|null The response to return, which might be provided/altered by a listener
  137.      */
  138.     protected function dispatch($name, Request $request, Response $response = null, $requestType = HttpKernelInterface::MASTER_REQUEST): ?Response
  139.     {
  140.         if ($this->getEventDispatcher()->hasListeners($name)) {
  141.             $event = new CacheEvent($this, $request, $response, $requestType);
  142.             $this->getEventDispatcher()->dispatch($event, $name);
  144.             $response = $event->getResponse();
  145.         }
  147.         return $response;
  148.     }
  149. }