allow to configure tags on routes as constants or with expressions

dbu · ddeboer · commit 2854cfcb1c81 · 2014-06-07T00:42:23.000+02:00
cleanup configuration

moving validation into configuration class
diff --git a/DependencyInjection/Configuration.php b/DependencyInjection/Configuration.php
@@ -9,9 +9,13 @@
 use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
 
 /**
- * This is the class that validates and merges configuration from your app/config files
+ * This class contains the configuration information for the bundle
  *
- * To learn more see {@link http://symfony.com/doc/current/cookbook/bundles/extension.html#cookbook-bundles-extension-config-class}
+ * This information is solely responsible for how the different configuration
+ * sections are normalized, and merged.
+ *
+ * @author David de Boer <david@driebit.nl>
+ * @author David Buchmann <mail@davidbu.ch>
  */
 class Configuration implements ConfigurationInterface
 {
@@ -24,6 +28,18 @@ public function getConfigTreeBuilder()
         $rootNode = $treeBuilder->root('fos_http_cache');
 
         $rootNode
+            ->validate()
+                ->ifTrue(function ($v) {return $v['cache_manager']['enabled'] && !isset($v['proxy_client']);})
+                ->then(function ($v) {
+                    if ('auto' === $v['cache_manager']['enabled']) {
+                        $v['cache_manager']['enabled'] = false;
+
+                        return $v;
+                    }
+                    throw new InvalidConfigurationException('You need to configure a proxy_client to use the cache_manager.');
+                })
+            ->end()
+
             ->children()
                 ->booleanNode('debug')
                     ->defaultValue('%kernel.debug%')
@@ -39,9 +55,8 @@ public function getConfigTreeBuilder()
         $this->addUserContextListenerSection($rootNode);
         $this->addRulesSection($rootNode);
         $this->addProxyClientSection($rootNode);
-        $this->addTagListenerSection($rootNode);
+        $this->addCacheManager($rootNode);
         $this->addFlashMessageListenerSection($rootNode);
-        $this->addInvalidatorsSection($rootNode);
 
         return $treeBuilder;
     }
@@ -106,13 +121,18 @@ private function addRulesSection(ArrayNodeDefinition $rootNode)
 
         $this->addMatchSection($rules);
         $this->addHeaderSection($rules);
+        $this->addTagSection($rules);
+    }
+
+    private function addTagSection(NodeBuilder $rules)
+    {
         $rules
             ->arrayNode('tags')
                 ->prototype('scalar')
-                ->validate()
-                    ->ifTrue(function ($v) {return !count($v);})
-                    ->thenUnset()
-                ->end()
+                ->info('Tags to add to the response on safe requests, to invalidate on unsafe requests')
+            ->end()->end()
+            ->arrayNode('tag_expressions')
+                ->prototype('scalar')
                 ->info('Tags to add to the response on safe requests, to invalidate on unsafe requests')
             ->end()
         ;
@@ -231,9 +251,37 @@ private function addProxyClientSection(ArrayNodeDefinition $rootNode)
             ->end();
     }
 
-    private function addTagListenerSection(ArrayNodeDefinition $rootNode)
+    private function addCacheManager(ArrayNodeDefinition $rootNode)
     {
-        $rootNode
+        $invalidationNode = $rootNode
+            ->children()
+                ->arrayNode('cache_manager')
+                    ->addDefaultsIfNotSet()
+                    ->beforeNormalization()
+                        ->ifArray()
+                        ->then(function ($v) {
+                            $v['enabled'] = isset($v['enabled']) ? $v['enabled'] : true;
+
+                            return $v;
+                        })
+                    ->end()
+                    ->info('Configure the cache manager. Needs a proxy_client to be configured.')
+                    ->children()
+                        ->enumNode('enabled')
+                            ->values(array(true, false, 'auto'))
+                            ->defaultValue('auto')
+                            ->info('Allows to disable the invalidation manager. Enabled by default if you configure a proxy client.')
+                        ->end()
+                    ->end()
+        ;
+
+        $this->addTagListenerSection($invalidationNode);
+        $this->addInvalidatorsSection($invalidationNode);
+    }
+
+    private function addTagListenerSection(ArrayNodeDefinition $invalidationNode)
+    {
+        $invalidationNode
             ->children()
                 ->arrayNode('tag_listener')
                     ->addDefaultsIfNotSet()
@@ -282,21 +330,24 @@ private function addFlashMessageListenerSection(ArrayNodeDefinition $rootNode)
             ->end();
     }
 
-    private function addInvalidatorsSection(ArrayNodeDefinition $rootNode)
+    private function addInvalidatorsSection(ArrayNodeDefinition $invalidationNode)
     {
-        $rootNode
+        $invalidationNode
             ->children()
-                ->arrayNode('invalidators')
+                ->arrayNode('route_invalidators')
                     ->useAttributeAsKey('name')
+                    ->info('Groups of origin routes that invalidate target routes when a request is made')
                     ->prototype('array')
                         ->children()
                             ->arrayNode('origin_routes')
                                 ->isRequired()
                                 ->requiresAtLeastOneElement()
                                 ->prototype('scalar')->end()
+                                ->info('Invalidate the target routes in this group when one of these routes is called')
                             ->end()
                             ->arrayNode('invalidate_routes')
                                 ->useAttributeAsKey('name')
+                                ->info('Target routes to invalidate when an origin route is called')
                                 ->prototype('array')
                                     ->children()
                                         ->scalarNode('parameter_mapper')->end()
diff --git a/DependencyInjection/FOSHttpCacheExtension.php b/DependencyInjection/FOSHttpCacheExtension.php
@@ -34,31 +34,11 @@ public function load(array $configs, ContainerBuilder $container)
         }
 
         if (isset($config['proxy_client'])) {
-            $container->setParameter($this->getAlias().'.invalidators', $config['invalidators']);
             $this->loadProxyClient($container, $loader, $config['proxy_client']);
+        }
 
-            $loader->load('cache_manager.xml');
-
-            if ($config['tag_listener']['enabled']) {
-                // true or auto
-                if (class_exists('\Symfony\Component\ExpressionLanguage\ExpressionLanguage')) {
-                    $loader->load('tag_listener.xml');
-                } elseif (true === $config['tag_listener']['enabled']) {
-                    // silently skip if set to auto
-                    throw new InvalidConfigurationException('The TagListener requires symfony/expression-language');
-                }
-            }
-
-            if (version_compare(Kernel::VERSION, '2.4.0', '>=')) {
-                $container
-                    ->getDefinition('fos_http_cache.command.invalidate_path')
-                    ->addTag('console.command')
-                ;
-            }
-        } elseif (!empty($config['invalidators'])) {
-            throw new InvalidConfigurationException('You need to configure a proxy client to use the invalidators.');
-        } elseif (true === $config['tag_listener']['enabled']) {
-            throw new InvalidConfigurationException('You need to configure a proxy client to use the tag listener.');
+        if ($config['cache_manager']['enabled'] && isset($config['proxy_client'])) {
+            $this->loadCacheManager($container, $loader, $config['cache_manager']);
         }
 
         if (!empty($config['rules'])) {
@@ -82,9 +62,11 @@ public function load(array $configs, ContainerBuilder $container)
 
     /**
      * @param ContainerBuilder $container
-     * @param $config
+     * @param array            $config
+     *
+     * @throws InvalidConfigurationException
      */
-    protected function loadRules(ContainerBuilder $container, $config)
+    protected function loadRules(ContainerBuilder $container, array $config)
     {
         foreach ($config['rules'] as $rule) {
             $match = $rule['match'];
@@ -112,13 +94,18 @@ protected function loadRules(ContainerBuilder $container, $config)
                 $extraCriteria
             );
 
-            if (isset($rule['tags']) && count($rule['tags'])) {
+            $tags = array(
+                'tags' => $rule['tags'],
+                'expressions' => $rule['tag_expressions'],
+            );
+            if (count($tags['tags']) || count($tags['expressions'])) {
                 if (!$container->hasDefinition($this->getAlias() . '.event_listener.tag')) {
                     throw new InvalidConfigurationException('To configure tags, you need to have the tag event listener enabled, requiring symfony/expression-language');
                 }
+
                 $container
                     ->getDefinition($this->getAlias() . '.event_listener.tag')
-                    ->addMethodCall('addRule', array($ruleMatcher, $rule['tags']))
+                    ->addMethodCall('addRule', array($ruleMatcher, $tags))
                 ;
             }
 
@@ -221,6 +208,37 @@ protected function loadVarnish(ContainerBuilder $container, XmlFileLoader $loade
         $container->setParameter($this->getAlias() . '.proxy_client.varnish.base_url', $config['base_url']);
     }
 
+    protected function loadCacheManager(ContainerBuilder $container, XmlFileLoader $loader, array $config)
+    {
+        $container->setParameter($this->getAlias().'.cache_manager.route_invalidators', $config['route_invalidators']);
+
+        $container->setParameter(
+            $this->getAlias() . '.cache_manager.additional_status',
+            isset($config['additional_status']) ? $config['additional_status'] : array()
+        );
+        $container->setParameter(
+            $this->getAlias() . '.cache_manager.match_response',
+            isset($config['match_response']) ? $config['match_response'] : null
+        );
+        $loader->load('cache_manager.xml');
+        if (version_compare(Kernel::VERSION, '2.4.0', '>=')) {
+            $container
+                ->getDefinition('fos_http_cache.command.invalidate_path')
+                ->addTag('console.command')
+            ;
+        }
+
+        if ($config['tag_listener']['enabled']) {
+            // true or auto
+            if (class_exists('\Symfony\Component\ExpressionLanguage\ExpressionLanguage')) {
+                $loader->load('tag_listener.xml');
+            } elseif (true === $config['tag_listener']['enabled']) {
+                // silently skip if set to auto
+                throw new InvalidConfigurationException('The TagListener requires symfony/expression-language');
+            }
+        }
+    }
+
     private function validateUrl($url, $msg)
     {
         if (false === strpos($url, '://')) {
diff --git a/EventListener/TagSubscriber.php b/EventListener/TagSubscriber.php
@@ -58,28 +58,30 @@ public function onKernelResponse(FilterResponseEvent $event)
         if ($response->isSuccessful()) {
             $tags = $this->getAnnotationTags($request);
         }
-        $configuredTags = $this->matchConfiguration($request, $response) ?: array();
-        /*
-        foreach ($configuredTags as $id => $tag) {
-            $configuredTags[$id] = $this->expressionLanguage->evaluate($tag, array(
-                'request' => $request,
-                'response' => $response,
-            ));
-        }
-        */
 
-        $uniqueTags = array_values(array_unique(array_merge($tags, $configuredTags)));
+        $configuredTags = $this->matchConfiguration($request, $response);
+        if ($configuredTags) {
+            foreach ($configuredTags['tags'] as $tag) {
+                $tags[] = $tag;
+            }
+            foreach ($configuredTags['expressions'] as $expression) {
+                $tags[] = $this->expressionLanguage->evaluate($expression, array(
+                    'request' => $request,
+                    'response' => $response,
+                ));
+            }
+        }
 
-        if (!count($uniqueTags)) {
+        if (!count($tags)) {
             return;
         }
 
         if ($request->isMethodSafe()) {
             // For safe requests (GET and HEAD), set cache tags on response
-            $this->cacheManager->tagResponse($response, $uniqueTags);
+            $this->cacheManager->tagResponse($response, $tags);
         } else {
             // For non-safe methods, invalidate the tags
-            $this->cacheManager->invalidateTags($uniqueTags);
+            $this->cacheManager->invalidateTags($tags);
         }
     }
 
diff --git a/Resources/config/cache_manager.xml b/Resources/config/cache_manager.xml
@@ -16,7 +16,7 @@
                  class="FOS\HttpCacheBundle\Invalidator\InvalidatorCollection"
                  factory-class="FOS\HttpCacheBundle\Invalidator\InvalidatorCollectionFactory"
                  factory-method="getInvalidatorCollection">
-            <argument>%fos_http_cache.invalidators%</argument>
+            <argument>%fos_http_cache.cache_manager.route_invalidators%</argument>
         </service>
 
         <service id="fos_http_cache.cache_manager"
diff --git a/Resources/doc/invalidation-configuration.md b/Resources/doc/invalidation-configuration.md
@@ -22,17 +22,18 @@ You can configure invalidators as follows:
 # app/config/config.yml
 
 fos_http_cache:
-  ...
-  invalidators:
-    villains:
-      origin_routes: [ villain_edit, villain_delete, villain_publish ]
-      invalidate_routes:
-        villains_index: ~    # e.g., /villains
-        villain_details: ~   # e.g., /villain/{id}
-    another_invalidator:
-      origin_routes: [ ... ]
-      invalidate_routes:
-        ...
+    ...
+    cache_manager:
+        route_invalidation:
+            villains:
+                origin_routes: [ villain_edit, villain_delete, villain_publish ]
+                invalidate_routes:
+                    villains_index: ~    # e.g., /villains
+                    villain_details: ~   # e.g., /villain/{id}
+            another_invalidator:
+                origin_routes: [ ... ]
+                invalidate_routes:
+            ...
 ```
 
 Now when a request to either one of the three origin routes returns a 200 response, both `villains_index` and
diff --git a/Resources/doc/tagging.md b/Resources/doc/tagging.md
@@ -32,16 +32,17 @@ You need to configure your caching proxy to support cache tagging. See the FOSHt
 documentation’s [Varnish Configuration chapter](https://github.com/FriendsOfSymfony/FOSHttpCache/blob/master/doc/varnish-configuration.md#tagging)
 for more details.
 
-The tag system is controlled by `fos_http_cache.tag_listener.enabled`. By
-default, this setting is on `auto`, meaning tagging is activated if you have a
+The tag system is controlled by `fos_http_cache.cache_manager.tag_listener.enabled`.
+By default, this setting is on `auto`, meaning tagging is activated if you have a
 proxy client configured and you have `symfony/expression-language` available in
 your project. If you use tagging, it is recommended to set enabled to true to
 be notified if your setup is broken:
 
 ```yaml
 fos_http_cache:
-    tag_listener:
-        enabled: true
+    cache_manager:
+        tag_listener:
+            enabled: true
 ```
 
 Tagging with the Cache Manager
diff --git a/Tests/Unit/DependencyInjection/FOSHttpCacheExtensionTest.php b/Tests/Unit/DependencyInjection/FOSHttpCacheExtensionTest.php
@@ -40,19 +40,26 @@ public function testEmptyConfig()
     public function testConfigLoadInvalidators()
     {
         $config = $this->getBaseConfig() + array(
-            'invalidators' => array(
-                array(
-                    'name' => 'invalidator1',
-                    'origin_routes' => array(
-                        'my_route'
-                    ),
-                    'invalidate_routes' => array(
-                        array(
-                            'name' => 'invalidate_route1',
+            'cache_manager' => array(
+                'route_invalidators' => array(
+                    array(
+                        'name' => 'invalidator1',
+                        'origin_routes' => array(
+                            'my_route'
+                        ),
+                        'invalidate_routes' => array(
+                            array(
+                                'name' => 'invalidate_route1',
+                            )
                         )
                     )
                 )
-            )
+            ),
+            'proxy_client' => array(
+                'varnish' => array(
+                    'servers' => array('1.2.3.4'),
+                ),
+            ),
         );
 
         $container = new ContainerBuilder();
diff --git a/Tests/Unit/EventListener/TagSubscriberTest.php b/Tests/Unit/EventListener/TagSubscriberTest.php
