vendor/symfony/symfony/src/Symfony/Component/HttpKernel/HttpCache/HttpCache.php line 420

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * This code is partially based on the Rack-Cache library by Ryan Tomayko,
  9.  * which is released under the MIT license.
  10.  * (based on commit 02d2b48d75bcb63cf1c0c7149c077ad256542801)
  11.  *
  12.  * For the full copyright and license information, please view the LICENSE
  13.  * file that was distributed with this source code.
  14.  */
  16. namespace Symfony\Component\HttpKernel\HttpCache;
  18. use Symfony\Component\HttpKernel\HttpKernelInterface;
  19. use Symfony\Component\HttpKernel\TerminableInterface;
  20. use Symfony\Component\HttpFoundation\Request;
  21. use Symfony\Component\HttpFoundation\Response;
  23. /**
  24.  * Cache provides HTTP caching.
  25.  *
  26.  * @author Fabien Potencier <fabien@symfony.com>
  27.  */
  28. class HttpCache implements HttpKernelInterface, TerminableInterface
  29. {
  30.     private $kernel;
  31.     private $store;
  32.     private $request;
  33.     private $surrogate;
  34.     private $surrogateCacheStrategy;
  35.     private $options = array();
  36.     private $traces = array();
  38.     /**
  39.      * Constructor.
  40.      *
  41.      * The available options are:
  42.      *
  43.      *   * debug:                 If true, the traces are added as a HTTP header to ease debugging
  44.      *
  45.      *   * default_ttl            The number of seconds that a cache entry should be considered
  46.      *                            fresh when no explicit freshness information is provided in
  47.      *                            a response. Explicit Cache-Control or Expires headers
  48.      *                            override this value. (default: 0)
  49.      *
  50.      *   * private_headers        Set of request headers that trigger "private" cache-control behavior
  51.      *                            on responses that don't explicitly state whether the response is
  52.      *                            public or private via a Cache-Control directive. (default: Authorization and Cookie)
  53.      *
  54.      *   * allow_reload           Specifies whether the client can force a cache reload by including a
  55.      *                            Cache-Control "no-cache" directive in the request. Set it to ``true``
  56.      *                            for compliance with RFC 2616. (default: false)
  57.      *
  58.      *   * allow_revalidate       Specifies whether the client can force a cache revalidate by including
  59.      *                            a Cache-Control "max-age=0" directive in the request. Set it to ``true``
  60.      *                            for compliance with RFC 2616. (default: false)
  61.      *
  62.      *   * stale_while_revalidate Specifies the default number of seconds (the granularity is the second as the
  63.      *                            Response TTL precision is a second) during which the cache can immediately return
  64.      *                            a stale response while it revalidates it in the background (default: 2).
  65.      *                            This setting is overridden by the stale-while-revalidate HTTP Cache-Control
  66.      *                            extension (see RFC 5861).
  67.      *
  68.      *   * stale_if_error         Specifies the default number of seconds (the granularity is the second) during which
  69.      *                            the cache can serve a stale response when an error is encountered (default: 60).
  70.      *                            This setting is overridden by the stale-if-error HTTP Cache-Control extension
  71.      *                            (see RFC 5861).
  72.      */
  73.     public function __construct(HttpKernelInterface $kernel, StoreInterface $store, SurrogateInterface $surrogate = null, array $options = array())
  74.     {
  75.         $this->store = $store;
  76.         $this->kernel = $kernel;
  77.         $this->surrogate = $surrogate;
  79.         // needed in case there is a fatal error because the backend is too slow to respond
  80.         register_shutdown_function(array($this->store, 'cleanup'));
  82.         $this->options = array_merge(array(
  83.             'debug' => false,
  84.             'default_ttl' => 0,
  85.             'private_headers' => array('Authorization', 'Cookie'),
  86.             'allow_reload' => false,
  87.             'allow_revalidate' => false,
  88.             'stale_while_revalidate' => 2,
  89.             'stale_if_error' => 60,
  90.         ), $options);
  91.     }
  93.     /**
  94.      * Gets the current store.
  95.      *
  96.      * @return StoreInterface $store A StoreInterface instance
  97.      */
  98.     public function getStore()
  99.     {
  100.         return $this->store;
  101.     }
  103.     /**
  104.      * Returns an array of events that took place during processing of the last request.
  105.      *
  106.      * @return array An array of events
  107.      */
  108.     public function getTraces()
  109.     {
  110.         return $this->traces;
  111.     }
  113.     /**
  114.      * Returns a log message for the events of the last request processing.
  115.      *
  116.      * @return string A log message
  117.      */
  118.     public function getLog()
  119.     {
  120.         $log = array();
  121.         foreach ($this->traces as $request => $traces) {
  122.             $log[] = sprintf('%s: %s', $request, implode(', ', $traces));
  123.         }
  125.         return implode('; ', $log);
  126.     }
  128.     /**
  129.      * Gets the Request instance associated with the master request.
  130.      *
  131.      * @return Request A Request instance
  132.      */
  133.     public function getRequest()
  134.     {
  135.         return $this->request;
  136.     }
  138.     /**
  139.      * Gets the Kernel instance.
  140.      *
  141.      * @return HttpKernelInterface An HttpKernelInterface instance
  142.      */
  143.     public function getKernel()
  144.     {
  145.         return $this->kernel;
  146.     }
  148.     /**
  149.      * Gets the Surrogate instance.
  150.      *
  151.      * @return SurrogateInterface A Surrogate instance
  152.      *
  153.      * @throws \LogicException
  154.      */
  155.     public function getSurrogate()
  156.     {
  157.         return $this->surrogate;
  158.     }
  160.     /**
  161.      * {@inheritdoc}
  162.      */
  163.     public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
  164.     {
  165.         // FIXME: catch exceptions and implement a 500 error page here? -> in Varnish, there is a built-in error page mechanism
  166.         if (HttpKernelInterface::MASTER_REQUEST === $type) {
  167.             $this->traces = array();
  168.             // Keep a clone of the original request for surrogates so they can access it.
  169.             // We must clone here to get a separate instance because the application will modify the request during
  170.             // the application flow (we know it always does because we do ourselves by setting REMOTE_ADDR to 127.0.0.1
  171.             // and adding the X-Forwarded-For header, see HttpCache::forward()).
  172.             $this->request = clone $request;
  173.             if (null !== $this->surrogate) {
  174.                 $this->surrogateCacheStrategy = $this->surrogate->createCacheStrategy();
  175.             }
  176.         }
  178.         $this->traces[$this->getTraceKey($request)] = array();
  180.         if (!$request->isMethodSafe(false)) {
  181.             $response = $this->invalidate($request, $catch);
  182.         } elseif ($request->headers->has('expect') || !$request->isMethodCacheable()) {
  183.             $response = $this->pass($request, $catch);
  184.         } elseif ($this->options['allow_reload'] && $request->isNoCache()) {
  185.             /*
  186.                 If allow_reload is configured and the client requests "Cache-Control: no-cache",
  187.                 reload the cache by fetching a fresh response and caching it (if possible).
  188.             */
  189.             $this->record($request, 'reload');
  190.             $response = $this->fetch($request, $catch);
  191.         } else {
  192.             $response = $this->lookup($request, $catch);
  193.         }
  195.         $this->restoreResponseBody($request, $response);
  197.         if (HttpKernelInterface::MASTER_REQUEST === $type && $this->options['debug']) {
  198.             $response->headers->set('X-Symfony-Cache', $this->getLog());
  199.         }
  201.         if (null !== $this->surrogate) {
  202.             if (HttpKernelInterface::MASTER_REQUEST === $type) {
  203.                 $this->surrogateCacheStrategy->update($response);
  204.             } else {
  205.                 $this->surrogateCacheStrategy->add($response);
  206.             }
  207.         }
  209.         $response->prepare($request);
  211.         $response->isNotModified($request);
  213.         return $response;
  214.     }
  216.     /**
  217.      * {@inheritdoc}
  218.      */
  219.     public function terminate(Request $request, Response $response)
  220.     {
  221.         if ($this->getKernel() instanceof TerminableInterface) {
  222.             $this->getKernel()->terminate($request, $response);
  223.         }
  224.     }
  226.     /**
  227.      * Forwards the Request to the backend without storing the Response in the cache.
  228.      *
  229.      * @param Request $request A Request instance
  230.      * @param bool    $catch   Whether to process exceptions
  231.      *
  232.      * @return Response A Response instance
  233.      */
  234.     protected function pass(Request $request, $catch = false)
  235.     {
  236.         $this->record($request, 'pass');
  238.         return $this->forward($request, $catch);
  239.     }
  241.     /**
  242.      * Invalidates non-safe methods (like POST, PUT, and DELETE).
  243.      *
  244.      * @param Request $request A Request instance
  245.      * @param bool    $catch   Whether to process exceptions
  246.      *
  247.      * @return Response A Response instance
  248.      *
  249.      * @throws \Exception
  250.      *
  251.      * @see RFC2616 13.10
  252.      */
  253.     protected function invalidate(Request $request, $catch = false)
  254.     {
  255.         $response = $this->pass($request, $catch);
  257.         // invalidate only when the response is successful
  258.         if ($response->isSuccessful() || $response->isRedirect()) {
  259.             try {
  260.                 $this->store->invalidate($request);
  262.                 // As per the RFC, invalidate Location and Content-Location URLs if present
  263.                 foreach (array('Location', 'Content-Location') as $header) {
  264.                     if ($uri = $response->headers->get($header)) {
  265.                         $subRequest = Request::create($uri, 'get', array(), array(), array(), $request->server->all());
  267.                         $this->store->invalidate($subRequest);
  268.                     }
  269.                 }
  271.                 $this->record($request, 'invalidate');
  272.             } catch (\Exception $e) {
  273.                 $this->record($request, 'invalidate-failed');
  275.                 if ($this->options['debug']) {
  276.                     throw $e;
  277.                 }
  278.             }
  279.         }
  281.         return $response;
  282.     }
  284.     /**
  285.      * Lookups a Response from the cache for the given Request.
  286.      *
  287.      * When a matching cache entry is found and is fresh, it uses it as the
  288.      * response without forwarding any request to the backend. When a matching
  289.      * cache entry is found but is stale, it attempts to "validate" the entry with
  290.      * the backend using conditional GET. When no matching cache entry is found,
  291.      * it triggers "miss" processing.
  292.      *
  293.      * @param Request $request A Request instance
  294.      * @param bool    $catch   Whether to process exceptions
  295.      *
  296.      * @return Response A Response instance
  297.      *
  298.      * @throws \Exception
  299.      */
  300.     protected function lookup(Request $request, $catch = false)
  301.     {
  302.         try {
  303.             $entry = $this->store->lookup($request);
  304.         } catch (\Exception $e) {
  305.             $this->record($request, 'lookup-failed');
  307.             if ($this->options['debug']) {
  308.                 throw $e;
  309.             }
  311.             return $this->pass($request, $catch);
  312.         }
  314.         if (null === $entry) {
  315.             $this->record($request, 'miss');
  317.             return $this->fetch($request, $catch);
  318.         }
  320.         if (!$this->isFreshEnough($request, $entry)) {
  321.             $this->record($request, 'stale');
  323.             return $this->validate($request, $entry, $catch);
  324.         }
  326.         $this->record($request, 'fresh');
  328.         $entry->headers->set('Age', $entry->getAge());
  330.         return $entry;
  331.     }
  333.     /**
  334.      * Validates that a cache entry is fresh.
  335.      *
  336.      * The original request is used as a template for a conditional
  337.      * GET request with the backend.
  338.      *
  339.      * @param Request  $request A Request instance
  340.      * @param Response $entry   A Response instance to validate
  341.      * @param bool     $catch   Whether to process exceptions
  342.      *
  343.      * @return Response A Response instance
  344.      */
  345.     protected function validate(Request $request, Response $entry, $catch = false)
  346.     {
  347.         $subRequest = clone $request;
  349.         // send no head requests because we want content
  350.         if ('HEAD' === $request->getMethod()) {
  351.             $subRequest->setMethod('GET');
  352.         }
  354.         // add our cached last-modified validator
  355.         $subRequest->headers->set('if_modified_since', $entry->headers->get('Last-Modified'));
  357.         // Add our cached etag validator to the environment.
  358.         // We keep the etags from the client to handle the case when the client
  359.         // has a different private valid entry which is not cached here.
  360.         $cachedEtags = $entry->getEtag() ? array($entry->getEtag()) : array();
  361.         $requestEtags = $request->getETags();
  362.         if ($etags = array_unique(array_merge($cachedEtags, $requestEtags))) {
  363.             $subRequest->headers->set('if_none_match', implode(', ', $etags));
  364.         }
  366.         $response = $this->forward($subRequest, $catch, $entry);
  368.         if (304 == $response->getStatusCode()) {
  369.             $this->record($request, 'valid');
  371.             // return the response and not the cache entry if the response is valid but not cached
  372.             $etag = $response->getEtag();
  373.             if ($etag && in_array($etag, $requestEtags) && !in_array($etag, $cachedEtags)) {
  374.                 return $response;
  375.             }
  377.             $entry = clone $entry;
  378.             $entry->headers->remove('Date');
  380.             foreach (array('Date', 'Expires', 'Cache-Control', 'ETag', 'Last-Modified') as $name) {
  381.                 if ($response->headers->has($name)) {
  382.                     $entry->headers->set($name, $response->headers->get($name));
  383.                 }
  384.             }
  386.             $response = $entry;
  387.         } else {
  388.             $this->record($request, 'invalid');
  389.         }
  391.         if ($response->isCacheable()) {
  392.             $this->store($request, $response);
  393.         }
  395.         return $response;
  396.     }
  398.     /**
  399.      * Unconditionally fetches a fresh response from the backend and
  400.      * stores it in the cache if is cacheable.
  401.      *
  402.      * @param Request $request A Request instance
  403.      * @param bool    $catch   Whether to process exceptions
  404.      *
  405.      * @return Response A Response instance
  406.      */
  407.     protected function fetch(Request $request, $catch = false)
  408.     {
  409.         $subRequest = clone $request;
  411.         // send no head requests because we want content
  412.         if ('HEAD' === $request->getMethod()) {
  413.             $subRequest->setMethod('GET');
  414.         }
  416.         // avoid that the backend sends no content
  417.         $subRequest->headers->remove('if_modified_since');
  418.         $subRequest->headers->remove('if_none_match');
  420.         $response = $this->forward($subRequest, $catch);
  422.         if ($response->isCacheable()) {
  423.             $this->store($request, $response);
  424.         }
  426.         return $response;
  427.     }
  429.     /**
  430.      * Forwards the Request to the backend and returns the Response.
  431.      *
  432.      * All backend requests (cache passes, fetches, cache validations)
  433.      * run through this method.
  434.      *
  435.      * @param Request  $request A Request instance
  436.      * @param bool     $catch   Whether to catch exceptions or not
  437.      * @param Response $entry   A Response instance (the stale entry if present, null otherwise)
  438.      *
  439.      * @return Response A Response instance
  440.      */
  441.     protected function forward(Request $request, $catch = false, Response $entry = null)
  442.     {
  443.         if ($this->surrogate) {
  444.             $this->surrogate->addSurrogateCapability($request);
  445.         }
  447.         // modify the X-Forwarded-For header if needed
  448.         $forwardedFor = $request->headers->get('X-Forwarded-For');
  449.         if ($forwardedFor) {
  450.             $request->headers->set('X-Forwarded-For', $forwardedFor.', '.$request->server->get('REMOTE_ADDR'));
  451.         } else {
  452.             $request->headers->set('X-Forwarded-For', $request->server->get('REMOTE_ADDR'));
  453.         }
  455.         // fix the client IP address by setting it to 127.0.0.1 as HttpCache
  456.         // is always called from the same process as the backend.
  457.         $request->server->set('REMOTE_ADDR', '127.0.0.1');
  459.         // make sure HttpCache is a trusted proxy
  460.         if (!in_array('127.0.0.1', $trustedProxies = Request::getTrustedProxies())) {
  461.             $trustedProxies[] = '127.0.0.1';
  462.             Request::setTrustedProxies($trustedProxies, Request::HEADER_X_FORWARDED_ALL);
  463.         }
  465.         // always a "master" request (as the real master request can be in cache)
  466.         $response = $this->kernel->handle($request, HttpKernelInterface::MASTER_REQUEST, $catch);
  467.         // FIXME: we probably need to also catch exceptions if raw === true
  469.         // we don't implement the stale-if-error on Requests, which is nonetheless part of the RFC
  470.         if (null !== $entry && in_array($response->getStatusCode(), array(500, 502, 503, 504))) {
  471.             if (null === $age = $entry->headers->getCacheControlDirective('stale-if-error')) {
  472.                 $age = $this->options['stale_if_error'];
  473.             }
  475.             if (abs($entry->getTtl()) < $age) {
  476.                 $this->record($request, 'stale-if-error');
  478.                 return $entry;
  479.             }
  480.         }
  482.         /*
  483.             RFC 7231 Sect. 7.1.1.2 says that a server that does not have a reasonably accurate
  484.             clock MUST NOT send a "Date" header, although it MUST send one in most other cases
  485.             except for 1xx or 5xx responses where it MAY do so.
  487.             Anyway, a client that received a message without a "Date" header MUST add it.
  488.         */
  489.         if (!$response->headers->has('Date')) {
  490.             $response->setDate(\DateTime::createFromFormat('U', time()));
  491.         }
  493.         $this->processResponseBody($request, $response);
  495.         if ($this->isPrivateRequest($request) && !$response->headers->hasCacheControlDirective('public')) {
  496.             $response->setPrivate();
  497.         } elseif ($this->options['default_ttl'] > 0 && null === $response->getTtl() && !$response->headers->getCacheControlDirective('must-revalidate')) {
  498.             $response->setTtl($this->options['default_ttl']);
  499.         }
  501.         return $response;
  502.     }
  504.     /**
  505.      * Checks whether the cache entry is "fresh enough" to satisfy the Request.
  506.      *
  507.      * @return bool true if the cache entry if fresh enough, false otherwise
  508.      */
  509.     protected function isFreshEnough(Request $request, Response $entry)
  510.     {
  511.         if (!$entry->isFresh()) {
  512.             return $this->lock($request, $entry);
  513.         }
  515.         if ($this->options['allow_revalidate'] && null !== $maxAge = $request->headers->getCacheControlDirective('max-age')) {
  516.             return $maxAge > 0 && $maxAge >= $entry->getAge();
  517.         }
  519.         return true;
  520.     }
  522.     /**
  523.      * Locks a Request during the call to the backend.
  524.      *
  525.      * @return bool true if the cache entry can be returned even if it is staled, false otherwise
  526.      */
  527.     protected function lock(Request $request, Response $entry)
  528.     {
  529.         // try to acquire a lock to call the backend
  530.         $lock = $this->store->lock($request);
  532.         if (true === $lock) {
  533.             // we have the lock, call the backend
  534.             return false;
  535.         }
  537.         // there is already another process calling the backend
  539.         // May we serve a stale response?
  540.         if ($this->mayServeStaleWhileRevalidate($entry)) {
  541.             $this->record($request, 'stale-while-revalidate');
  543.             return true;
  544.         }
  546.         // wait for the lock to be released
  547.         if ($this->waitForLock($request)) {
  548.             // replace the current entry with the fresh one
  549.             $new = $this->lookup($request);
  550.             $entry->headers = $new->headers;
  551.             $entry->setContent($new->getContent());
  552.             $entry->setStatusCode($new->getStatusCode());
  553.             $entry->setProtocolVersion($new->getProtocolVersion());
  554.             foreach ($new->headers->getCookies() as $cookie) {
  555.                 $entry->headers->setCookie($cookie);
  556.             }
  557.         } else {
  558.             // backend is slow as hell, send a 503 response (to avoid the dog pile effect)
  559.             $entry->setStatusCode(503);
  560.             $entry->setContent('503 Service Unavailable');
  561.             $entry->headers->set('Retry-After', 10);
  562.         }
  564.         return true;
  565.     }
  567.     /**
  568.      * Writes the Response to the cache.
  569.      *
  570.      * @throws \Exception
  571.      */
  572.     protected function store(Request $request, Response $response)
  573.     {
  574.         try {
  575.             $this->store->write($request, $response);
  577.             $this->record($request, 'store');
  579.             $response->headers->set('Age', $response->getAge());
  580.         } catch (\Exception $e) {
  581.             $this->record($request, 'store-failed');
  583.             if ($this->options['debug']) {
  584.                 throw $e;
  585.             }
  586.         }
  588.         // now that the response is cached, release the lock
  589.         $this->store->unlock($request);
  590.     }
  592.     /**
  593.      * Restores the Response body.
  594.      */
  595.     private function restoreResponseBody(Request $request, Response $response)
  596.     {
  597.         if ($response->headers->has('X-Body-Eval')) {
  598.             ob_start();
  600.             if ($response->headers->has('X-Body-File')) {
  601.                 include $response->headers->get('X-Body-File');
  602.             } else {
  603.                 eval('; ?>'.$response->getContent().'<?php ;');
  604.             }
  606.             $response->setContent(ob_get_clean());
  607.             $response->headers->remove('X-Body-Eval');
  608.             if (!$response->headers->has('Transfer-Encoding')) {
  609.                 $response->headers->set('Content-Length', strlen($response->getContent()));
  610.             }
  611.         } elseif ($response->headers->has('X-Body-File')) {
  612.             // Response does not include possibly dynamic content (ESI, SSI), so we need
  613.             // not handle the content for HEAD requests
  614.             if (!$request->isMethod('HEAD')) {
  615.                 $response->setContent(file_get_contents($response->headers->get('X-Body-File')));
  616.             }
  617.         } else {
  618.             return;
  619.         }
  621.         $response->headers->remove('X-Body-File');
  622.     }
  624.     protected function processResponseBody(Request $request, Response $response)
  625.     {
  626.         if (null !== $this->surrogate && $this->surrogate->needsParsing($response)) {
  627.             $this->surrogate->process($request, $response);
  628.         }
  629.     }
  631.     /**
  632.      * Checks if the Request includes authorization or other sensitive information
  633.      * that should cause the Response to be considered private by default.
  634.      *
  635.      * @return bool true if the Request is private, false otherwise
  636.      */
  637.     private function isPrivateRequest(Request $request)
  638.     {
  639.         foreach ($this->options['private_headers'] as $key) {
  640.             $key = strtolower(str_replace('HTTP_', '', $key));
  642.             if ('cookie' === $key) {
  643.                 if (count($request->cookies->all())) {
  644.                     return true;
  645.                 }
  646.             } elseif ($request->headers->has($key)) {
  647.                 return true;
  648.             }
  649.         }
  651.         return false;
  652.     }
  654.     /**
  655.      * Records that an event took place.
  656.      *
  657.      * @param Request $request A Request instance
  658.      * @param string  $event   The event name
  659.      */
  660.     private function record(Request $request, $event)
  661.     {
  662.         $this->traces[$this->getTraceKey($request)][] = $event;
  663.     }
  665.     /**
  666.      * Calculates the key we use in the "trace" array for a given request.
  667.      *
  668.      * @param Request $request
  669.      *
  670.      * @return string
  671.      */
  672.     private function getTraceKey(Request $request)
  673.     {
  674.         $path = $request->getPathInfo();
  675.         if ($qs = $request->getQueryString()) {
  676.             $path .= '?'.$qs;
  677.         }
  679.         return $request->getMethod().' '.$path;
  680.     }
  682.     /**
  683.      * Checks whether the given (cached) response may be served as "stale" when a revalidation
  684.      * is currently in progress.
  685.      *
  686.      * @param Response $entry
  687.      *
  688.      * @return bool true when the stale response may be served, false otherwise
  689.      */
  690.     private function mayServeStaleWhileRevalidate(Response $entry)
  691.     {
  692.         $timeout = $entry->headers->getCacheControlDirective('stale-while-revalidate');
  694.         if (null === $timeout) {
  695.             $timeout = $this->options['stale_while_revalidate'];
  696.         }
  698.         return abs($entry->getTtl()) < $timeout;
  699.     }
  701.     /**
  702.      * Waits for the store to release a locked entry.
  703.      *
  704.      * @param Request $request The request to wait for
  705.      *
  706.      * @return bool true if the lock was released before the internal timeout was hit; false if the wait timeout was exceeded
  707.      */
  708.     private function waitForLock(Request $request)
  709.     {
  710.         $wait = 0;
  711.         while ($this->store->isLocked($request) && $wait < 100) {
  712.             usleep(50000);
  713.             ++$wait;
  714.         }
  716.         return $wait < 100;
  717.     }
  718. }