adding symfony cache proxy client

Author: dbu

CHANGELOG.md

@@ -4,17 +4,16 @@ Changelog
 1.3.0
 -----
 
-* Configured/annotated cache tags on subrequests (in twig: `render(controller())`)
+* Added configuration for Symfony HttpCache client and HttpCache now loads
+  purge and refresh handlers by default.
+* Configured/annotated cache tags on subrequests (in Twig: `render(controller())`)
   are no longer ignored. Additionally, it is now possible to add tags from code
   before the response object has been created, by using the TagHandler, and from
-  twig with the `fos_httpcache_tag` function.
-  
+  Twig with the `fos_httpcache_tag` function.
   If you defined custom services for the `InvalidateTagCommand`, you should
   now inject the TagHandler instead of the CacheManager.
-
-  **deprecated** `CacheManager::tagResponse` in favor of `TagHandler::addTags`
-
-* **2015-05-08** Added configuration option for custom proxy client (#208)
+* **deprecated** `CacheManager::tagResponse` in favor of `TagHandler::addTags`
+* Added configuration option for custom proxy client (#208)
 * Added support for a simple Etag header in the header configuration (#207)
 
 1.2.0

DependencyInjection/Configuration.php

@@ -305,7 +305,7 @@ private function addProxyClientSection(ArrayNodeDefinition $rootNode)
                 ->arrayNode('proxy_client')
                     ->children()
                         ->enumNode('default')
-                            ->values(array('varnish', 'nginx'))
+                            ->values(array('varnish', 'nginx', 'symfony'))
                             ->info('If you configure more than one proxy client, specify which client is the default.')
                         ->end()
                         ->arrayNode('varnish')
@@ -356,6 +356,28 @@ private function addProxyClientSection(ArrayNodeDefinition $rootNode)
                             ->end()
                         ->end()
 
+                        ->arrayNode('symfony')
+                            ->fixXmlConfig('server')
+                            ->children()
+                                ->arrayNode('servers')
+                                    ->beforeNormalization()->ifString()->then(function ($v) { return preg_split('/\s*,\s*/', $v); })->end()
+                                    ->useAttributeAsKey('name')
+                                    ->isRequired()
+                                    ->requiresAtLeastOneElement()
+                                    ->prototype('scalar')->end()
+                                    ->info('Addresses of the hosts Symfony HttpCache is running on. May be hostname or ip, and with :port if not the default port 80.')
+                                ->end()
+                                ->scalarNode('base_url')
+                                    ->defaultNull()
+                                    ->info('Default host name and optional path for path based invalidation.')
+                                ->end()
+                                ->scalarNode('guzzle_client')
+                                    ->defaultNull()
+                                    ->info('Guzzle service to use for customizing the requests.')
+                                ->end()
+                            ->end()
+                        ->end()
+
                     ->end()
                 ->end()
             ->end();

DependencyInjection/FOSHttpCacheExtension.php

@@ -235,6 +235,9 @@ private function loadProxyClient(ContainerBuilder $container, XmlFileLoader $loa
         if (isset($config['nginx'])) {
             $this->loadNginx($container, $loader, $config['nginx']);
         }
+        if (isset($config['symfony'])) {
+            $this->loadSymfony($container, $loader, $config['symfony']);
+        }
 
         $container->setAlias(
             $this->getAlias().'.default_proxy_client',
@@ -256,12 +259,8 @@ private function loadVarnish(ContainerBuilder $container, XmlFileLoader $loader,
         }
         $container->setParameter($this->getAlias().'.proxy_client.varnish.servers', $config['servers']);
         $container->setParameter($this->getAlias().'.proxy_client.varnish.base_url', $baseUrl);
-        if ($config['guzzle_client']) {
-            $container->getDefinition($this->getAlias().'.proxy_client.varnish')
-                ->addArgument(
-                    new Reference($config['guzzle_client'])
-                )
-            ;
+        if (!empty($config['guzzle_client'])) {
+            $container->setParameter($this->getAlias().'.proxy_client.varnish.guzzle_client', $config['guzzle_client']);
         }
     }
 
@@ -279,6 +278,28 @@ private function loadNginx(ContainerBuilder $container, XmlFileLoader $loader, a
         $container->setParameter($this->getAlias().'.proxy_client.nginx.servers', $config['servers']);
         $container->setParameter($this->getAlias().'.proxy_client.nginx.base_url', $baseUrl);
         $container->setParameter($this->getAlias().'.proxy_client.nginx.purge_location', $config['purge_location']);
+        if (!empty($config['guzzle_client'])) {
+            $container->setParameter($this->getAlias().'.proxy_client.nginx.guzzle_client', $config['guzzle_client']);
+        }
+    }
+
+    private function loadSymfony(ContainerBuilder $container, XmlFileLoader $loader, array $config)
+    {
+        $loader->load('symfony-client.xml');
+        foreach ($config['servers'] as $url) {
+            $this->validateUrl($url, 'Not a valid web server address: "%s"');
+        }
+        if (!empty($config['base_url'])) {
+            $baseUrl = $this->prefixSchema($config['base_url'], 'Not a valid base path: "%s"');
+            $this->validateUrl($baseUrl, 'Not a valid base path: "%s"');
+        } else {
+            $baseUrl = null;
+        }
+        $container->setParameter($this->getAlias().'.proxy_client.symfony.servers', $config['servers']);
+        $container->setParameter($this->getAlias().'.proxy_client.symfony.base_url', $baseUrl);
+        if (!empty($config['guzzle_client'])) {
+            $container->setParameter($this->getAlias().'.proxy_client.symfony.guzzle_client', $config['guzzle_client']);
+        }
     }
 
     private function loadTest(ContainerBuilder $container, XmlFileLoader $loader, array $config)

Resources/config/nginx.xml

@@ -14,6 +14,7 @@
             <argument>%fos_http_cache.proxy_client.nginx.servers%</argument>
             <argument>%fos_http_cache.proxy_client.nginx.base_url%</argument>
             <argument>%fos_http_cache.proxy_client.nginx.purge_location%</argument>
+            <argument type="service" id="fos_http_cache.proxy_client.nginx.guzzle_client" on-invalid="ignore"/>
         </service>
 
         <service id="fos_http_cache.test.client.nginx"

Resources/config/symfony.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" ?>
+
+<container xmlns="http://symfony.com/schema/dic/services"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">
+
+    <parameters>
+        <parameter key="fos_http_cache.proxy_client.symfony.class">FOS\HttpCache\ProxyClient\Symfony</parameter>
+    </parameters>
+
+    <services>
+        <service id="fos_http_cache.proxy_client.symfony"
+                 class="%fos_http_cache.proxy_client.symfony.class%">
+            <argument>%fos_http_cache.proxy_client.symfony.servers%</argument>
+            <argument>%fos_http_cache.proxy_client.symfony.base_url%</argument>
+            <argument type="service" id="fos_http_cache.proxy_client.symfony.guzzle_client" on-invalid="ignore"/>
+        </service>
+    </services>
+
+</container>

Resources/config/varnish.xml

@@ -13,6 +13,7 @@
                  class="%fos_http_cache.proxy_client.varnish.class%">
             <argument>%fos_http_cache.proxy_client.varnish.servers%</argument>
             <argument>%fos_http_cache.proxy_client.varnish.base_url%</argument>
+            <argument type="service" id="fos_http_cache.proxy_client.varnish.guzzle_client" on-invalid="ignore"/>
         </service>
 
         <service id="fos_http_cache.test.client.varnish"

Resources/doc/features/symfony-http-cache.rst

@@ -36,7 +36,7 @@ Instead of extending ``Symfony\Bundle\FrameworkBundle\HttpCache\HttpCache``, you
 .. tip::
 
     If your class already needs to extend a different class, simply copy the event
-    handling code from the EventDispatchingHttpCache into your ``AppCache`` class.
+    handling code from the ``EventDispatchingHttpCache`` into your ``AppCache`` class.
     The drawback is that you need to manually check whether you need to adjust your
     ``AppCache`` each time you update the FOSHttpCache library.
 
@@ -45,7 +45,8 @@ about. You can disable subscribers, or customize how they are instantiated.
 
 If you do not need all subscribers, or need to register some yourself to
 customize their behavior, overwrite ``getOptions`` and return the right bitmap
-in ``fos_default_subscribers``. Use the constants provided by the cache kernel::
+in ``fos_default_subscribers``. Use the constants provided by the
+``EventDispatchingHttpCache``::
 
     public function getOptions()
     {

Resources/doc/reference/configuration/cache-manager.rst

@@ -22,6 +22,8 @@ specify the ``custom_proxy_client`` field.
 Whether the cache manager service should be enabled. By default, it is enabled
 if a proxy client is configured. It can not be enabled without a proxy client.
 
+.. _custom_proxy_client:
+
 ``custom_proxy_client``
 -----------------------
 

Resources/doc/reference/configuration/proxy-client.rst

@@ -10,7 +10,13 @@ to work.
 
 The proxy client is also directly available as a service
 (``fos_http_cache.proxy_client.default`` and ``fos_http_cache.proxy_client.varnish``
-or ``fos_http_cache.proxy_client.nginx``) that you can use directly.
+, ``fos_http_cache.proxy_client.nginx`` or ``fos_http_cache.proxy_client.symfony``)
+that you can use directly.
+
+If you need to adjust the proxy client, you can also configure the ``CacheManager``
+with a :ref:`custom proxy client <custom_proxy_client>` that you defined as a
+service. In that case, you do not need to configure anything in the
+``proxy_client`` configuration section.
 
 varnish
 -------
@@ -33,6 +39,10 @@ Comma-separated list of IP addresses or host names of your
 caching proxy servers. The port those servers will be contacted
 defaults to 80; you can specify a different port with ``:<port>``.
 
+When using a multi-server setup, make sure to include **all** proxy servers in
+this list. Invalidation must happen on all systems or you will end up with
+inconsistent caches.
+
 ``base_url``
 """"""""""""
 
@@ -83,10 +93,24 @@ Separate location that purge requests will be sent to.
 See the :ref:`FOSHttpCache library docs <foshttpcache:nginx configuration>`
 on how to configure Nginx.
 
+symfony
+-------
+
+.. code-block:: yaml
+
+    # app/config/config.yml
+    fos_http_cache:
+        proxy_client:
+            symfony:
+                servers: 123.123.123.1:6060, 123.123.123.2
+                base_url: yourwebsite.com
+
+For ``servers`` and ``base_url``, see above.
+
 default
 -------
 
-**type**: ``enum`` **options**: ``varnish``, ``nginx``
+**type**: ``enum`` **options**: ``varnish``, ``nginx``, ``symfony``
 
 .. code-block:: yaml
 
@@ -95,27 +119,29 @@ default
         proxy_client:
             default: varnish
 
-The default proxy client that will be used by the cache manager.
-You can *use Nginx and Varnish in parallel*. If you need to cache and
-invalidate pages in both, you can configure both in this bundle.
-The cache manager however will only use the default client.
+If there is only one proxy client, it is automatically the default. Only
+configure this if you configured more than one proxy client.
+
+The default proxy client that will be used by the cache manager. You can
+*configure Nginx, Varnish and Symfony proxy clients in parallel*. There is
+however only one cache manager and it will only use the default client.
 
 Custom Guzzle Client
 --------------------
 
 By default, the proxy client instantiates a `Guzzle client`_ to talk with the
 caching proxy. If you need to customize the requests, for example to send a
 basic authentication header, you can configure a service and specify that in
-the ``guzzle_client`` option. A sample service definition for using basic
-authentication looks like this:
+the ``guzzle_client`` option of any of the cache proxy clients. A sample
+service definition for using basic authentication looks like this:
 
 .. code-block:: yaml
 
     # app/config/config.yml
     acme.varnish.guzzle.client:
         class: Guzzle\Service\Client
         calls:
-            - [setDefaultOption, [auth, [%varnish.username%, %varnish.password%, basic ]]]
+            - [setDefaultOption, [auth, [%caching_proxy.username%, %caching_proxy.password%, basic ]]]
 
 Caching Proxy Configuration
 ---------------------------

Tests/Unit/DependencyInjection/FOSHttpCacheExtensionTest.php

@@ -38,6 +38,8 @@ public function testConfigLoadVarnish()
         $this->assertFalse($container->hasDefinition('fos_http_cache.proxy_client.nginx'));
         $this->assertTrue($container->hasAlias('fos_http_cache.default_proxy_client'));
         $this->assertTrue($container->hasDefinition('fos_http_cache.event_listener.invalidation'));
+
+        $this->assertFalse($container->hasParameter('fos_http_cache.proxy_client.varnish.guzzle_client'));
     }
 
     public function testConfigLoadVarnishCustomGuzzle()
@@ -50,7 +52,11 @@ public function testConfigLoadVarnishCustomGuzzle()
 
         $this->assertTrue($container->hasDefinition('fos_http_cache.proxy_client.varnish'));
         $def = $container->getDefinition('fos_http_cache.proxy_client.varnish');
-        $this->assertEquals('my_guzzle', $def->getArgument(2));
+        $this->assertInstanceOf('Symfony\Component\DependencyInjection\Reference', $def->getArgument(2));
+        $this->assertEquals('fos_http_cache.proxy_client.varnish.guzzle_client', $def->getArgument(2)->__toString());
+
+        $this->assertTrue($container->hasParameter('fos_http_cache.proxy_client.varnish.guzzle_client'));
+        $this->assertEquals('my_guzzle', $container->getParameter('fos_http_cache.proxy_client.varnish.guzzle_client'));
     }
 
     /**
@@ -150,7 +156,7 @@ public function testConfigLoadInvalidatorRules()
 
         $this->assertMatcherCreated($container, array('_route' => 'my_route'));
         $this->assertListenerHasRule($container, 'fos_http_cache.event_listener.invalidation');
-        
+
         // Test for runtime errors
         $container->compile();
     }
@@ -289,13 +295,13 @@ protected function createContainer()
         $container = new ContainerBuilder(
             new ParameterBag(array('kernel.debug' => false,))
         );
-        
+
         // The cache_manager service depends on the router service
         $container->setDefinition(
             'router',
             new Definition('\Symfony\Component\Routing\Router')
         );
-        
+
         return $container;
     }