Support cache tagging

CacheManager.php

@@ -3,6 +3,9 @@
 namespace FOS\HttpCacheBundle;
 
 use FOS\HttpCacheBundle\HttpCache\HttpCacheInterface;
+use FOS\HttpCacheBundle\Invalidation\CacheProxyInterface;
+use FOS\HttpCacheBundle\Invalidation\Method\BanInterface;
+use Symfony\Component\HttpFoundation\Response;
 use Symfony\Component\Routing\RouterInterface;
 
 /**
@@ -11,6 +14,11 @@
  */
 class CacheManager
 {
+    /**
+     * @var string
+     */
+    protected $tagsHeader = 'X-Cache-Tags';
+
     /**
      * @var HttpCacheInterface
      */
@@ -31,15 +39,60 @@ class CacheManager
     /**
      * Constructor
      *
-     * @param HttpCacheInterface $cache  HTTP cache
-     * @param RouterInterface    $router Symfony router
+     * @param CacheProxyInterface $cache  HTTP cache
+     * @param RouterInterface     $router Symfony router
      */
-    public function __construct(HttpCacheInterface $cache, RouterInterface $router)
+    public function __construct(CacheProxyInterface $cache, RouterInterface $router)
     {
         $this->cache = $cache;
         $this->router = $router;
     }
 
+    /**
+     * Set the HTTP header name that will hold cache tags
+     *
+     * @param string $tagsHeader
+     */
+    public function setTagsHeader($tagsHeader)
+    {
+        $this->tagsHeader = $tagsHeader;
+    }
+
+    /**
+     * Get the HTTP header name that will hold cache tags
+     *
+     * @return string
+     */
+    public function getTagsHeader()
+    {
+        return $this->tagsHeader;
+    }
+
+    /**
+     * Assign cache tags to a response
+     *
+     * @param Response $response
+     * @param array    $tags
+     * @param bool     $replace  Whether to replace the current tags on the
+     *                           response
+     *
+     * @return $this
+     */
+    public function tagResponse(Response $response, array $tags, $replace = false)
+    {
+        if (!$replace) {
+            $tags = array_merge(
+                $response->headers->get($this->getTagsHeader(), array()),
+                $tags
+            );
+        }
+
+        $uniqueTags = array_unique($tags);
+        $response->headers->set($this->getTagsHeader(), implode(',', $uniqueTags));
+
+        return $this;
+    }
+
     /**
      * Invalidate a path (URL)
      *
@@ -83,22 +136,32 @@ public function invalidateRegex($regex)
     }
 
     /**
-     * Flush all paths queued for invalidation
+     * Invalidate cache tags
+     *
+     * @param array $tags Cache tags
      *
-     * @return array Paths that were flushed from the queue
+     * @return $this
+     * @throws \RuntimeException If HTTP cache does not support BAN requests
      */
-    public function flush()
+    public function invalidateTags(array $tags)
     {
-        $queue = $this->getInvalidationQueue();
-
-        if (0 === count($queue)) {
-            return $queue;
+        if (!$this->cache instanceof BanInterface) {
+            throw new \RuntimeException('HTTP cache does not support BAN requests');
         }
 
-        $this->cache->invalidateUrls($queue);
-        $this->invalidationQueue = array();
+        $headers = array($this->getTagsHeader() => '('.implode('|', $tags).')(,.+)?$');
+        $this->cache->ban($headers);
 
-        return $queue;
+        return $this;
+    }
+
+    /**
+     * Send all invalidation requests
+     *
+     */
+    public function flush()
+    {
+        $this->cache->flush();
     }
 
     /**

Configuration/Tag.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace FOS\HttpCacheBundle\Configuration;
+
+use FOS\HttpCacheBundle\Exception\InvalidTagException;
+use Sensio\Bundle\FrameworkExtraBundle\Configuration\ConfigurationAnnotation;
+
+/**
+ * @Annotation
+ */
+class Tag extends ConfigurationAnnotation
+{
+    protected $tags;
+    protected $expression;
+
+    public function setValue($data)
+    {
+        $this->setTags(is_array($data) ? $data: array($data));
+    }
+
+    /**
+     * @param mixed $expression
+     */
+    public function setExpression($expression)
+    {
+        $this->expression = $expression;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getExpression()
+    {
+        return $this->expression;
+    }
+
+    public function setTags(array $tags)
+    {
+        foreach ($tags as $tag) {
+            if (false !== \strpos($tag, ',')) {
+                throw new InvalidTagException($tag, ',');
+            }
+        }
+
+        $this->tags = $tags;
+    }
+
+    public function getTags()
+    {
+        return $this->tags;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getAliasName()
+    {
+        return 'tag';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function allowArray()
+    {
+        return true;
+    }
+} 

EventListener/TagListener.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace FOS\HttpCacheBundle\EventListener;
+
+use FOS\HttpCacheBundle\CacheManager;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
+use Symfony\Component\HttpKernel\KernelEvents;
+use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
+
+class TagListener implements EventSubscriberInterface
+{
+    /**
+     * @var CacheManager
+     */
+    protected $cacheManager;
+
+    /**
+     * Constructor
+     *
+     * @param CacheManager       $cacheManager
+     * @param ExpressionLanguage $expressionLanguage
+     */
+    public function __construct(
+        CacheManager $cacheManager,
+        ExpressionLanguage $expressionLanguage = null
+    ) {
+        $this->cacheManager = $cacheManager;
+        $this->expressionLanguage = $expressionLanguage ?: new ExpressionLanguage();
+    }
+
+    /**
+     * Process the _tags request attribute, which is set when using the Tag
+     * annotation
+     *
+     * - For a safe (GET or HEAD) request, the tags are set on the response.
+     * - For a non-safe request, the tags will be invalidated.
+     *
+     * @param FilterResponseEvent $event
+     */
+    public function onKernelResponse(FilterResponseEvent $event)
+    {
+        $request = $event->getRequest();
+
+        // Check for _tag request attribute that is set when using @Tag
+        // annotation
+        if (!$tagConfigurations = $request->attributes->get('_tag')) {
+            return;
+        }
+
+        $response = $event->getResponse();
+
+        // Only set cache tags or invalidate them if response is successful
+        if (!$response->isSuccessful()) {
+            return;
+        }
+
+        $tags = array();
+        foreach ($tagConfigurations as $tagConfiguration) {
+            if (null !== $tagConfiguration->getExpression()) {
+                $tags[] = $this->expressionLanguage->evaluate(
+                    $tagConfiguration->getExpression(),
+                    $request->attributes->all()
+                );
+            } else {
+                $tags = array_merge($tags, $tagConfiguration->getTags());
+            }
+        }
+
+        $uniqueTags = array_unique($tags);
+
+        if ($request->isMethodSafe()) {
+            // For safe requests (GET and HEAD), set cache tags on response
+            $this->cacheManager->tagResponse($response, $uniqueTags);
+        } else {
+            // For non-safe methods, invalidate the tags
+            $this->cacheManager->invalidateTags($uniqueTags);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public static function getSubscribedEvents()
+    {
+        return array(
+            KernelEvents::RESPONSE => 'onKernelResponse'
+        );
+    }
+} 

Exception/InvalidTagException.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace FOS\HttpCacheBundle\Exception;
+
+class InvalidTagException extends \InvalidArgumentException
+{
+    public function __construct($tag, $char)
+    {
+        parent:__construct(sprintf('Tag %s is invalid because it contains %s'));
+    }
+} 

Invalidation/CacheProxyInterface.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace FOS\HttpCacheBundle\Invalidation;
+
+interface CacheProxyInterface
+{
+
+} 

Invalidation/Method/BanInterface.php

@@ -12,6 +12,24 @@ interface BanInterface
     const REGEX_MATCH_ALL = '.*';
     const CONTENT_TYPE_ALL = self::REGEX_MATCH_ALL;
 
+    /**
+     * Ban cached objects matching HTTP headers
+     *
+     * Please make sure to configure your HTTP caching proxy to set the headers
+     * supplied here on the cached objects. So if you want to match objects by
+     * host name, configure your proxy to copy the host to a custom HTTP header
+     * such as X-Host.
+     *
+     * @param array $headers HTTP headers that path must match to be banned.
+     *                       Each header is either a:
+     *                       - regular string ('X-Host' => 'example.com')
+     *                       - or a POSIX regular expression
+     *                         ('X-Host' => '^(www\.)?(this|that)\.com$').
+     *
+     * @return $this
+     */
+    public function ban(array $headers);
+
     /**
      * Ban paths matching a regular expression
      *
@@ -30,5 +48,5 @@ interface BanInterface
      *
      * @return $this
      */
-    public function ban($path, $contentType = self::CONTENT_TYPE_ALL, array $hosts = null);
+    public function banPath($path, $contentType = self::CONTENT_TYPE_ALL, array $hosts = null);
 }