yaffs.net Git - yaffs-website/blob - vendor/symfony/http-kernel/HttpCache/HttpCache.php

   1 <?php
   2
   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  */
  15
  16 namespace Symfony\Component\HttpKernel\HttpCache;
  17
  18 use Symfony\Component\HttpFoundation\Request;
  19 use Symfony\Component\HttpFoundation\Response;
  20 use Symfony\Component\HttpKernel\HttpKernelInterface;
  21 use Symfony\Component\HttpKernel\TerminableInterface;
  22
  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();
  37
  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;
  78
  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'));
  81
  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     }
  92
  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     }
 102
 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     }
 112
 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         }
 124
 125         return implode('; ', $log);
 126     }
 127
 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     }
 137
 138     /**
 139      * Gets the Kernel instance.
 140      *
 141      * @return HttpKernelInterface An HttpKernelInterface instance
 142      */
 143     public function getKernel()
 144     {
 145         return $this->kernel;
 146     }
 147
 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     }
 159
 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         }
 177
 178         $this->traces[$this->getTraceKey($request)] = array();
 179
 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         }
 194
 195         $this->restoreResponseBody($request, $response);
 196
 197         if (HttpKernelInterface::MASTER_REQUEST === $type && $this->options['debug']) {
 198             $response->headers->set('X-Symfony-Cache', $this->getLog());
 199         }
 200
 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         }
 208
 209         $response->prepare($request);
 210
 211         $response->isNotModified($request);
 212
 213         return $response;
 214     }
 215
 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     }
 225
 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');
 237
 238         return $this->forward($request, $catch);
 239     }
 240
 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);
 256
 257         // invalidate only when the response is successful
 258         if ($response->isSuccessful() || $response->isRedirect()) {
 259             try {
 260                 $this->store->invalidate($request);
 261
 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());
 266
 267                         $this->store->invalidate($subRequest);
 268                     }
 269                 }
 270
 271                 $this->record($request, 'invalidate');
 272             } catch (\Exception $e) {
 273                 $this->record($request, 'invalidate-failed');
 274
 275                 if ($this->options['debug']) {
 276                     throw $e;
 277                 }
 278             }
 279         }
 280
 281         return $response;
 282     }
 283
 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');
 306
 307             if ($this->options['debug']) {
 308                 throw $e;
 309             }
 310
 311             return $this->pass($request, $catch);
 312         }
 313
 314         if (null === $entry) {
 315             $this->record($request, 'miss');
 316
 317             return $this->fetch($request, $catch);
 318         }
 319
 320         if (!$this->isFreshEnough($request, $entry)) {
 321             $this->record($request, 'stale');
 322
 323             return $this->validate($request, $entry, $catch);
 324         }
 325
 326         $this->record($request, 'fresh');
 327
 328         $entry->headers->set('Age', $entry->getAge());
 329
 330         return $entry;
 331     }
 332
 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;
 348
 349         // send no head requests because we want content
 350         if ('HEAD' === $request->getMethod()) {
 351             $subRequest->setMethod('GET');
 352         }
 353
 354         // add our cached last-modified validator
 355         $subRequest->headers->set('if_modified_since', $entry->headers->get('Last-Modified'));
 356
 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         }
 365
 366         $response = $this->forward($subRequest, $catch, $entry);
 367
 368         if (304 == $response->getStatusCode()) {
 369             $this->record($request, 'valid');
 370
 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             }
 376
 377             $entry = clone $entry;
 378             $entry->headers->remove('Date');
 379
 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             }
 385
 386             $response = $entry;
 387         } else {
 388             $this->record($request, 'invalid');
 389         }
 390
 391         if ($response->isCacheable()) {
 392             $this->store($request, $response);
 393         }
 394
 395         return $response;
 396     }
 397
 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;
 410
 411         // send no head requests because we want content
 412         if ('HEAD' === $request->getMethod()) {
 413             $subRequest->setMethod('GET');
 414         }
 415
 416         // avoid that the backend sends no content
 417         $subRequest->headers->remove('if_modified_since');
 418         $subRequest->headers->remove('if_none_match');
 419
 420         $response = $this->forward($subRequest, $catch);
 421
 422         if ($response->isCacheable()) {
 423             $this->store($request, $response);
 424         }
 425
 426         return $response;
 427     }
 428
 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         }
 446
 447         // always a "master" request (as the real master request can be in cache)
 448         $response = SubRequestHandler::handle($this->kernel, $request, HttpKernelInterface::MASTER_REQUEST, $catch);
 449
 450         // we don't implement the stale-if-error on Requests, which is nonetheless part of the RFC
 451         if (null !== $entry && \in_array($response->getStatusCode(), array(500, 502, 503, 504))) {
 452             if (null === $age = $entry->headers->getCacheControlDirective('stale-if-error')) {
 453                 $age = $this->options['stale_if_error'];
 454             }
 455
 456             if (abs($entry->getTtl()) < $age) {
 457                 $this->record($request, 'stale-if-error');
 458
 459                 return $entry;
 460             }
 461         }
 462
 463         /*
 464             RFC 7231 Sect. 7.1.1.2 says that a server that does not have a reasonably accurate
 465             clock MUST NOT send a "Date" header, although it MUST send one in most other cases
 466             except for 1xx or 5xx responses where it MAY do so.
 467
 468             Anyway, a client that received a message without a "Date" header MUST add it.
 469         */
 470         if (!$response->headers->has('Date')) {
 471             $response->setDate(\DateTime::createFromFormat('U', time()));
 472         }
 473
 474         $this->processResponseBody($request, $response);
 475
 476         if ($this->isPrivateRequest($request) && !$response->headers->hasCacheControlDirective('public')) {
 477             $response->setPrivate();
 478         } elseif ($this->options['default_ttl'] > 0 && null === $response->getTtl() && !$response->headers->getCacheControlDirective('must-revalidate')) {
 479             $response->setTtl($this->options['default_ttl']);
 480         }
 481
 482         return $response;
 483     }
 484
 485     /**
 486      * Checks whether the cache entry is "fresh enough" to satisfy the Request.
 487      *
 488      * @return bool true if the cache entry if fresh enough, false otherwise
 489      */
 490     protected function isFreshEnough(Request $request, Response $entry)
 491     {
 492         if (!$entry->isFresh()) {
 493             return $this->lock($request, $entry);
 494         }
 495
 496         if ($this->options['allow_revalidate'] && null !== $maxAge = $request->headers->getCacheControlDirective('max-age')) {
 497             return $maxAge > 0 && $maxAge >= $entry->getAge();
 498         }
 499
 500         return true;
 501     }
 502
 503     /**
 504      * Locks a Request during the call to the backend.
 505      *
 506      * @return bool true if the cache entry can be returned even if it is staled, false otherwise
 507      */
 508     protected function lock(Request $request, Response $entry)
 509     {
 510         // try to acquire a lock to call the backend
 511         $lock = $this->store->lock($request);
 512
 513         if (true === $lock) {
 514             // we have the lock, call the backend
 515             return false;
 516         }
 517
 518         // there is already another process calling the backend
 519
 520         // May we serve a stale response?
 521         if ($this->mayServeStaleWhileRevalidate($entry)) {
 522             $this->record($request, 'stale-while-revalidate');
 523
 524             return true;
 525         }
 526
 527         // wait for the lock to be released
 528         if ($this->waitForLock($request)) {
 529             // replace the current entry with the fresh one
 530             $new = $this->lookup($request);
 531             $entry->headers = $new->headers;
 532             $entry->setContent($new->getContent());
 533             $entry->setStatusCode($new->getStatusCode());
 534             $entry->setProtocolVersion($new->getProtocolVersion());
 535             foreach ($new->headers->getCookies() as $cookie) {
 536                 $entry->headers->setCookie($cookie);
 537             }
 538         } else {
 539             // backend is slow as hell, send a 503 response (to avoid the dog pile effect)
 540             $entry->setStatusCode(503);
 541             $entry->setContent('503 Service Unavailable');
 542             $entry->headers->set('Retry-After', 10);
 543         }
 544
 545         return true;
 546     }
 547
 548     /**
 549      * Writes the Response to the cache.
 550      *
 551      * @throws \Exception
 552      */
 553     protected function store(Request $request, Response $response)
 554     {
 555         try {
 556             $this->store->write($request, $response);
 557
 558             $this->record($request, 'store');
 559
 560             $response->headers->set('Age', $response->getAge());
 561         } catch (\Exception $e) {
 562             $this->record($request, 'store-failed');
 563
 564             if ($this->options['debug']) {
 565                 throw $e;
 566             }
 567         }
 568
 569         // now that the response is cached, release the lock
 570         $this->store->unlock($request);
 571     }
 572
 573     /**
 574      * Restores the Response body.
 575      */
 576     private function restoreResponseBody(Request $request, Response $response)
 577     {
 578         if ($response->headers->has('X-Body-Eval')) {
 579             ob_start();
 580
 581             if ($response->headers->has('X-Body-File')) {
 582                 include $response->headers->get('X-Body-File');
 583             } else {
 584                 eval('; ?>'.$response->getContent().'<?php ;');
 585             }
 586
 587             $response->setContent(ob_get_clean());
 588             $response->headers->remove('X-Body-Eval');
 589             if (!$response->headers->has('Transfer-Encoding')) {
 590                 $response->headers->set('Content-Length', \strlen($response->getContent()));
 591             }
 592         } elseif ($response->headers->has('X-Body-File')) {
 593             // Response does not include possibly dynamic content (ESI, SSI), so we need
 594             // not handle the content for HEAD requests
 595             if (!$request->isMethod('HEAD')) {
 596                 $response->setContent(file_get_contents($response->headers->get('X-Body-File')));
 597             }
 598         } else {
 599             return;
 600         }
 601
 602         $response->headers->remove('X-Body-File');
 603     }
 604
 605     protected function processResponseBody(Request $request, Response $response)
 606     {
 607         if (null !== $this->surrogate && $this->surrogate->needsParsing($response)) {
 608             $this->surrogate->process($request, $response);
 609         }
 610     }
 611
 612     /**
 613      * Checks if the Request includes authorization or other sensitive information
 614      * that should cause the Response to be considered private by default.
 615      *
 616      * @return bool true if the Request is private, false otherwise
 617      */
 618     private function isPrivateRequest(Request $request)
 619     {
 620         foreach ($this->options['private_headers'] as $key) {
 621             $key = strtolower(str_replace('HTTP_', '', $key));
 622
 623             if ('cookie' === $key) {
 624                 if (\count($request->cookies->all())) {
 625                     return true;
 626                 }
 627             } elseif ($request->headers->has($key)) {
 628                 return true;
 629             }
 630         }
 631
 632         return false;
 633     }
 634
 635     /**
 636      * Records that an event took place.
 637      *
 638      * @param Request $request A Request instance
 639      * @param string  $event   The event name
 640      */
 641     private function record(Request $request, $event)
 642     {
 643         $this->traces[$this->getTraceKey($request)][] = $event;
 644     }
 645
 646     /**
 647      * Calculates the key we use in the "trace" array for a given request.
 648      *
 649      * @param Request $request
 650      *
 651      * @return string
 652      */
 653     private function getTraceKey(Request $request)
 654     {
 655         $path = $request->getPathInfo();
 656         if ($qs = $request->getQueryString()) {
 657             $path .= '?'.$qs;
 658         }
 659
 660         return $request->getMethod().' '.$path;
 661     }
 662
 663     /**
 664      * Checks whether the given (cached) response may be served as "stale" when a revalidation
 665      * is currently in progress.
 666      *
 667      * @param Response $entry
 668      *
 669      * @return bool true when the stale response may be served, false otherwise
 670      */
 671     private function mayServeStaleWhileRevalidate(Response $entry)
 672     {
 673         $timeout = $entry->headers->getCacheControlDirective('stale-while-revalidate');
 674
 675         if (null === $timeout) {
 676             $timeout = $this->options['stale_while_revalidate'];
 677         }
 678
 679         return abs($entry->getTtl()) < $timeout;
 680     }
 681
 682     /**
 683      * Waits for the store to release a locked entry.
 684      *
 685      * @param Request $request The request to wait for
 686      *
 687      * @return bool true if the lock was released before the internal timeout was hit; false if the wait timeout was exceeded
 688      */
 689     private function waitForLock(Request $request)
 690     {
 691         $wait = 0;
 692         while ($this->store->isLocked($request) && $wait < 100) {
 693             usleep(50000);
 694             ++$wait;
 695         }
 696
 697         return $wait < 100;
 698     }
 699 }