Make sure we tag the doctrine cache

Author: Nyholm

src/Cache/DoctrineTaggingCachePool.php

@@ -0,0 +1,101 @@
+<?php
+
+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 DoctrineTaggingCachePool implements CacheItemPoolInterface
+{
+    /**
+     * @var CacheItemPoolInterface|TaggablePoolInterface
+     */
+    private $cache;
+
+    /**
+     * @param TaggablePoolInterface $cache
+     */
+    public function __construct(TaggablePoolInterface $cache)
+    {
+        $this->cache = $cache;
+    }
+
+    /**
+     * @{@inheritdoc}
+     */
+    public function getItem($key)
+    {
+        return $this->cache->getItem($key, ['doctrine']);
+    }
+
+    /**
+     * @{@inheritdoc}
+     */
+    public function getItems(array $keys = array())
+    {
+        return $this->cache->getItems($keys, ['doctrine']);
+    }
+
+    /**
+     * @{@inheritdoc}
+     */
+    public function hasItem($key)
+    {
+        return $this->cache->hasItem($key, ['doctrine']);
+    }
+
+    /**
+     * @{@inheritdoc}
+     */
+    public function clear()
+    {
+        return $this->cache->clear(['doctrine']);
+    }
+
+    /**
+     * @{@inheritdoc}
+     */
+    public function deleteItem($key)
+    {
+        return $this->cache->deleteItem($key, ['doctrine']);
+    }
+
+    /**
+     * @{@inheritdoc}
+     */
+    public function deleteItems(array $keys)
+    {
+        return $this->cache->deleteItems($keys, ['doctrine']);
+    }
+
+    /**
+     * @{@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/DependencyInjection/Compiler/DoctrineSupportCompilerPass.php

@@ -12,6 +12,7 @@
 namespace Cache\CacheBundle\DependencyInjection\Compiler;
 
 use Cache\Bridge\DoctrineCacheBridge;
+use Cache\CacheBundle\Cache\DoctrineTaggingCachePool;
 use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
 use Symfony\Component\DependencyInjection\Reference;
 
@@ -23,6 +24,8 @@
  */
 class DoctrineSupportCompilerPass extends BaseCompilerPass
 {
+
+
     /**
      * @throws \Exception
      *
@@ -69,7 +72,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 +91,30 @@ 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, DoctrineTaggingCachePool::class);
+        $taggingDef->addArgument(new Reference($cacheData['service_id']))
+            ->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'];