vendor/contao/core-bundle/src/EventListener/SubrequestCacheSubscriber.php line 57

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /*
  6.  * This file is part of Contao.
  7.  *
  8.  * (c) Leo Feyer
  9.  *
  10.  * @license LGPL-3.0-or-later
  11.  */
  13. namespace Contao\CoreBundle\EventListener;
  15. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  16. use Symfony\Component\HttpKernel\Event\RequestEvent;
  17. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  18. use Symfony\Component\HttpKernel\HttpCache\ResponseCacheStrategy;
  19. use Symfony\Component\HttpKernel\KernelEvents;
  20. use Symfony\Component\HttpKernel\KernelInterface;
  21. use Symfony\Contracts\Service\ResetInterface;
  23. /**
  24.  * The Symfony HttpCache ships with a ResponseCacheStrategy, which is used to
  25.  * merge the caching information of multiple ESI subrequests with the main
  26.  * response. It will make sure that the final response has the lowest possible
  27.  * cache time.
  28.  *
  29.  * In Contao, we use the same cache strategy to merge inline fragments into the
  30.  * main page content. This means a fragment like a content element or frontend
  31.  * module can influence the cache time of the page. A user might configure a
  32.  * cache time of 1 day in the page settings, but the news list module might
  33.  * know there is a news item scheduled for publishing in 5 hours (start time),
  34.  * so the page cache time will be set to 5 hours instead.
  35.  *
  36.  * To apply the cache merging, a specific header needs to be present in both
  37.  * the main and subrequest response. The header is automatically set for the
  38.  * page content and classes implementing the abstract content element and
  39.  * module controllers.
  40.  *
  41.  * @internal
  42.  */
  43. class SubrequestCacheSubscriber implements EventSubscriberInterface, ResetInterface
  44. {
  45.     public const MERGE_CACHE_HEADER = 'Contao-Merge-Cache-Control';
  47.     /**
  48.      * @var array<ResponseCacheStrategy>
  49.      */
  50.     private $strategyStack = [];
  52.     /**
  53.      * @var ResponseCacheStrategy|null
  54.      */
  55.     private $currentStrategy;
  57.     public function onKernelRequest(RequestEvent $event): void
  58.     {
  59.         if (KernelInterface::MASTER_REQUEST !== $event->getRequestType()) {
  60.             return;
  61.         }
  63.         if ($this->currentStrategy) {
  64.             $this->strategyStack[] = $this->currentStrategy;
  65.         }
  67.         $this->currentStrategy = new ResponseCacheStrategy();
  68.     }
  70.     public function onKernelResponse(ResponseEvent $event): void
  71.     {
  72.         $response = $event->getResponse();
  73.         $isMasterRequest = KernelInterface::MASTER_REQUEST === $event->getRequestType();
  75.         if ($this->currentStrategy && $response->headers->has(self::MERGE_CACHE_HEADER)) {
  76.             if ($isMasterRequest) {
  77.                 $this->currentStrategy->update($response);
  78.             } elseif ($response->headers->has('Cache-Control')) {
  79.                 $this->currentStrategy->add($response);
  80.             }
  81.         }
  83.         if ($isMasterRequest) {
  84.             $this->currentStrategy = array_pop($this->strategyStack);
  85.             $response->headers->remove(self::MERGE_CACHE_HEADER);
  86.         }
  87.     }
  89.     public function reset(): void
  90.     {
  91.         $this->currentStrategy = null;
  92.         $this->strategyStack = [];
  93.     }
  95.     public static function getSubscribedEvents(): array
  96.     {
  97.         return [
  98.             KernelEvents::REQUEST => ['onKernelRequest', 255],
  99.             KernelEvents::RESPONSE => ['onKernelResponse', -255],
  100.         ];
  101.     }
  102. }