FOS\HttpCacheBundle\EventListener\InvalidationListener

Complexity

Total Complexity

29

Size/Duplication

Total Lines	200
Duplicated Lines	11.5 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

98.33%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	onKernelTerminate()	0	17	3
A	onKernelException()	0	9	2
A	onConsoleTerminate()	0	8	3
A	getSubscribedEvents()	0	8	1
B	handleInvalidation()	0	31	8
A	invalidatePaths()	0	8	3
A	invalidateRoutes()	0	23	5
A	__construct()	11	11	1
A	getExpressionLanguage()	12	12	3

<?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\HttpCache\Exception\ExceptionCollection;
use FOS\HttpCacheBundle\CacheManager;
use FOS\HttpCacheBundle\Configuration\InvalidatePath;
use FOS\HttpCacheBundle\Configuration\InvalidateRoute;
use FOS\HttpCacheBundle\Http\RuleMatcherInterface;
use Symfony\Component\Console\ConsoleEvents;
use Symfony\Component\Console\Event\ConsoleEvent;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Event\PostResponseEvent;
use Symfony\Component\HttpKernel\Event\TerminateEvent;
use Symfony\Component\HttpKernel\Kernel;
use Symfony\Component\HttpKernel\KernelEvents;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;

if (Kernel::MAJOR_VERSION >= 5) {
    class_alias(TerminateEvent::class, 'FOS\HttpCacheBundle\EventListener\InvalidationTerminateEvent');
} else {
    class_alias(PostResponseEvent::class, 'FOS\HttpCacheBundle\EventListener\InvalidationTerminateEvent');
}

/**
 * On kernel.terminate event, this event handler invalidates routes for the
 * current request and flushes the CacheManager.
 *
 * @author David de Boer <david@driebit.nl>
 */
class InvalidationListener extends AbstractRuleListener implements EventSubscriberInterface
{
    /**
     * Cache manager.
     *
     * @var CacheManager
     */
    private $cacheManager;

    /**
     * Router.
     *
     * @var UrlGeneratorInterface
     */
    private $urlGenerator;

    /**
     * Router.
     *
     * @var ExpressionLanguage|null
     */
    private $expressionLanguage;

    /**
     * @var RuleMatcherInterface
     */
    private $mustInvalidateRule;

    /**
     * Constructor.
     */
    public function __construct(

This method seems to be duplicated in your project.

        CacheManager $cacheManager,
        UrlGeneratorInterface $urlGenerator,
        RuleMatcherInterface $mustInvalidateRule,
        ExpressionLanguage $expressionLanguage = null
    ) {
        $this->cacheManager = $cacheManager;
        $this->urlGenerator = $urlGenerator;
        $this->expressionLanguage = $expressionLanguage;
        $this->mustInvalidateRule = $mustInvalidateRule;
    }

    /**
     * Apply invalidators and flush cache manager.
     *
     * On kernel.terminate:
     * - see if any invalidators apply to the current request and, if so, add
     *   their routes to the cache manager;
     * - flush the cache manager in order to send invalidation requests to the
     *   HTTP cache.
     */
    public function onKernelTerminate(InvalidationTerminateEvent $event)
    {
        $request = $event->getRequest();
        $response = $event->getResponse();

        // Don't invalidate any caches if the request was unsuccessful
        if ($this->mustInvalidateRule->matches($request, $response)) {
            $this->handleInvalidation($request, $response);
        }

        try {
            $this->cacheManager->flush();
        } catch (ExceptionCollection $e) {
            // swallow exception
            // there is the fos_http_cache.event_listener.log to log them
        }
    }

    /**
     * Flush cache manager when kernel exception occurs.
     */
    public function onKernelException()
    {
        try {
            $this->cacheManager->flush();
        } catch (ExceptionCollection $e) {
            // swallow exception
            // there is the fos_http_cache.event_listener.log to log them
        }
    }

    /**
     * Flush cache manager when console terminates or errors.
     *
     * @throws ExceptionCollection If an exception occurs during flush
     */
    public function onConsoleTerminate(ConsoleEvent $event)
    {
        $num = $this->cacheManager->flush();

        if ($num > 0 && OutputInterface::VERBOSITY_VERBOSE <= $event->getOutput()->getVerbosity()) {
            $event->getOutput()->writeln(sprintf('Sent %d invalidation request(s)', $num));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [
            KernelEvents::TERMINATE => 'onKernelTerminate',
            KernelEvents::EXCEPTION => 'onKernelException',
            ConsoleEvents::TERMINATE => 'onConsoleTerminate',
        ];
    }

    /**
     * Handle the invalidation annotations and configured invalidators.
     */
    private function handleInvalidation(Request $request, Response $response)
    {
        // Check controller annotations
        if ($paths = $request->attributes->get('_invalidate_path')) {
            $this->invalidatePaths($paths);
        }

        if ($routes = $request->attributes->get('_invalidate_route')) {
            $this->invalidateRoutes($routes, $request);
        }

        // Check configured invalidators
        if (!$invalidatorConfigs = $this->matchRule($request, $response)) {

The call to InvalidationListener::matchRule() has too many arguments starting with $response.

            return;
        }

        $requestParams = $request->attributes->get('_route_params');
        foreach ($invalidatorConfigs as $route => $config) {
            $path = $this->urlGenerator->generate($route, $requestParams);
            // If extra route parameters should be ignored, strip the query
            // string generated by the Symfony router from the path
            if (isset($config['ignore_extra_params'])
                && $config['ignore_extra_params']
                && $pos = strpos($path, '?')
            ) {
                $path = substr($path, 0, $pos);
            }

            $this->cacheManager->invalidatePath($path);
        }
    }

    /**
     * Invalidate paths from annotations.
     *
     * @param array|InvalidatePath[] $pathConfigurations
     */
    private function invalidatePaths(array $pathConfigurations)
    {
        foreach ($pathConfigurations as $pathConfiguration) {
            foreach ($pathConfiguration->getPaths() as $path) {
                $this->cacheManager->invalidatePath($path);
            }
        }
    }

    /**
     * Invalidate routes from annotations.
     *
     * @param array|InvalidateRoute[] $routes
     */
    private function invalidateRoutes(array $routes, Request $request)
    {
        $values = $request->attributes->all();
        // if there is an attribute called "request", it needs to be accessed through the request.
        $values['request'] = $request;

        foreach ($routes as $route) {
            $params = [];

            if (null !== $route->getParams()) {
                // Iterate over route params and try to evaluate their values
                foreach ($route->getParams() as $key => $value) {
                    if (is_array($value)) {
                        $value = $this->getExpressionLanguage()->evaluate($value['expression'], $values);
                    }

                    $params[$key] = $value;
                }
            }

            $this->cacheManager->invalidateRoute($route->getName(), $params);
        }
    }

    private function getExpressionLanguage(): ExpressionLanguage

This method seems to be duplicated in your project.

    {
        if (!$this->expressionLanguage) {
            // the expression comes from controller annotations, we can't detect whether they use expressions while building the configuration
            if (!class_exists(ExpressionLanguage::class)) {
                throw new \RuntimeException('Invalidation rules with expressions require '.ExpressionLanguage::class.' to be available.');
            }
            $this->expressionLanguage = new ExpressionLanguage();
        }

        return $this->expressionLanguage;
    }
}