pimcore/lib/Pimcore/Bundle/CoreBundle/EventListener/Frontend/FullPageCacheListener.php line 303

Open in your IDE?
  1. <?php
  2. /**
  3.  * Pimcore
  4.  *
  5.  * This source file is available under two different licenses:
  6.  * - GNU General Public License version 3 (GPLv3)
  7.  * - Pimcore Enterprise License (PEL)
  8.  * Full copyright and license information is available in
  9.  * LICENSE.md which is distributed with this source code.
  10.  *
  11.  * @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  12.  * @license    http://www.pimcore.org/license     GPLv3 and PEL
  13.  */
  15. namespace Pimcore\Bundle\CoreBundle\EventListener\Frontend;
  17. use Pimcore\Bundle\CoreBundle\EventListener\Traits\PimcoreContextAwareTrait;
  18. use Pimcore\Cache;
  19. use Pimcore\Cache\FullPage\SessionStatus;
  20. use Pimcore\Event\Cache\FullPage\CacheResponseEvent;
  21. use Pimcore\Event\Cache\FullPage\PrepareResponseEvent;
  22. use Pimcore\Event\FullPageCacheEvents;
  23. use Pimcore\FeatureToggles\Features\DebugMode;
  24. use Pimcore\Http\Request\Resolver\PimcoreContextResolver;
  25. use Pimcore\Logger;
  26. use Pimcore\Targeting\VisitorInfoStorageInterface;
  27. use Pimcore\Tool;
  28. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  29. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  30. use Symfony\Component\HttpFoundation\Response;
  31. use Symfony\Component\HttpFoundation\StreamedResponse;
  32. use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
  33. use Symfony\Component\HttpKernel\Event\GetResponseEvent;
  34. use Symfony\Component\HttpKernel\Event\KernelEvent;
  36. class FullPageCacheListener
  37. {
  38.     use PimcoreContextAwareTrait;
  40.     /**
  41.      * @var VisitorInfoStorageInterface
  42.      */
  43.     private $visitorInfoStorage;
  45.     /**
  46.      * @var SessionStatus
  47.      */
  48.     private $sessionStatus;
  50.     /**
  51.      * @var EventDispatcherInterface
  52.      */
  53.     private $eventDispatcher;
  55.     /**
  56.      * @var bool
  57.      */
  58.     protected $enabled = true;
  60.     /**
  61.      * @var bool
  62.      */
  63.     protected $stopResponsePropagation = false;
  65.     /**
  66.      * @var null|int
  67.      */
  68.     protected $lifetime = null;
  70.     /**
  71.      * @var bool
  72.      */
  73.     protected $addExpireHeader = true;
  75.     /**
  76.      * @var string|null
  77.      */
  78.     protected $disableReason;
  80.     /**
  81.      * @var string
  82.      */
  83.     protected $defaultCacheKey;
  85.     public function __construct(
  86.         VisitorInfoStorageInterface $visitorInfoStorage,
  87.         SessionStatus $sessionStatus,
  88.         EventDispatcherInterface $eventDispatcher
  89.     ) {
  90.         $this->visitorInfoStorage = $visitorInfoStorage;
  91.         $this->sessionStatus      = $sessionStatus;
  92.         $this->eventDispatcher    = $eventDispatcher;
  93.     }
  95.     /**
  96.      * @param null $reason
  97.      *
  98.      * @return bool
  99.      */
  100.     public function disable($reason = null)
  101.     {
  102.         if ($reason) {
  103.             $this->disableReason = $reason;
  104.         }
  106.         $this->enabled = false;
  108.         return true;
  109.     }
  111.     /**
  112.      * @return bool
  113.      */
  114.     public function enable()
  115.     {
  116.         $this->enabled = true;
  118.         return true;
  119.     }
  121.     /**
  122.      * @return bool
  123.      */
  124.     public function isEnabled()
  125.     {
  126.         return $this->enabled;
  127.     }
  129.     /**
  130.      * @param $lifetime
  131.      *
  132.      * @return $this
  133.      */
  134.     public function setLifetime($lifetime)
  135.     {
  136.         $this->lifetime = $lifetime;
  138.         return $this;
  139.     }
  141.     /**
  142.      * @return int|null
  143.      */
  144.     public function getLifetime()
  145.     {
  146.         return $this->lifetime;
  147.     }
  149.     public function disableExpireHeader()
  150.     {
  151.         $this->addExpireHeader = false;
  152.     }
  154.     public function enableExpireHeader()
  155.     {
  156.         $this->addExpireHeader = true;
  157.     }
  159.     /**
  160.      * @param GetResponseEvent $event
  161.      *
  162.      * @return mixed
  163.      */
  164.     public function onKernelRequest(GetResponseEvent $event)
  165.     {
  166.         $request = $event->getRequest();
  168.         if (!$event->isMasterRequest()) {
  169.             return;
  170.         }
  172.         if (!$this->matchesPimcoreContext($request, PimcoreContextResolver::CONTEXT_DEFAULT)) {
  173.             return;
  174.         }
  176.         if (!\Pimcore\Tool::useFrontendOutputFilters()) {
  177.             return false;
  178.         }
  180.         $requestUri = $request->getRequestUri();
  181.         $excludePatterns = [];
  183.         // only enable GET method
  184.         if (!$request->isMethod('GET')) {
  185.             return $this->disable();
  186.         }
  188.         // disable the output-cache if browser wants the most recent version
  189.         // unfortunately only Chrome + Firefox if not using SSL
  190.         if (!$request->isSecure()) {
  191.             if (isset($_SERVER['HTTP_CACHE_CONTROL']) && $_SERVER['HTTP_CACHE_CONTROL'] == 'no-cache') {
  192.                 return $this->disable('HTTP Header Cache-Control: no-cache was sent');
  193.             }
  195.             if (isset($_SERVER['HTTP_PRAGMA']) && $_SERVER['HTTP_PRAGMA'] == 'no-cache') {
  196.                 return $this->disable('HTTP Header Pragma: no-cache was sent');
  197.             }
  198.         }
  200.         try {
  201.             $conf = \Pimcore\Config::getSystemConfig();
  202.             if ($conf->cache) {
  203.                 $conf = $conf->cache;
  205.                 if (!$conf->enabled) {
  206.                     return $this->disable();
  207.                 }
  209.                 if (\Pimcore::inDebugMode(DebugMode::DISABLE_FULL_PAGE_CACHE)) {
  210.                     return $this->disable('Debug flag DISABLE_FULL_PAGE_CACHE is enabled');
  211.                 }
  213.                 if ($conf->lifetime) {
  214.                     $this->setLifetime((int) $conf->lifetime);
  215.                 }
  217.                 if ($conf->excludePatterns) {
  218.                     $confExcludePatterns = explode(',', $conf->excludePatterns);
  219.                     if (!empty($confExcludePatterns)) {
  220.                         $excludePatterns = $confExcludePatterns;
  221.                     }
  222.                 }
  224.                 if ($conf->excludeCookie) {
  225.                     $cookies = explode(',', strval($conf->excludeCookie));
  227.                     foreach ($cookies as $cookie) {
  228.                         if (!empty($cookie) && isset($_COOKIE[trim($cookie)])) {
  229.                             return $this->disable('exclude cookie in system-settings matches');
  230.                         }
  231.                     }
  232.                 }
  234.                 // output-cache is always disabled when logged in at the admin ui
  235.                 if (null !== $pimcoreUser = Tool\Authentication::authenticateSession($request)) {
  236.                     return $this->disable('backend user is logged in');
  237.                 }
  238.             } else {
  239.                 return $this->disable();
  240.             }
  241.         } catch (\Exception $e) {
  242.             Logger::error($e);
  244.             return $this->disable('ERROR: Exception (see log files in /var/logs)');
  245.         }
  247.         foreach ($excludePatterns as $pattern) {
  248.             if (@preg_match($pattern, $requestUri)) {
  249.                 return $this->disable('exclude path pattern in system-settings matches');
  250.             }
  251.         }
  253.         // check if targeting matched anything and disable cache
  254.         if ($this->disabledByTargeting()) {
  255.             return $this->disable('Targeting matched rules/target groups');
  256.         }
  258.         $deviceDetector = Tool\DeviceDetector::getInstance();
  259.         $device = $deviceDetector->getDevice();
  260.         $deviceDetector->setWasUsed(false);
  262.         $appendKey = '';
  263.         // this is for example for the image-data-uri plugin
  264.         if (isset($_REQUEST['pimcore_cache_tag_suffix'])) {
  265.             $tags = $_REQUEST['pimcore_cache_tag_suffix'];
  266.             if (is_array($tags)) {
  267.                 $appendKey = '_' . implode('_', $tags);
  268.             }
  269.         }
  271.         $this->defaultCacheKey = 'output_' . md5(\Pimcore\Tool::getHostname() . $requestUri . $appendKey);
  272.         $cacheKeys = [
  273.             $this->defaultCacheKey . '_' . $device,
  274.             $this->defaultCacheKey,
  275.         ];
  277.         $cacheKey = null;
  278.         $cacheItem = null;
  279.         foreach ($cacheKeys as $cacheKey) {
  280.             $cacheItem = Cache::load($cacheKey);
  281.             if ($cacheItem) {
  282.                 break;
  283.             }
  284.         }
  286.         if ($cacheItem) {
  287.             /**
  288.              * @var $response Response
  289.              */
  290.             $response = $cacheItem;
  291.             $response->headers->set('X-Pimcore-Output-Cache-Tag', $cacheKey, true);
  292.             $cacheItemDate = strtotime($response->headers->get('X-Pimcore-Cache-Date'));
  293.             $response->headers->set('Age', (time() - $cacheItemDate));
  295.             $event->setResponse($response);
  296.             $this->stopResponsePropagation = true;
  297.         }
  298.     }
  300.     /**
  301.      * @param KernelEvent $event
  302.      */
  303.     public function stopPropagationCheck(KernelEvent $event)
  304.     {
  305.         if ($this->stopResponsePropagation) {
  306.             $event->stopPropagation();
  307.         }
  308.     }
  310.     /**
  311.      * @param FilterResponseEvent $event
  312.      *
  313.      * @return bool|void
  314.      */
  315.     public function onKernelResponse(FilterResponseEvent $event)
  316.     {
  317.         if (!$event->isMasterRequest()) {
  318.             return;
  319.         }
  321.         $request = $event->getRequest();
  322.         if (!\Pimcore\Tool::isFrontend() || \Pimcore\Tool::isFrontendRequestByAdmin($request)) {
  323.             return;
  324.         }
  326.         if (!$this->matchesPimcoreContext($request, PimcoreContextResolver::CONTEXT_DEFAULT)) {
  327.             return;
  328.         }
  330.         $response = $event->getResponse();
  331.         if (!$response) {
  332.             return;
  333.         }
  335.         if (!$this->responseCanBeCached($response)) {
  336.             $this->disable('Response can\'t be cached');
  337.         }
  339.         if ($this->enabled && $this->sessionStatus->isDisabledBySession($request)) {
  340.             $this->disable('Session in use');
  341.         }
  343.         if ($this->disableReason) {
  344.             $response->headers->set('X-Pimcore-Output-Cache-Disable-Reason', $this->disableReason, true);
  345.         }
  347.         if ($this->enabled && $response->getStatusCode() == 200 && $this->defaultCacheKey) {
  348.             try {
  349.                 if ($this->lifetime && $this->addExpireHeader) {
  350.                     // add cache control for proxies and http-caches like varnish, ...
  351.                     $response->headers->set('Cache-Control', 'public, max-age=' . $this->lifetime, true);
  353.                     // add expire header
  354.                     $date = new \DateTime('now');
  355.                     $date->add(new \DateInterval('PT' . $this->lifetime . 'S'));
  356.                     $response->headers->set('Expires', $date->format(\DateTime::RFC1123), true);
  357.                 }
  359.                 $now = new \DateTime('now');
  360.                 $response->headers->set('X-Pimcore-Cache-Date', $now->format(\DateTime::ISO8601));
  362.                 $cacheKey = $this->defaultCacheKey;
  363.                 $deviceDetector = Tool\DeviceDetector::getInstance();
  364.                 if ($deviceDetector->wasUsed()) {
  365.                     $cacheKey .= '_' . $deviceDetector->getDevice();
  366.                 }
  368.                 $event = new PrepareResponseEvent($request, $response);
  369.                 $this->eventDispatcher->dispatch(FullPageCacheEvents::PREPARE_RESPONSE, $event);
  371.                 $cacheItem = $event->getResponse();
  373.                 $tags = ['output'];
  374.                 if ($this->lifetime) {
  375.                     $tags = ['output_lifetime'];
  376.                 }
  378.                 Cache::save($cacheItem, $cacheKey, $tags, $this->lifetime, 1000, true);
  379.             } catch (\Exception $e) {
  380.                 Logger::error($e);
  382.                 return;
  383.             }
  384.         } else {
  385.             // output-cache was disabled, add "output" as cleared tag to ensure that no other "output" tagged elements
  386.             // like the inc and snippet cache get into the cache
  387.             Cache::addIgnoredTagOnSave('output_inline');
  388.         }
  389.     }
  391.     private function responseCanBeCached(Response $response): bool
  392.     {
  393.         $cache = true;
  395.         // do not cache common responses
  396.         if ($response instanceof BinaryFileResponse) {
  397.             $cache = false;
  398.         }
  400.         if ($response instanceof StreamedResponse) {
  401.             $cache = false;
  402.         }
  404.         // fire an event to allow full customozations
  405.         $event = new CacheResponseEvent($response, $cache);
  406.         $this->eventDispatcher->dispatch(FullPageCacheEvents::CACHE_RESPONSE, $event);
  408.         return $event->getCache();
  409.     }
  411.     private function disabledByTargeting(): bool
  412.     {
  413.         if (!$this->visitorInfoStorage->hasVisitorInfo()) {
  414.             return false;
  415.         }
  417.         $visitorInfo = $this->visitorInfoStorage->getVisitorInfo();
  419.         if (!empty($visitorInfo->getMatchingTargetingRules())) {
  420.             return true;
  421.         }
  423.         if (!empty($visitorInfo->getTargetGroupAssignments())) {
  424.             return true;
  425.         }
  427.         return false;
  428.     }
  429. }