FriendsOfSymfony / FOSHttpCacheBundle

src/EventListener/CacheControlListener.php

<?php

/*
 * This file is part of the FOSHttpCacheBundle package.
 *
 * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace FOS\HttpCacheBundle\EventListener;

use FOS\HttpCacheBundle\Http\RuleMatcherInterface;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
use Symfony\Component\HttpKernel\KernelEvents;

/**
 * Set caching settings on matching response according to the configurations.
 *
 * The first matching ruleset is applied.
 *
 * @author Lea Haensenberger <lea.haensenberger@gmail.com>
 * @author David Buchmann <mail@davidbu.ch>
 */
class CacheControlListener implements EventSubscriberInterface
{
    /**
     * Whether to skip this response and not set any cache headers.
     *
     * @var bool
     */
    private $skip = false;

    /**
     * Cache control directives directly supported by Response.
     *
     * @var array
     */
    private $supportedDirectives = [
        'max_age' => true,
        's_maxage' => true,
        'private' => true,
        'public' => true,
    ];

    /**
     * @var array List of arrays with RuleMatcherInterface, settings array
     */
    private $rulesMap = [];

    /**
     * If not empty, add a debug header with that name to all responses,
     * telling the cache proxy to add debug output.
     *
     * @var string|bool Name of the header or false to add no header
     */
    private $debugHeader;

    /**
     * @param string|bool $debugHeader Header to set to trigger debugging, or false to send no header
     */
    public function __construct($debugHeader = false)
    {
        $this->debugHeader = $debugHeader;
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [
            KernelEvents::RESPONSE => ['onKernelResponse', 10],
        ];
    }

    /**
     * Set whether to skip this response completely.
     *
     * This can be called when other parts of the application took care of all
     * cache headers. No attempt to merge cache headers is made anymore.
     *
     * The debug header is still added if configured.
     *
     * @param bool $skip
     */
    public function setSkip($skip = true)
    {
        $this->skip = $skip;
    }

    /**
     * Apply the header rules if the request matches.
     *
     * @param FilterResponseEvent $event
     */
    public function onKernelResponse(FilterResponseEvent $event)
    {
        $request = $event->getRequest();
        $response = $event->getResponse();

        if ($this->debugHeader) {
            $response->headers->set($this->debugHeader, 1, false);
        }

        // do not change cache directives on non-cacheable requests.
        if ($this->skip || !$request->isMethodCacheable()) {
            return;
        }

        $options = $this->matchRule($request, $response);

        if (false === $options) {
            return;
        }

        if (!empty($options['cache_control'])) {
            $directives = array_intersect_key($options['cache_control'], $this->supportedDirectives);
            $extraDirectives = array_diff_key($options['cache_control'], $directives);
            if (!empty($directives)) {
                $this->setCache($response, $directives, $options['overwrite']);
            }
            if (!empty($extraDirectives)) {
                $this->setExtraCacheDirectives($response, $extraDirectives, $options['overwrite']);
            }
        }

        if (isset($options['reverse_proxy_ttl'])
            && null !== $options['reverse_proxy_ttl']
            && !$response->headers->has('X-Reverse-Proxy-TTL')
        ) {
            $response->headers->set('X-Reverse-Proxy-TTL', (int) $options['reverse_proxy_ttl'], false);
        }

        if (!empty($options['vary'])) {
            $response->setVary($options['vary'], $options['overwrite']);
        }

        if (!empty($options['etag'])
            && ($options['overwrite'] || null === $response->getEtag())
        ) {
            $response->setEtag(md5($response->getContent()), 'weak' === $options['etag']);
        }
        if (isset($options['last_modified'])
            && ($options['overwrite'] || null === $response->getLastModified())
        ) {
            $response->setLastModified(new \DateTime($options['last_modified']));
        }
    }

    /**
     * Add a rule matcher with a list of header directives to apply if the
     * request and response are matched.
     *
     * @param RuleMatcherInterface $ruleMatcher The headers apply to request and response matched by this matcher
     * @param array                $settings    An array of header configuration
     */
    public function addRule(
        RuleMatcherInterface $ruleMatcher,
        array $settings = []
    ) {
        $this->rulesMap[] = [$ruleMatcher, $settings];
    }

    /**
     * Return the settings for the current request if any rule matches.
     *
     * @param Request $request
     *
     * @return array|false Settings to apply or false if no rule matched
     */
    private function matchRule(Request $request, Response $response)

This method seems to be duplicated in your project.

    {
        foreach ($this->rulesMap as $elements) {
            if ($elements[0]->matches($request, $response)) {
                return $elements[1];
            }
        }

        return false;
    }

    /**
     * Set cache headers on response.
     *
     * @param Response $response
     * @param array    $directives
     * @param bool     $overwrite  Whether to keep existing cache headers or to overwrite them
     */
    private function setCache(Response $response, array $directives, $overwrite)
    {
        if ($overwrite) {
            $response->setCache($directives);

            return;
        }

        if (false !== strpos($response->headers->get('Cache-Control'), 'no-cache')) {
            // this single header is set by default. if its the only thing, we override it.
            $response->setCache($directives);

            return;
        }

        foreach (array_keys($this->supportedDirectives) as $key) {
            $directive = str_replace('_', '-', $key);
            if ($response->headers->hasCacheControlDirective($directive)) {
                $directives[$key] = $response->headers->getCacheControlDirective($directive);
            }
            if ('public' === $directive && $response->headers->hasCacheControlDirective('private')
                || 'private' === $directive && $response->headers->hasCacheControlDirective('public')
            ) {
                unset($directives[$key]);
            }
        }

        $response->setCache($directives);
    }

    /**
     * Add extra cache control directives on response.
     *
     * @param Response $response
     * @param array    $controls
     * @param bool     $overwrite Whether to keep existing cache headers or to overwrite them
     */
    private function setExtraCacheDirectives(Response $response, array $controls, $overwrite)
    {
        $flags = ['must_revalidate', 'proxy_revalidate', 'no_transform', 'no_cache', 'no_store'];
        $options = ['stale_if_error', 'stale_while_revalidate'];

        foreach ($flags as $key) {

This code seems to be duplicated across your project.

            $flag = str_replace('_', '-', $key);
            if (!empty($controls[$key])
                && ($overwrite || !$response->headers->hasCacheControlDirective($flag))
            ) {
                $response->headers->addCacheControlDirective($flag);
            }
        }

        foreach ($options as $key) {

This code seems to be duplicated across your project.

            $option = str_replace('_', '-', $key);
            if (isset($controls[$key])
                && ($overwrite || !$response->headers->hasCacheControlDirective($option))
            ) {
                $response->headers->addCacheControlDirective($option, $controls[$key]);
            }
        }
    }
}