Add rule matchers for cacheable and must invalidate

Author: ddeboer

src/DependencyInjection/FOSHttpCacheExtension.php

@@ -165,31 +165,30 @@ private function parseRuleMatcher(ContainerBuilder $container, array $match)
             $match['attributes']
         );
 
-        $extraCriteria = [];
-        foreach (['additional_cacheable_status', 'match_response'] as $extra) {
-            if (isset($match[$extra])) {
-                $extraCriteria[$extra] = $match[$extra];
-            }
-        }
+//        $extraCriteria = [];
+//        foreach (['additional_cacheable_status', 'match_response'] as $extra) {
+//            if (isset($match[$extra])) {
+//                $extraCriteria[$extra] = $match[$extra];
+//            }
+//        }
 
         return $this->createRuleMatcher(
             $container,
-            $requestMatcher,
-            $extraCriteria
+            $requestMatcher
         );
     }
 
-    private function createRuleMatcher(ContainerBuilder $container, Reference $requestMatcher, array $extraCriteria)
+    private function createRuleMatcher(ContainerBuilder $container, Reference $requestMatcher)
     {
-        $arguments = [(string) $requestMatcher, $extraCriteria];
+        $arguments = [(string) $requestMatcher];
         $serialized = serialize($arguments);
         $id = $this->getAlias().'.rule_matcher.'.md5($serialized).sha1($serialized);
 
         if (!$container->hasDefinition($id)) {
             $container
                 ->setDefinition($id, new DefinitionDecorator($this->getAlias().'.rule_matcher'))
                 ->replaceArgument(0, $requestMatcher)
-                ->replaceArgument(1, $extraCriteria)
+                ->replaceArgument(1, null)
             ;
         }
 

src/EventListener/InvalidationListener.php

@@ -15,6 +15,7 @@
 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;
@@ -55,6 +56,11 @@ class InvalidationListener extends AbstractRuleListener implements EventSubscrib
      */
     private $expressionLanguage;
 
+    /**
+     * @var RuleMatcherInterface
+     */
+    private $mustInvalidateRule;
+
     /**
      * Constructor.
      *
@@ -65,11 +71,13 @@ class InvalidationListener extends AbstractRuleListener implements EventSubscrib
     public function __construct(
         CacheManager $cacheManager,
         UrlGeneratorInterface $urlGenerator,
+        RuleMatcherInterface $mustInvalidateRule,
         ExpressionLanguage $expressionLanguage = null
     ) {
         $this->cacheManager = $cacheManager;
         $this->urlGenerator = $urlGenerator;
         $this->expressionLanguage = $expressionLanguage ?: new ExpressionLanguage();
+        $this->mustInvalidateRule = $mustInvalidateRule;
     }
 
     /**
@@ -89,9 +97,7 @@ public function onKernelTerminate(PostResponseEvent $event)
         $response = $event->getResponse();
 
         // Don't invalidate any caches if the request was unsuccessful
-        if ($response->getStatusCode() >= 200
-            && $response->getStatusCode() < 400
-        ) {
+        if ($this->mustInvalidateRule->matches($request, $response)) {
             $this->handleInvalidation($request, $response);
         }
 

src/EventListener/TagListener.php

@@ -13,6 +13,7 @@
 
 use FOS\HttpCacheBundle\CacheManager;
 use FOS\HttpCacheBundle\Configuration\Tag;
+use FOS\HttpCacheBundle\Http\RuleMatcherInterface;
 use FOS\HttpCacheBundle\Http\SymfonyResponseTagger;
 use Symfony\Component\EventDispatcher\EventSubscriberInterface;
 use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
@@ -43,6 +44,16 @@ class TagListener extends AbstractRuleListener implements EventSubscriberInterfa
      */
     private $expressionLanguage;
 
+    /**
+     * @var RuleMatcherInterface
+     */
+    private $mustInvalidateRule;
+
+    /**
+     * @var RuleMatcherInterface
+     */
+    private $cacheableRule;
+
     /**
      * Constructor.
      *
@@ -53,10 +64,14 @@ class TagListener extends AbstractRuleListener implements EventSubscriberInterfa
     public function __construct(
         CacheManager $cacheManager,
         SymfonyResponseTagger $tagHandler,
+        RuleMatcherInterface $cacheableRule,
+        RuleMatcherInterface $mustInvalidateRule,
         ExpressionLanguage $expressionLanguage = null
     ) {
         $this->cacheManager = $cacheManager;
         $this->symfonyResponseTagger = $tagHandler;
+        $this->cacheableRule = $cacheableRule;
+        $this->mustInvalidateRule = $mustInvalidateRule;
         $this->expressionLanguage = $expressionLanguage ?: new ExpressionLanguage();
     }
 
@@ -74,12 +89,14 @@ public function onKernelResponse(FilterResponseEvent $event)
         $request = $event->getRequest();
         $response = $event->getResponse();
 
-        $tags = [];
-        // Only set cache tags or invalidate them if response is successful
-        if ($response->isSuccessful()) {
-            $tags = $this->getAnnotationTags($request);
+        if (!$this->cacheableRule->matches($request, $response)
+            && !$this->mustInvalidateRule->matches($request, $response)
+        ) {
+            return;
         }
 
+        $tags = $this->getAnnotationTags($request);
+
         $configuredTags = $this->matchRule($request, $response);
         if ($configuredTags) {
             $tags = array_merge($tags, $configuredTags['tags']);
@@ -88,14 +105,15 @@ public function onKernelResponse(FilterResponseEvent $event)
             }
         }
 
-        if ($request->isMethodCacheable()) {
+        if ($this->cacheableRule->matches($request, $response)) {
+            // For safe requests (GET and HEAD), set cache tags on response
             $this->symfonyResponseTagger->addTags($tags);
             if (HttpKernelInterface::MASTER_REQUEST === $event->getRequestType()) {
-                // For safe requests (GET and HEAD), set cache tags on response
                 $this->symfonyResponseTagger->tagSymfonyResponse($response);
             }
-        } elseif (count($tags)) {
-            // For non-safe methods, invalidate the tags
+        } elseif (count($tags)
+            && $this->mustInvalidateRule->matches($request, $response)
+        ) {
             $this->cacheManager->invalidateTags($tags);
         }
     }

src/Http/RequestMatcher/CacheableRequestMatcher.php

@@ -0,0 +1,26 @@
+<?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\Http\RequestMatcher;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\RequestMatcherInterface;
+
+/**
+ * @see https://tools.ietf.org/html/rfc7231#section-4.2.3
+ */
+class CacheableRequestMatcher implements RequestMatcherInterface
+{
+    public function matches(Request $request)
+    {
+        return $request->isMethodCacheable();
+    }
+}

src/Http/RequestMatcher/UnsafeRequestMatcher.php

@@ -0,0 +1,23 @@
+<?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\Http\RequestMatcher;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\RequestMatcherInterface;
+
+class UnsafeRequestMatcher implements RequestMatcherInterface
+{
+    public function matches(Request $request)
+    {
+        return !$request->isMethodSafe();
+    }
+}

src/Http/ResponseMatcher/CacheableResponseMatcher.php

@@ -0,0 +1,42 @@
+<?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\Http\ResponseMatcher;
+
+use Symfony\Component\HttpFoundation\Response;
+
+/**
+ * Matches status codes as defined by IETF RFC 7231.
+ *
+ * @see https://tools.ietf.org/html/rfc7231#section-6.1
+ */
+class CacheableResponseMatcher implements ResponseMatcherInterface
+{
+    private $cacheableStatusCodes = [
+        200, 203, 204, 206,
+        300, 301,
+        404, 405, 410, 414,
+        501,
+    ];
+
+    private $additionalStatusCodes;
+
+    public function __construct(array $additionalStatusCodes = [])
+    {
+        $this->additionalStatusCodes = $additionalStatusCodes;
+    }
+
+    public function matches(Response $response)
+    {
+        return in_array($response->getStatusCode(), $this->cacheableStatusCodes)
+            || in_array($response->getStatusCode(), $this->additionalStatusCodes);
+    }
+}

src/Http/ResponseMatcher/NonErrorResponseMatcher.php

@@ -0,0 +1,29 @@
+<?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\Http\ResponseMatcher;
+
+use Symfony\Component\HttpFoundation\Response;
+
+/**
+ * "A cache MUST invalidate the effective Request URI ... when a non-error
+ * status code is received in response to an unsafe request method".
+ *
+ * @see https://tools.ietf.org/html/rfc7234#section-4.4
+ */
+class NonErrorResponseMatcher implements ResponseMatcherInterface
+{
+    public function matches(Response $response)
+    {
+        return $response->getStatusCode() >= 200
+            && $response->getStatusCode() < 400;
+    }
+}

src/Http/ResponseMatcher/ResponseMatcher.php

@@ -0,0 +1,63 @@
+<?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\Http\ResponseMatcher;
+
+use Symfony\Component\DependencyInjection\ExpressionLanguage;
+use Symfony\Component\HttpFoundation\Response;
+
+class ResponseMatcher implements ResponseMatcherInterface
+{
+    private $statusCodes;
+    private $expression;
+    private $expressionLanguage;
+
+    public function matchExpression($expression)
+    {
+        $this->expression = $expression;
+    }
+
+    public function matchStatusCodes(array $statusCodes)
+    {
+        $this->statusCodes = $statusCodes;
+    }
+
+    public function matches(Response $response)
+    {
+        if ($this->expression
+            && !$this->getExpressionLanguage()->evaluate($this->expression, [
+                'response' => $response,
+            ])
+        ) {
+            return false;
+        }
+
+        if ($this->statusCodes
+            && !in_array($response->getStatusCode(), $this->statusCodes)
+        ) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * @return ExpressionLanguage
+     */
+    private function getExpressionLanguage()
+    {
+        if (!$this->expressionLanguage) {
+            $this->expressionLanguage = new ExpressionLanguage();
+        }
+
+        return $this->expressionLanguage;
+    }
+}

src/Http/ResponseMatcher/ResponseMatcherInterface.php

@@ -0,0 +1,19 @@
+<?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\Http\ResponseMatcher;
+
+use Symfony\Component\HttpFoundation\Response;
+
+interface ResponseMatcherInterface
+{
+    public function matches(Response $response);
+}