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

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\PrepareResponseEvent;
  21. use Pimcore\Event\FullPageCacheEvents;
  22. use Pimcore\Http\Request\Resolver\PimcoreContextResolver;
  23. use Pimcore\Logger;
  24. use Pimcore\Targeting\VisitorInfoStorageInterface;
  25. use Pimcore\Tool;
  26. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  27. use Symfony\Component\HttpFoundation\Response;
  28. use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
  29. use Symfony\Component\HttpKernel\Event\GetResponseEvent;
  30. use Symfony\Component\HttpKernel\Event\KernelEvent;
  32. class FullPageCacheListener
  33. {
  34.     use PimcoreContextAwareTrait;
  36.     /**
  37.      * @var VisitorInfoStorageInterface
  38.      */
  39.     private $visitorInfoStorage;
  41.     /**
  42.      * @var SessionStatus
  43.      */
  44.     private $sessionStatus;
  46.     /**
  47.      * @var EventDispatcherInterface
  48.      */
  49.     private $eventDispatcher;
  51.     /**
  52.      * @var bool
  53.      */
  54.     protected $enabled = true;
  56.     /**
  57.      * @var bool
  58.      */
  59.     protected $stopResponsePropagation = false;
  61.     /**
  62.      * @var null|int
  63.      */
  64.     protected $lifetime = null;
  66.     /**
  67.      * @var bool
  68.      */
  69.     protected $addExpireHeader = true;
  71.     /**
  72.      * @var string|null
  73.      */
  74.     protected $disableReason;
  76.     /**
  77.      * @var string
  78.      */
  79.     protected $defaultCacheKey;
  81.     public function __construct(
  82.         VisitorInfoStorageInterface $visitorInfoStorage,
  83.         SessionStatus $sessionStatus,
  84.         EventDispatcherInterface $eventDispatcher
  85.     ) {
  86.         $this->visitorInfoStorage = $visitorInfoStorage;
  87.         $this->sessionStatus      = $sessionStatus;
  88.         $this->eventDispatcher    = $eventDispatcher;
  89.     }
  91.     /**
  92.      * @param null $reason
  93.      *
  94.      * @return bool
  95.      */
  96.     public function disable($reason = null)
  97.     {
  98.         if ($reason) {
  99.             $this->disableReason = $reason;
  100.         }
  102.         $this->enabled = false;
  104.         return true;
  105.     }
  107.     /**
  108.      * @return bool
  109.      */
  110.     public function enable()
  111.     {
  112.         $this->enabled = true;
  114.         return true;
  115.     }
  117.     /**
  118.      * @return bool
  119.      */
  120.     public function isEnabled()
  121.     {
  122.         return $this->enabled;
  123.     }
  125.     /**
  126.      * @param $lifetime
  127.      *
  128.      * @return $this
  129.      */
  130.     public function setLifetime($lifetime)
  131.     {
  132.         $this->lifetime = $lifetime;
  134.         return $this;
  135.     }
  137.     /**
  138.      * @return int|null
  139.      */
  140.     public function getLifetime()
  141.     {
  142.         return $this->lifetime;
  143.     }
  145.     public function disableExpireHeader()
  146.     {
  147.         $this->addExpireHeader = false;
  148.     }
  150.     public function enableExpireHeader()
  151.     {
  152.         $this->addExpireHeader = true;
  153.     }
  155.     /**
  156.      * @param GetResponseEvent $event
  157.      *
  158.      * @return mixed
  159.      */
  160.     public function onKernelRequest(GetResponseEvent $event)
  161.     {
  162.         $request = $event->getRequest();
  164.         if (!$event->isMasterRequest()) {
  165.             return;
  166.         }
  168.         if (!$this->matchesPimcoreContext($request, PimcoreContextResolver::CONTEXT_DEFAULT)) {
  169.             return;
  170.         }
  172.         if (!\Pimcore\Tool::useFrontendOutputFilters()) {
  173.             return false;
  174.         }
  176.         $requestUri = $request->getRequestUri();
  177.         $excludePatterns = [];
  179.         // only enable GET method
  180.         if (!$request->isMethod('GET')) {
  181.             return $this->disable();
  182.         }
  184.         // disable the output-cache if browser wants the most recent version
  185.         // unfortunately only Chrome + Firefox if not using SSL
  186.         if (!$request->isSecure()) {
  187.             if (isset($_SERVER['HTTP_CACHE_CONTROL']) && $_SERVER['HTTP_CACHE_CONTROL'] == 'no-cache') {
  188.                 return $this->disable('HTTP Header Cache-Control: no-cache was sent');
  189.             }
  191.             if (isset($_SERVER['HTTP_PRAGMA']) && $_SERVER['HTTP_PRAGMA'] == 'no-cache') {
  192.                 return $this->disable('HTTP Header Pragma: no-cache was sent');
  193.             }
  194.         }
  196.         try {
  197.             $conf = \Pimcore\Config::getSystemConfig();
  198.             if ($conf->cache) {
  199.                 $conf = $conf->cache;
  201.                 if (!$conf->enabled) {
  202.                     return $this->disable();
  203.                 }
  205.                 if (\Pimcore::inDebugMode()) {
  206.                     return $this->disable('in debug mode');
  207.                 }
  209.                 if ($conf->lifetime) {
  210.                     $this->setLifetime((int) $conf->lifetime);
  211.                 }
  213.                 if ($conf->excludePatterns) {
  214.                     $confExcludePatterns = explode(',', $conf->excludePatterns);
  215.                     if (!empty($confExcludePatterns)) {
  216.                         $excludePatterns = $confExcludePatterns;
  217.                     }
  218.                 }
  220.                 if ($conf->excludeCookie) {
  221.                     $cookies = explode(',', strval($conf->excludeCookie));
  223.                     foreach ($cookies as $cookie) {
  224.                         if (!empty($cookie) && isset($_COOKIE[trim($cookie)])) {
  225.                             return $this->disable('exclude cookie in system-settings matches');
  226.                         }
  227.                     }
  228.                 }
  230.                 // output-cache is always disabled when logged in at the admin ui
  231.                 if (null !== $pimcoreUser = Tool\Authentication::authenticateSession($request)) {
  232.                     return $this->disable('backend user is logged in');
  233.                 }
  234.             } else {
  235.                 return $this->disable();
  236.             }
  237.         } catch (\Exception $e) {
  238.             Logger::error($e);
  240.             return $this->disable('ERROR: Exception (see log files in /var/logs)');
  241.         }
  243.         foreach ($excludePatterns as $pattern) {
  244.             if (@preg_match($pattern, $requestUri)) {
  245.                 return $this->disable('exclude path pattern in system-settings matches');
  246.             }
  247.         }
  249.         // check if targeting matched anything and disable cache
  250.         if ($this->disabledByTargeting()) {
  251.             return $this->disable('Targeting matched rules/target groups');
  252.         }
  254.         $deviceDetector = Tool\DeviceDetector::getInstance();
  255.         $device = $deviceDetector->getDevice();
  256.         $deviceDetector->setWasUsed(false);
  258.         $appendKey = '';
  259.         // this is for example for the image-data-uri plugin
  260.         if (isset($_REQUEST['pimcore_cache_tag_suffix'])) {
  261.             $tags = $_REQUEST['pimcore_cache_tag_suffix'];
  262.             if (is_array($tags)) {
  263.                 $appendKey = '_' . implode('_', $tags);
  264.             }
  265.         }
  267.         $this->defaultCacheKey = 'output_' . md5(\Pimcore\Tool::getHostname() . $requestUri . $appendKey);
  268.         $cacheKeys = [
  269.             $this->defaultCacheKey . '_' . $device,
  270.             $this->defaultCacheKey,
  271.         ];
  273.         $cacheKey = null;
  274.         $cacheItem = null;
  275.         foreach ($cacheKeys as $cacheKey) {
  276.             $cacheItem = Cache::load($cacheKey);
  277.             if ($cacheItem) {
  278.                 break;
  279.             }
  280.         }
  282.         if ($cacheItem) {
  283.             /**
  284.              * @var $response Response
  285.              */
  286.             $response = $cacheItem;
  287.             $response->headers->set('X-Pimcore-Output-Cache-Tag', $cacheKey, true);
  288.             $cacheItemDate = strtotime($response->headers->get('X-Pimcore-Cache-Date'));
  289.             $response->headers->set('Age', (time() - $cacheItemDate));
  291.             $event->setResponse($response);
  292.             $this->stopResponsePropagation = true;
  293.         }
  294.     }
  296.     /**
  297.      * @param KernelEvent $event
  298.      */
  299.     public function stopPropagationCheck(KernelEvent $event)
  300.     {
  301.         if ($this->stopResponsePropagation) {
  302.             $event->stopPropagation();
  303.         }
  304.     }
  306.     /**
  307.      * @param FilterResponseEvent $event
  308.      *
  309.      * @return bool|void
  310.      */
  311.     public function onKernelResponse(FilterResponseEvent $event)
  312.     {
  313.         if (!$event->isMasterRequest()) {
  314.             return;
  315.         }
  317.         $request = $event->getRequest();
  318.         if (!\Pimcore\Tool::isFrontend() || \Pimcore\Tool::isFrontendRequestByAdmin($request)) {
  319.             return;
  320.         }
  322.         if (!$this->matchesPimcoreContext($request, PimcoreContextResolver::CONTEXT_DEFAULT)) {
  323.             return;
  324.         }
  326.         $response = $event->getResponse();
  327.         if (!$response) {
  328.             return;
  329.         }
  331.         if ($this->enabled && $this->sessionStatus->isDisabledBySession($request)) {
  332.             $this->disable('Session in use');
  333.         }
  335.         if ($this->disableReason) {
  336.             $response->headers->set('X-Pimcore-Output-Cache-Disable-Reason', $this->disableReason, true);
  337.         }
  339.         if ($this->enabled && $response->getStatusCode() == 200 && $this->defaultCacheKey) {
  340.             try {
  341.                 if ($this->lifetime && $this->addExpireHeader) {
  342.                     // add cache control for proxies and http-caches like varnish, ...
  343.                     $response->headers->set('Cache-Control', 'public, max-age=' . $this->lifetime, true);
  345.                     // add expire header
  346.                     $date = new \DateTime('now');
  347.                     $date->add(new \DateInterval('PT' . $this->lifetime . 'S'));
  348.                     $response->headers->set('Expires', $date->format(\DateTime::RFC1123), true);
  349.                 }
  351.                 $now = new \DateTime('now');
  352.                 $response->headers->set('X-Pimcore-Cache-Date', $now->format(\DateTime::ISO8601));
  354.                 $cacheKey = $this->defaultCacheKey;
  355.                 $deviceDetector = Tool\DeviceDetector::getInstance();
  356.                 if ($deviceDetector->wasUsed()) {
  357.                     $cacheKey .= '_' . $deviceDetector->getDevice();
  358.                 }
  360.                 $event = new PrepareResponseEvent($request, $response);
  361.                 $this->eventDispatcher->dispatch(FullPageCacheEvents::PREPARE_RESPONSE, $event);
  363.                 $cacheItem = $event->getResponse();
  365.                 $tags = ['output'];
  366.                 if ($this->lifetime) {
  367.                     $tags = ['output_lifetime'];
  368.                 }
  370.                 Cache::save($cacheItem, $cacheKey, $tags, $this->lifetime, 1000, true);
  371.             } catch (\Exception $e) {
  372.                 Logger::error($e);
  374.                 return;
  375.             }
  376.         } else {
  377.             // output-cache was disabled, add "output" as cleared tag to ensure that no other "output" tagged elements
  378.             // like the inc and snippet cache get into the cache
  379.             Cache::addIgnoredTagOnSave('output_inline');
  380.         }
  381.     }
  383.     private function disabledByTargeting(): bool
  384.     {
  385.         if (!$this->visitorInfoStorage->hasVisitorInfo()) {
  386.             return false;
  387.         }
  389.         $visitorInfo = $this->visitorInfoStorage->getVisitorInfo();
  391.         if (!empty($visitorInfo->getMatchingTargetingRules())) {
  392.             return true;
  393.         }
  395.         if (!empty($visitorInfo->getTargetGroupAssignments())) {
  396.             return true;
  397.         }
  399.         return false;
  400.     }
  401. }