<?php

/*

 * This file is part of the Symfony package.

 *

 * (c) Fabien Potencier <fabien@symfony.com>

 *

 * This code is partially based on the Rack-Cache library by Ryan Tomayko,

 * which is released under the MIT license.

 * (based on commit 02d2b48d75bcb63cf1c0c7149c077ad256542801)

 *

 * For the full copyright and license information, please view the LICENSE

 * file that was distributed with this source code.

 */

namespace Symfony\Component\HttpKernel\HttpCache;

use Symfony\Component\HttpKernel\HttpKernelInterface;

use Symfony\Component\HttpFoundation\Request;

use Symfony\Component\HttpFoundation\Response;

/**

 * Cache provides HTTP caching.

 *

 * @author Fabien Potencier <fabien@symfony.com>

 *

 * @api

 */

class HttpCache implements HttpKernelInterface

{

    private $kernel;

    private $store;

    private $request;

    private $esi;

    private $esiCacheStrategy;

    private $traces;

    /**

     * Constructor.

     *

     * The available options are:

     *

     *   * debug:                 If true, the traces are added as a HTTP header to ease debugging

     *

     *   * default_ttl            The number of seconds that a cache entry should be considered

     *                            fresh when no explicit freshness information is provided in

     *                            a response. Explicit Cache-Control or Expires headers

     *                            override this value. (default: 0)

     *

     *   * private_headers        Set of request headers that trigger "private" cache-control behavior

     *                            on responses that don't explicitly state whether the response is

     *                            public or private via a Cache-Control directive. (default: Authorization and Cookie)

     *

     *   * allow_reload           Specifies whether the client can force a cache reload by including a

     *                            Cache-Control "no-cache" directive in the request. Set it to ``true``

     *                            for compliance with RFC 2616. (default: false)

     *

     *   * allow_revalidate       Specifies whether the client can force a cache revalidate by including

     *                            a Cache-Control "max-age=0" directive in the request. Set it to ``true``

     *                            for compliance with RFC 2616. (default: false)

     *

     *   * stale_while_revalidate Specifies the default number of seconds (the granularity is the second as the

     *                            Response TTL precision is a second) during which the cache can immediately return

     *                            a stale response while it revalidates it in the background (default: 2).

     *                            This setting is overridden by the stale-while-revalidate HTTP Cache-Control

     *                            extension (see RFC 5861).

     *

     *   * stale_if_error         Specifies the default number of seconds (the granularity is the second) during which

     *                            the cache can serve a stale response when an error is encountered (default: 60).

     *                            This setting is overridden by the stale-if-error HTTP Cache-Control extension

     *                            (see RFC 5861).

     *

     * @param HttpKernelInterface $kernel  An HttpKernelInterface instance

     * @param StoreInterface      $store   A Store instance

     * @param Esi                 $esi     An Esi instance

     * @param array               $options An array of options

     */

    public function __construct(HttpKernelInterface $kernel, StoreInterface $store, Esi $esi = null, array $options = array())

    {

        $this->store = $store;

        $this->kernel = $kernel;

        // needed in case there is a fatal error because the backend is too slow to respond

        register_shutdown_function(array($this->store, 'cleanup'));

        $this->options = array_merge(array(

            'debug'                  => false,

            'default_ttl'            => 0,

            'private_headers'        => array('Authorization', 'Cookie'),

            'allow_reload'           => false,

            'allow_revalidate'       => false,

            'stale_while_revalidate' => 2,

            'stale_if_error'         => 60,

        ), $options);

        $this->esi = $esi;

        $this->traces = array();

    }

    /**

     * Returns an array of events that took place during processing of the last request.

     *

     * @return array An array of events

     */

    public function getTraces()

    {

        return $this->traces;

    }

    /**

     * Returns a log message for the events of the last request processing.

     *

     * @return string A log message

     */

    public function getLog()

    {

        $log = array();

        foreach ($this->traces as $request => $traces) {

            $log[] = sprintf('%s: %s', $request, implode(', ', $traces));

        }

        return implode('; ', $log);

    }

    /**

     * Gets the Request instance associated with the master request.

     *

     * @return Symfony\Component\HttpFoundation\Request A Request instance

     */

    public function getRequest()

    {

        return $this->request;

    }

    /**

     * Gets the Kernel instance

     *

     * @return Symfony\Component\HttpKernel\HttpKernelInterface An HttpKernelInterface instance

     */

    public function getKernel()

    {

        return $this->kernel;

    }

    /**

     * Gets the Esi instance

     *

     * @return Symfony\Component\HttpKernel\HttpCache\Esi An Esi instance

     */

    public function getEsi()

    {

        return $this->esi;

    }

    /**

     * {@inheritdoc}

     *

     * @api

     */

    public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)

    {

        // FIXME: catch exceptions and implement a 500 error page here? -> in Varnish, there is a built-in error page mechanism

        if (HttpKernelInterface::MASTER_REQUEST === $type) {

            $this->traces = array();

            $this->request = $request;

            if (null !== $this->esi) {

                $this->esiCacheStrategy = $this->esi->createCacheStrategy();

            }

        }

        $path = $request->getPathInfo();

        if ($qs = $request->getQueryString()) {

            $path .= '?'.$qs;

        }

        $this->traces[$request->getMethod().' '.$path] = array();

        if (!$request->isMethodSafe()) {

            $response = $this->invalidate($request, $catch);

        } elseif ($request->headers->has('expect')) {

            $response = $this->pass($request, $catch);

        } else {

            $response = $this->lookup($request, $catch);

        }

        $response->isNotModified($request);

        $this->restoreResponseBody($request, $response);

        $response->setDate(new \DateTime(null, new \DateTimeZone('UTC')));

        if (HttpKernelInterface::MASTER_REQUEST === $type && $this->options['debug']) {

            $response->headers->set('X-Symfony-Cache', $this->getLog());

        }

        if (null !== $this->esi) {

            $this->esiCacheStrategy->add($response);

            if (HttpKernelInterface::MASTER_REQUEST === $type) {

                $this->esiCacheStrategy->update($response);

            }

        }

        $response->prepare();

        return $response;

    }

    /**

     * Forwards the Request to the backend without storing the Response in the cache.

     *

     * @param Request $request A Request instance

     * @param Boolean $catch   Whether to process exceptions

     *

     * @return Response A Response instance

     */

    protected function pass(Request $request, $catch = false)

    {

        $this->record($request, 'pass');

        return $this->forward($request, $catch);

    }

    /**

     * Invalidates non-safe methods (like POST, PUT, and DELETE).

     *

     * @param Request $request A Request instance

     * @param Boolean $catch   Whether to process exceptions

     *

     * @return Response A Response instance

     *

     * @see RFC2616 13.10

     */

    protected function invalidate(Request $request, $catch = false)

    {

        $response = $this->pass($request, $catch);

        // invalidate only when the response is successful

        if ($response->isSuccessful() || $response->isRedirect()) {

            try {

                $this->store->invalidate($request, $catch);

                $this->record($request, 'invalidate');

            } catch (\Exception $e) {

                $this->record($request, 'invalidate-failed');

                if ($this->options['debug']) {

                    throw $e;

                }

            }

        }

        return $response;

    }

    /**

     * Lookups a Response from the cache for the given Request.

     *

     * When a matching cache entry is found and is fresh, it uses it as the

     * response without forwarding any request to the backend. When a matching

     * cache entry is found but is stale, it attempts to "validate" the entry with

     * the backend using conditional GET. When no matching cache entry is found,

     * it triggers "miss" processing.

     *

     * @param Request $request A Request instance

     * @param Boolean $catch   whether to process exceptions

     *

     * @return Response A Response instance

     */

    protected function lookup(Request $request, $catch = false)

    {

        // if allow_reload and no-cache Cache-Control, allow a cache reload

        if ($this->options['allow_reload'] && $request->isNoCache()) {

            $this->record($request, 'reload');

            return $this->fetch($request);

        }

        try {

            $entry = $this->store->lookup($request);

        } catch (\Exception $e) {

            $this->record($request, 'lookup-failed');

            if ($this->options['debug']) {

                throw $e;

            }

            return $this->pass($request, $catch);

        }

        if (null === $entry) {

            $this->record($request, 'miss');

            return $this->fetch($request, $catch);

        }

        if (!$this->isFreshEnough($request, $entry)) {

            $this->record($request, 'stale');

            return $this->validate($request, $entry, $catch);

        }

        $this->record($request, 'fresh');

        $entry->headers->set('Age', $entry->getAge());

        return $entry;

    }

    /**

     * Validates that a cache entry is fresh.

     *

     * The original request is used as a template for a conditional

     * GET request with the backend.

     *

     * @param Request  $request A Request instance

     * @param Response $entry   A Response instance to validate

     * @param Boolean  $catch   Whether to process exceptions

     *

     * @return Response A Response instance

     */

    protected function validate(Request $request, Response $entry, $catch = false)

    {

        $subRequest = clone $request;

        // send no head requests because we want content

        $subRequest->setMethod('GET');

        // add our cached last-modified validator

        $subRequest->headers->set('if_modified_since', $entry->headers->get('Last-Modified'));

        // Add our cached etag validator to the environment.

        // We keep the etags from the client to handle the case when the client

        // has a different private valid entry which is not cached here.

        $cachedEtags = $entry->getEtag() ? array($entry->getEtag()) : array();

        $requestEtags = $request->getEtags();

        if ($etags = array_unique(array_merge($cachedEtags, $requestEtags))) {

            $subRequest->headers->set('if_none_match', implode(', ', $etags));

        }

        $response = $this->forward($subRequest, $catch, $entry);

        if (304 == $response->getStatusCode()) {

            $this->record($request, 'valid');

            // return the response and not the cache entry if the response is valid but not cached

            $etag = $response->getEtag();

            if ($etag && in_array($etag, $requestEtags) && !in_array($etag, $cachedEtags)) {

                return $response;

            }

            $entry = clone $entry;

            $entry->headers->remove('Date');

            foreach (array('Date', 'Expires', 'Cache-Control', 'ETag', 'Last-Modified') as $name) {

                if ($response->headers->has($name)) {

                    $entry->headers->set($name, $response->headers->get($name));

                }

            }

            $response = $entry;

        } else {

            $this->record($request, 'invalid');

        }

        if ($response->isCacheable()) {

            $this->store($request, $response);

        }

        return $response;

    }

    /**

     * Forwards the Request to the backend and determines whether the response should be stored.

     *

     * This methods is triggered when the cache missed or a reload is required.

     *

     * @param Request $request A Request instance

     * @param Boolean $catch   whether to process exceptions

     *

     * @return Response A Response instance

     */

    protected function fetch(Request $request, $catch = false)

    {

        $subRequest = clone $request;

        // send no head requests because we want content

        $subRequest->setMethod('GET');

        // avoid that the backend sends no content

        $subRequest->headers->remove('if_modified_since');

        $subRequest->headers->remove('if_none_match');

        $response = $this->forward($subRequest, $catch);

        if ($this->isPrivateRequest($request) && !$response->headers->hasCacheControlDirective('public')) {

            $response->setPrivate(true);

        } elseif ($this->options['default_ttl'] > 0 && null === $response->getTtl() && !$response->headers->getCacheControlDirective('must-revalidate')) {

            $response->setTtl($this->options['default_ttl']);

        }

        if ($response->isCacheable()) {

            $this->store($request, $response);

        }

        return $response;

    }

    /**

     * Forwards the Request to the backend and returns the Response.

     *

     * @param Request  $request A Request instance

     * @param Boolean  $catch   Whether to catch exceptions or not

     * @param Response $entry   A Response instance (the stale entry if present, null otherwise)

     *

     * @return Response A Response instance

     */

    protected function forward(Request $request, $catch = false, Response $entry = null)

    {

        if ($this->esi) {

            $this->esi->addSurrogateEsiCapability($request);

        }

        // always a "master" request (as the real master request can be in cache)

        $response = $this->kernel->handle($request, HttpKernelInterface::MASTER_REQUEST, $catch);

        // FIXME: we probably need to also catch exceptions if raw === true

        // we don't implement the stale-if-error on Requests, which is nonetheless part of the RFC

        if (null !== $entry && in_array($response->getStatusCode(), array(500, 502, 503, 504))) {

            if (null === $age = $entry->headers->getCacheControlDirective('stale-if-error')) {

                $age = $this->options['stale_if_error'];

            }

            if (abs($entry->getTtl()) < $age) {

                $this->record($request, 'stale-if-error');