Merge pull request #23 from Nyholm/doctrine

Make sure we tag the doctrine cache

Author: Nyholm

src/Cache/FixedTaggingCachePool.php

@@ -0,0 +1,117 @@
+<?php
+
+/*
+ * This file is part of php-cache\cache-bundle package.
+ *
+ * (c) 2015-2015 Aaron Scherer <[email protected]>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace Cache\CacheBundle\Cache;
+
+use Cache\Taggable\TaggablePoolInterface;
+use Psr\Cache\CacheItemInterface;
+use Psr\Cache\CacheItemPoolInterface;
+
+/**
+ * This class is a decorator for a TaggablePoolInterface. It tags everything with 'doctrine'.
+ * Use this class with the DoctrineBridge.
+ *
+ * @author Tobias Nyholm <[email protected]>
+ */
+class FixedTaggingCachePool implements CacheItemPoolInterface
+{
+    /**
+     * @type CacheItemPoolInterface|TaggablePoolInterface
+     */
+    private $cache;
+
+    /**
+     * @type array
+     */
+    private $tags;
+
+    /**
+     * @param TaggablePoolInterface $cache
+     * @param array                 $tags
+     */
+    public function __construct(TaggablePoolInterface $cache, array $tags)
+    {
+        $this->cache = $cache;
+        $this->tags  = $tags;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getItem($key)
+    {
+        return $this->cache->getItem($key, $this->tags);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getItems(array $keys = [])
+    {
+        return $this->cache->getItems($keys, $this->tags);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function hasItem($key)
+    {
+        return $this->cache->hasItem($key, $this->tags);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function clear()
+    {
+        return $this->cache->clear($this->tags);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function deleteItem($key)
+    {
+        return $this->cache->deleteItem($key, $this->tags);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function deleteItems(array $keys)
+    {
+        return $this->cache->deleteItems($keys, $this->tags);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function save(CacheItemInterface $item)
+    {
+        return $this->cache->save($item);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function saveDeferred(CacheItemInterface $item)
+    {
+        return $this->cache->saveDeferred($item);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function commit()
+    {
+        return $this->cache->commit();
+    }
+}

src/Command/CacheFlushCommand.php

@@ -73,8 +73,23 @@ private function clearCacheForType($type)
 
         $config = $this->getContainer()->getParameter(sprintf('cache.%s', $type));
 
+        if ($type === 'doctrine') {
+            $this->doClearCache($type, $config['metadata']['service_id']);
+            $this->doClearCache($type, $config['result']['service_id']);
+            $this->doClearCache($type, $config['query']['service_id']);
+        } else {
+            $this->doClearCache($type, $config['service_id']);
+        }
+    }
+
+    /**
+     * @param string $type
+     * @param string $serviceId
+     */
+    private function doClearCache($type, $serviceId)
+    {
         /** @type CacheItemPoolInterface $service */
-        $service = $this->getContainer()->get($config['service_id']);
+        $service = $this->getContainer()->get($serviceId);
         if ($service instanceof TaggablePoolInterface) {
             $service->clear([$type]);
         } else {

src/DependencyInjection/Compiler/DoctrineSupportCompilerPass.php

@@ -12,6 +12,7 @@
 namespace Cache\CacheBundle\DependencyInjection\Compiler;
 
 use Cache\Bridge\DoctrineCacheBridge;
+use Cache\CacheBundle\Cache\FixedTaggingCachePool;
 use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
 use Symfony\Component\DependencyInjection\Reference;
 
@@ -69,7 +70,7 @@ protected function enableDoctrineSupport(array $config)
                 // Doctrine can't talk to a PSR-6 cache, so we need a bridge
                 $bridgeServiceId = sprintf('cache.provider.doctrine.%s.bridge', $cacheType);
                 $bridgeDef       = $this->container->register($bridgeServiceId, DoctrineCacheBridge::class);
-                $bridgeDef->addArgument(0, new Reference($cacheData['service_id']))
+                $bridgeDef->addArgument(new Reference($this->getPoolReferenceForBridge($bridgeServiceId, $cacheData, $config['use_tagging'])))
                     ->setPublic(false);
 
                 foreach ($cacheData[$type] as $manager) {
@@ -88,6 +89,31 @@ protected function enableDoctrineSupport(array $config)
         }
     }
 
+    /**
+     * Get a reference string for the PSR-6 cache implementation service to use with doctrine.
+     * If we support tagging we use the DoctrineTaggingCachePool.
+     *
+     * @param string $bridgeServiceId
+     * @param array  $cacheData
+     * @param bool   $tagging
+     *
+     * @return string
+     */
+    public function getPoolReferenceForBridge($bridgeServiceId, $cacheData, $tagging)
+    {
+        if (!$tagging) {
+            return $cacheData['service_id'];
+        }
+
+        $taggingServiceId = $bridgeServiceId.'.tagging';
+        $taggingDef       = $this->container->register($taggingServiceId, FixedTaggingCachePool::class);
+        $taggingDef->addArgument(new Reference($cacheData['service_id']))
+            ->addArgument(['doctrine'])
+            ->setPublic(false);
+
+        return $taggingServiceId;
+    }
+
     /**
      * Checks to see if there are ORM's or ODM's.
      *

src/DependencyInjection/Configuration.php

@@ -84,6 +84,9 @@ private function addDoctrineSection()
                     ->defaultFalse()
                     ->isRequired()
                 ->end()
+                ->booleanNode('use_tagging')
+                    ->defaultTrue()
+                ->end()
             ->end();
 
         $types = ['metadata', 'result', 'query'];