[FrameworkBundle] Allow clearing private cache pools

chalasr · chalasr · commit 6737ebe9d664 · 2016-12-10T11:52:34.000+01:00
diff --git a/Command/CachePoolClearCommand.php b/Command/CachePoolClearCommand.php
@@ -55,16 +55,21 @@ protected function execute(InputInterface $input, OutputInterface $output)
         $clearers = array();
         $container = $this->getContainer();
         $cacheDir = $container->getParameter('kernel.cache_dir');
+        $globalClearer = $container->get('cache.global_clearer');
 
         foreach ($input->getArgument('pools') as $id) {
-            $pool = $container->get($id);
-
-            if ($pool instanceof CacheItemPoolInterface) {
-                $pools[$id] = $pool;
-            } elseif ($pool instanceof Psr6CacheClearer) {
-                $clearers[$id] = $pool;
+            if ($globalClearer->hasPool($id)) {
+                $pools[$id] = $id;
             } else {
-                throw new \InvalidArgumentException(sprintf('"%s" is not a cache pool nor a cache clearer.', $id));
+                $pool = $container->get($id);
+
+                if ($pool instanceof CacheItemPoolInterface) {
+                    $pools[$id] = $pool;
+                } elseif ($pool instanceof Psr6CacheClearer) {
+                    $clearers[$id] = $pool;
+                } else {
+                    throw new \InvalidArgumentException(sprintf('"%s" is not a cache pool nor a cache clearer.', $id));
+                }
             }
         }
 
@@ -75,7 +80,12 @@ protected function execute(InputInterface $input, OutputInterface $output)
 
         foreach ($pools as $id => $pool) {
             $io->comment(sprintf('Clearing cache pool: <info>%s</info>', $id));
-            $pool->clear();
+
+            if ($pool instanceof CacheItemPoolInterface) {
+                $pool->clear();
+            } else {
+                $globalClearer->clearPool($id);
+            }
         }
 
         $io->success('Cache was successfully cleared.');
diff --git a/DependencyInjection/Compiler/CachePoolClearerPass.php b/DependencyInjection/Compiler/CachePoolClearerPass.php
@@ -27,19 +27,31 @@ final class CachePoolClearerPass implements CompilerPassInterface
     public function process(ContainerBuilder $container)
     {
         $container->getParameterBag()->remove('cache.prefix.seed');
+        $poolsByClearer = array();
+        $pools = array();
 
         foreach ($container->findTaggedServiceIds('cache.pool') as $id => $attributes) {
+            $pools[$id] = new Reference($id);
             foreach (array_reverse($attributes) as $attr) {
                 if (isset($attr['clearer'])) {
-                    $clearer = $container->getDefinition($attr['clearer']);
-                    $clearer->addMethodCall('addPool', array(new Reference($id)));
+                    $poolsByClearer[$attr['clearer']][$id] = $pools[$id];
                 }
-                if (array_key_exists('clearer', $attr)) {
+                if (!empty($attr['unlazy'])) {
+                    $container->getDefinition($id)->setLazy(false);
+                }
+                if (array_key_exists('clearer', $attr) || array_key_exists('unlazy', $attr)) {
                     break;
                 }
             }
         }
 
+        $container->getDefinition('cache.global_clearer')->addArgument($pools);
+
+        foreach ($poolsByClearer as $clearer => $pools) {
+            $clearer = $container->getDefinition($clearer);
+            $clearer->addArgument($pools);
+        }
+
         if (!$container->has('cache.annotations')) {
             return;
         }
diff --git a/DependencyInjection/Compiler/CachePoolPass.php b/DependencyInjection/Compiler/CachePoolPass.php
@@ -47,8 +47,10 @@ public function process(ContainerBuilder $container)
             if ($pool->isAbstract()) {
                 continue;
             }
+            $isLazy = $pool->isLazy();
             while ($adapter instanceof DefinitionDecorator) {
                 $adapter = $container->findDefinition($adapter->getParent());
+                $isLazy = $isLazy || $adapter->isLazy();
                 if ($t = $adapter->getTag('cache.pool')) {
                     $tags[0] += $t[0];
                 }
@@ -80,8 +82,16 @@ public function process(ContainerBuilder $container)
                 throw new InvalidArgumentException(sprintf('Invalid "cache.pool" tag for service "%s": accepted attributes are "clearer", "provider", "namespace" and "default_lifetime", found "%s".', $id, implode('", "', array_keys($tags[0]))));
             }
 
+            $attr = array();
             if (null !== $clearer) {
-                $pool->addTag('cache.pool', array('clearer' => $clearer));
+                $attr['clearer'] = $clearer;
+            }
+            if (!$isLazy) {
+                $pool->setLazy(true);
+                $attr['unlazy'] = true;
+            }
+            if ($attr) {
+                $pool->addTag('cache.pool', $attr);
             }
         }
     }
diff --git a/Resources/config/cache.xml b/Resources/config/cache.xml
@@ -97,6 +97,7 @@
             <tag name="kernel.cache_clearer" />
         </service>
 
+        <service id="cache.global_clearer" parent="cache.default_clearer" />
         <service id="cache.app_clearer" alias="cache.default_clearer" />
 
     </services>
diff --git a/Tests/DependencyInjection/Compiler/CachePoolClearerPassTest.php b/Tests/DependencyInjection/Compiler/CachePoolClearerPassTest.php
@@ -18,6 +18,7 @@
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Definition;
 use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\HttpKernel\CacheClearer\Psr6CacheClearer;
 
 class CachePoolClearerPassTest extends \PHPUnit_Framework_TestCase
 {
@@ -29,6 +30,9 @@ public function testPoolRefsAreWeak()
         $container->setParameter('kernel.environment', 'prod');
         $container->setParameter('kernel.root_dir', 'foo');
 
+        $globalClearer = new Definition(Psr6CacheClearer::class);
+        $container->setDefinition('cache.global_clearer', $globalClearer);
+
         $publicPool = new Definition();
         $publicPool->addArgument('namespace');
         $publicPool->addTag('cache.pool', array('clearer' => 'clearer_alias'));
@@ -50,6 +54,7 @@ public function testPoolRefsAreWeak()
             $pass->process($container);
         }
 
-        $this->assertEquals(array(array('addPool', array(new Reference('public.pool')))), $clearer->getMethodCalls());
+        $this->assertEquals(array(array('public.pool' => new Reference('public.pool'))), $clearer->getArguments());
+        $this->assertEquals(array(array('public.pool' => new Reference('public.pool'))), $globalClearer->getArguments());
     }
 }
diff --git a/Tests/Functional/CachePoolClearCommandTest.php b/Tests/Functional/CachePoolClearCommandTest.php
@@ -0,0 +1,86 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\FrameworkBundle\Tests\Functional;
+
+use Symfony\Bundle\FrameworkBundle\Command\CachePoolClearCommand;
+use Symfony\Component\Console\Tester\CommandTester;
+
+/**
+ * @group functional
+ */
+class CachePoolClearCommandTest extends WebTestCase
+{
+    private $application;
+
+    protected function setUp()
+    {
+        static::bootKernel(array('test_case' => 'CachePoolClear', 'root_config' => 'config.yml'));
+    }
+
+    public function testClearPrivatePool()
+    {
+        $tester = $this->createCommandTester();
+        $tester->execute(array('pools' => array('cache.private_pool')), array('decorated' => false));
+
+        $this->assertSame(0, $tester->getStatusCode(), 'cache:pool:clear exits with 0 in case of success');
+        $this->assertContains('Clearing cache pool: cache.private_pool', $tester->getDisplay());
+        $this->assertContains('[OK] Cache was successfully cleared.', $tester->getDisplay());
+    }
+
+    public function testClearPublicPool()
+    {
+        $tester = $this->createCommandTester();
+        $tester->execute(array('pools' => array('cache.public_pool')), array('decorated' => false));
+
+        $this->assertSame(0, $tester->getStatusCode(), 'cache:pool:clear exits with 0 in case of success');
+        $this->assertContains('Clearing cache pool: cache.public_pool', $tester->getDisplay());
+        $this->assertContains('[OK] Cache was successfully cleared.', $tester->getDisplay());
+    }
+
+    public function testClearPoolWithCustomClearer()
+    {
+        $tester = $this->createCommandTester();
+        $tester->execute(array('pools' => array('cache.pool_with_clearer')), array('decorated' => false));
+
+        $this->assertSame(0, $tester->getStatusCode(), 'cache:pool:clear exits with 0 in case of success');
+        $this->assertContains('Clearing cache pool: cache.pool_with_clearer', $tester->getDisplay());
+        $this->assertContains('[OK] Cache was successfully cleared.', $tester->getDisplay());
+    }
+
+    public function testCallClearer()
+    {
+        $tester = $this->createCommandTester();
+        $tester->execute(array('pools' => array('cache.default_clearer')), array('decorated' => false));
+
+        $this->assertSame(0, $tester->getStatusCode(), 'cache:pool:clear exits with 0 in case of success');
+        $this->assertContains('Calling cache clearer: cache.default_clearer', $tester->getDisplay());
+        $this->assertContains('[OK] Cache was successfully cleared.', $tester->getDisplay());
+    }
+
+    /**
+     * @expectedException        \Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException
+     * @expectedExceptionMessage You have requested a non-existent service "unknown_pool"
+     */
+    public function testClearUnexistingPool()
+    {
+        $this->createCommandTester()
+            ->execute(array('pools' => array('unknown_pool')), array('decorated' => false));
+    }
+
+    private function createCommandTester()
+    {
+        $command = new CachePoolClearCommand();
+        $command->setContainer(static::$kernel->getContainer());
+
+        return new CommandTester($command);
+    }
+}
diff --git a/Tests/Functional/app/CachePoolClear/bundles.php b/Tests/Functional/app/CachePoolClear/bundles.php
@@ -0,0 +1,18 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Symfony\Bundle\FrameworkBundle\Tests\Functional\Bundle\TestBundle\TestBundle;
+use Symfony\Bundle\FrameworkBundle\FrameworkBundle;
+
+return array(
+    new FrameworkBundle(),
+    new TestBundle(),
+);
diff --git a/Tests/Functional/app/CachePoolClear/config.yml b/Tests/Functional/app/CachePoolClear/config.yml
@@ -0,0 +1,21 @@
+imports:
+    - { resource: ../config/default.yml }
+
+services:
+    dummy:
+        class: Symfony\Bundle\FrameworkBundle\Tests\Fixtures\DeclaredClass
+        arguments: ['@cache.private_pool']
+    custom_clearer:
+        parent: cache.default_clearer
+        tags:
+            - name: kernel.cache_clearer
+
+framework:
+    cache:
+        pools:
+            cache.private_pool: ~
+            cache.public_pool:
+                public: true
+            cache.pool_with_clearer:
+                public: true
+                clearer: custom_clearer
diff --git a/composer.json b/composer.json
@@ -23,7 +23,7 @@
         "symfony/config": "~2.8|~3.0",
         "symfony/event-dispatcher": "~2.8|~3.0",
         "symfony/http-foundation": "~3.1",
-        "symfony/http-kernel": "~3.2",
+        "symfony/http-kernel": "~3.3",
         "symfony/polyfill-mbstring": "~1.0",
         "symfony/filesystem": "~2.8|~3.0",
         "symfony/finder": "~2.8|~3.0",

Original file line number	Diff line number	Diff line change
`@@ -27,19 +27,31 @@ final class CachePoolClearerPass implements CompilerPassInterface`
`27`	`27`	`public function process(ContainerBuilder $container)`
`28`	`28`	`{`
`29`	`29`	`$container->getParameterBag()->remove('cache.prefix.seed');`
	`30`	`+ $poolsByClearer = array();`
	`31`	`+ $pools = array();`
`30`	`32`
`31`	`33`	`foreach ($container->findTaggedServiceIds('cache.pool') as $id => $attributes) {`
	`34`	`+ $pools[$id] = new Reference($id);`
`32`	`35`	`foreach (array_reverse($attributes) as $attr) {`
`33`	`36`	`if (isset($attr['clearer'])) {`
`34`		`- $clearer = $container->getDefinition($attr['clearer']);`
`35`		`- $clearer->addMethodCall('addPool', array(new Reference($id)));`
	`37`	`+ $poolsByClearer[$attr['clearer']][$id] = $pools[$id];`
`36`	`38`	`}`
`37`		`- if (array_key_exists('clearer', $attr)) {`
	`39`	`+ if (!empty($attr['unlazy'])) {`
	`40`	`+ $container->getDefinition($id)->setLazy(false);`
	`41`	`+ }`
	`42`	`+ if (array_key_exists('clearer', $attr) \|\| array_key_exists('unlazy', $attr)) {`
`38`	`43`	`break;`
`39`	`44`	`}`
`40`	`45`	`}`
`41`	`46`	`}`
`42`	`47`
	`48`	`+ $container->getDefinition('cache.global_clearer')->addArgument($pools);`
	`49`	`+`
	`50`	`+ foreach ($poolsByClearer as $clearer => $pools) {`
	`51`	`+ $clearer = $container->getDefinition($clearer);`
	`52`	`+ $clearer->addArgument($pools);`
	`53`	`+ }`
	`54`	`+`
`43`	`55`	`if (!$container->has('cache.annotations')) {`
`44`	`56`	`return;`
`45`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,8 +47,10 @@ public function process(ContainerBuilder $container)`
`47`	`47`	`if ($pool->isAbstract()) {`
`48`	`48`	`continue;`
`49`	`49`	`}`
	`50`	`+ $isLazy = $pool->isLazy();`
`50`	`51`	`while ($adapter instanceof DefinitionDecorator) {`
`51`	`52`	`$adapter = $container->findDefinition($adapter->getParent());`
	`53`	`+ $isLazy = $isLazy \|\| $adapter->isLazy();`
`52`	`54`	`if ($t = $adapter->getTag('cache.pool')) {`
`53`	`55`	`$tags[0] += $t[0];`
`54`	`56`	`}`
`@@ -80,8 +82,16 @@ public function process(ContainerBuilder $container)`
`80`	`82`	`throw new InvalidArgumentException(sprintf('Invalid "cache.pool" tag for service "%s": accepted attributes are "clearer", "provider", "namespace" and "default_lifetime", found "%s".', $id, implode('", "', array_keys($tags[0]))));`
`81`	`83`	`}`
`82`	`84`
	`85`	`+ $attr = array();`
`83`	`86`	`if (null !== $clearer) {`
`84`		`- $pool->addTag('cache.pool', array('clearer' => $clearer));`
	`87`	`+ $attr['clearer'] = $clearer;`
	`88`	`+ }`
	`89`	`+ if (!$isLazy) {`
	`90`	`+ $pool->setLazy(true);`
	`91`	`+ $attr['unlazy'] = true;`
	`92`	`+ }`
	`93`	`+ if ($attr) {`
	`94`	`+ $pool->addTag('cache.pool', $attr);`
`85`	`95`	`}`
`86`	`96`	`}`
`87`	`97`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@`
`18`	`18`	`use Symfony\Component\DependencyInjection\ContainerBuilder;`
`19`	`19`	`use Symfony\Component\DependencyInjection\Definition;`
`20`	`20`	`use Symfony\Component\DependencyInjection\Reference;`
	`21`	`+use Symfony\Component\HttpKernel\CacheClearer\Psr6CacheClearer;`
`21`	`22`
`22`	`23`	`class CachePoolClearerPassTest extends \PHPUnit_Framework_TestCase`
`23`	`24`	`{`
`@@ -29,6 +30,9 @@ public function testPoolRefsAreWeak()`
`29`	`30`	`$container->setParameter('kernel.environment', 'prod');`
`30`	`31`	`$container->setParameter('kernel.root_dir', 'foo');`
`31`	`32`
	`33`	`+ $globalClearer = new Definition(Psr6CacheClearer::class);`
	`34`	`+ $container->setDefinition('cache.global_clearer', $globalClearer);`
	`35`	`+`
`32`	`36`	`$publicPool = new Definition();`
`33`	`37`	`$publicPool->addArgument('namespace');`
`34`	`38`	`$publicPool->addTag('cache.pool', array('clearer' => 'clearer_alias'));`
`@@ -50,6 +54,7 @@ public function testPoolRefsAreWeak()`
`50`	`54`	`$pass->process($container);`
`51`	`55`	`}`
`52`	`56`
`53`		`- $this->assertEquals(array(array('addPool', array(new Reference('public.pool')))), $clearer->getMethodCalls());`
	`57`	`+ $this->assertEquals(array(array('public.pool' => new Reference('public.pool'))), $clearer->getArguments());`
	`58`	`+ $this->assertEquals(array(array('public.pool' => new Reference('public.pool'))), $globalClearer->getArguments());`
`54`	`59`	`}`
`55`	`60`	`}`