[cache kernel] Adding a listener to remove cache tags before response is sent to the client

Author: Toflar

CHANGELOG.md

@@ -3,6 +3,14 @@ Changelog
 
 See also the [GitHub releases page](https://github.com/FriendsOfSymfony/FOSHttpCache/releases).
 
+2.4.0 (unreleased)
+------------------
+
+### Symfony
+
+* Added: `CleanupCacheTagsListener` to remove the cache tags header from the final
+  response that is sent to the client. Add this listener to your cache kernel.
+
 2.3.1
 -----
 

composer.json

@@ -54,7 +54,7 @@
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "2.3.x-dev"
+            "dev-master": "2.4.x-dev"
         }
     }
 }

doc/symfony-cache-configuration.rst

@@ -199,6 +199,10 @@ store does not have tagging support.
     To install the store, run
     ``composer require toflar/psr6-symfony-http-cache-store``.
 
+You should also add the ``CleanupCacheTagsListener`` to make sure the final
+response when sent to the client does not contain any cache tags in the
+headers anymore.
+
 Purging tags is only allowed from the same machine by default. To change this,
 you have the same configuration options as with the ``PurgeListener``. *Only
 set one of ``client_ips`` or ``client_matcher``*. Additionally, you can
@@ -229,6 +233,9 @@ To get cache tagging support, register the ``PurgeTagsListener`` and use the
 
     use Toflar\Psr6HttpCacheStore\Psr6Store;
     use FOS\HttpCache\SymfonyCache\PurgeTagsListener;
+    use FOS\HttpCache\SymfonyCache\CleanupCacheTagsListener;
+
+    const TAGS_HEADER = 'Custom-Cache-Tags-Header';
 
     // ...
 
@@ -242,12 +249,13 @@ To get cache tagging support, register the ``PurgeTagsListener`` and use the
     ) {
         $store = new Psr6Store([
             'cache_directory' => $kernel->getCacheDir(),
-            'cache_tags_header' => 'X-Cache-Tags',
+            'cache_tags_header' => self::TAGS_HEADER,
         ]);
 
         parent::__construct($kernel, $store, $surrogate, $options);
 
         $this->addSubscriber(new PurgeTagsListener());
+        $this->addSubscriber(new CleanupCacheTagsListener(self::TAGS_HEADER));
     }
 
 .. _symfony-cache user context:

src/SymfonyCache/CleanupCacheTagsListener.php

@@ -0,0 +1,56 @@
+<?php
+
+/*
+ * This file is part of the FOSHttpCache 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\HttpCache\SymfonyCache;
+
+use FOS\HttpCache\TagHeaderFormatter\TagHeaderFormatter;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+
+/**
+ * Listener to remove the cache tags header before the response
+ * is delivered to the client so it's not exposed to the world.
+ *
+ * @author Yanick Witschi <[email protected]>
+ */
+class CleanupCacheTagsListener implements EventSubscriberInterface
+{
+    /**
+     * @var string
+     */
+    private $tagsHeader;
+
+    /**
+     * @param string $tagsHeader The header that is used for cache tags
+     */
+    public function __construct($tagsHeader = TagHeaderFormatter::DEFAULT_HEADER_NAME)
+    {
+        $this->tagsHeader = $tagsHeader;
+    }
+
+    public function removeTagsHeader(CacheEvent $e)
+    {
+        if (null === $response = $e->getResponse()) {
+            return;
+        }
+
+        $response->headers->remove($this->tagsHeader);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public static function getSubscribedEvents()
+    {
+        return [
+            Events::POST_HANDLE => 'removeTagsHeader',
+        ];
+    }
+}

tests/Functional/Symfony/EventDispatchingHttpCacheTest.php

@@ -12,6 +12,7 @@
 namespace FOS\HttpCache\Tests\Functional\Symfony;
 
 use FOS\HttpCache\SymfonyCache\CacheInvalidation;
+use FOS\HttpCache\SymfonyCache\CleanupCacheTagsListener;
 use FOS\HttpCache\SymfonyCache\CustomTtlListener;
 use FOS\HttpCache\SymfonyCache\DebugListener;
 use FOS\HttpCache\SymfonyCache\EventDispatchingHttpCache;
@@ -38,6 +39,7 @@ public function testEventListeners()
         $request = new Request();
         $expectedResponse = new Response();
         $expectedResponse->headers->set('X-Reverse-Proxy-TTL', 60);
+        $expectedResponse->headers->set('X-Cache-Tags', 'foo, bar');
 
         $httpKernel = \Mockery::mock(HttpKernelInterface::class)
             ->shouldReceive('handle')
@@ -59,10 +61,12 @@ public function testEventListeners()
             // we already test anonymous hash lookup in the UserContextListener unit test
             'anonymous_hash' => 'abcdef',
         ]));
+        $kernel->addSubscriber(new CleanupCacheTagsListener());
 
         $response = $kernel->handle($request);
         $this->assertSame($expectedResponse, $response);
         $this->assertFalse($response->headers->has('X-Reverse-Proxy-TTL'));
+        $this->assertFalse($response->headers->has('X-Cache-Tags'));
     }
 }
 

tests/Unit/SymfonyCache/CleanupCacheTagsListenerTest.php

@@ -0,0 +1,70 @@
+<?php
+
+/*
+ * This file is part of the FOSHttpCache 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\HttpCache\Tests\Unit\SymfonyCache;
+
+use FOS\HttpCache\SymfonyCache\CacheEvent;
+use FOS\HttpCache\SymfonyCache\CacheInvalidation;
+use FOS\HttpCache\SymfonyCache\CleanupCacheTagsListener;
+use FOS\HttpCache\SymfonyCache\Events;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+
+/**
+ * @author Yanick Witschi <[email protected]>
+ */
+class CleanupCacheTagsListenerTest extends TestCase
+{
+    public function testSubscribedEvents()
+    {
+        $this->assertEquals([
+            Events::POST_HANDLE => 'removeTagsHeader',
+        ], CleanupCacheTagsListener::getSubscribedEvents());
+    }
+
+    public function testNoResponse()
+    {
+        $listener = new CleanupCacheTagsListener();
+        $listener->removeTagsHeader($this->createEvent());
+        $this->addToAssertionCount(1); // Nothing should happen, just asserting the "response is null" case
+    }
+
+    public function testResponseHeaderIsCleanedUp()
+    {
+        // Default cache tags header
+        $response = new Response();
+        $response->headers->set('X-Cache-Tags', 'foo, bar');
+
+        $listener = new CleanupCacheTagsListener();
+        $listener->removeTagsHeader($this->createEvent($response));
+
+        $this->assertFalse($response->headers->has('X-Cache-Tags'));
+
+        // Custom cache tags header
+        $response = new Response();
+        $response->headers->set('Foobar', 'foo, bar');
+
+        $listener = new CleanupCacheTagsListener('Foobar');
+        $listener->removeTagsHeader($this->createEvent($response));
+
+        $this->assertFalse($response->headers->has('Foobar'));
+    }
+
+    private function createEvent(Response $response = null)
+    {
+        return new CacheEvent(
+            $this->createMock(CacheInvalidation::class),
+            new Request(),
+            $response
+        );
+    }
+}