Merge pull request #8 from php-cache/command

Improved the cache flush command

Author: cryptiklemur

composer.json

@@ -24,14 +24,15 @@
         }
     ],
     "require":      {
-        "php":                      "^5.5|^7",
-        "symfony/framework-bundle": "^2.6|^3.0",
-        "psr/cache-implementation": "~1.0"
+        "php":                         "^5.5|^7",
+        "symfony/framework-bundle":    "^2.6|^3.0",
+        "cache/psr-6-doctrine-bridge": "^0.1",
+        "cache/taggable-cache":        "^0.1",
+        "psr/cache-implementation":    "~1.0"
     },
     "require-dev":  {
         "phpunit/phpunit":        "^5.1|^4.0",
-        "cache/doctrine-adapter": "^0.1",
-        "cache/taggable-cache":   "^0.1"
+        "cache/doctrine-adapter": "^0.1"
     },
     "suggest":      {
         "cache/doctrine-adapter-bundle": "A bundle to register PSR-6 compliant services based on Doctrine cache"

src/Command/CacheFlushCommand.php

@@ -11,39 +11,65 @@
 
 namespace Cache\CacheBundle\Command;
 
+use Cache\Taggable\TaggablePoolInterface;
 use Psr\Cache\CacheItemPoolInterface;
 use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Console\Input\InputArgument;
 
 /**
- * Class CacheFlushCommand
+ * Class CacheFlushCommand.
  *
  * @author Aaron Scherer <[email protected]>
  */
 class CacheFlushCommand extends ContainerAwareCommand
 {
-
     /**
      * {@inheritdoc}
      */
     protected function configure()
     {
         $this->setName('cache:flush');
         $this->setDescription('Flushes the given cache');
-        $this->addArgument('instance', InputArgument::REQUIRED, 'Which instance do you want to clean?');
+        $this->addArgument('type', InputArgument::REQUIRED, 'Which type of cache do you want to clear?');
     }
 
     /**
      * {@inheritdoc}
      */
     protected function execute(InputInterface $input, OutputInterface $output)
     {
-        $serviceName = sprintf('cache.instance.%s', $input->getArgument('instance'));
+        $validTypes = ['session', 'routing', 'doctrine', 'all'];
+        $type = $input->getArgument('type');
+        if (!in_array($type, $validTypes)) {
+            $output->writeln(sprintf('Type "%s" does not exist. Valid type are: %s', $type, implode(',', $validTypes)));
+        }
+
+        if ($type === 'all') {
+            foreach (['session', 'routing', 'doctrine'] as $type) {
+                $this->clearCacheForType($type);
+            }
+        } else {
+            $this->clearCacheForType($type);
+        }
+    }
+
+    /**
+     * Clear the cache for a type.
+     *
+     * @param string $type
+     */
+    private function clearCacheForType($type)
+    {
+        $serviceId = $this->getContainer()->getParameter(sprintf('cache.%s%.service_id', $type));
 
         /** @var CacheItemPoolInterface $service */
-        $service = $this->getContainer()->get($serviceName);
-        $service->clear();
+        $service = $this->getContainer()->get($serviceId);
+        if ($service instanceof TaggablePoolInterface) {
+            $service->clear([$type]);
+        } else {
+            $service->clear();
+        }
     }
 }

src/Session/SessionHandler.php

@@ -11,10 +11,11 @@
 
 namespace Cache\CacheBundle\Session;
 
+use Cache\Taggable\TaggablePoolInterface;
 use Psr\Cache\CacheItemPoolInterface;
 
 /**
- * Class SessionHandler
+ * Class SessionHandler.
  *
  * @author Aaron Scherer <[email protected]>
  */
@@ -26,7 +27,7 @@ class SessionHandler implements \SessionHandlerInterface
     private $cache;
 
     /**
-     * @var integer Time to live in seconds
+     * @var int Time to live in seconds
      */
     private $ttl;
 
@@ -43,40 +44,40 @@ class SessionHandler implements \SessionHandlerInterface
      *  * expiretime: The time to live in seconds
      *
      * @param CacheItemPoolInterface $cache   A Cache instance
-     * @param array $options An associative array of cache options
+     * @param array                  $options An associative array of cache options
      *
      * @throws \InvalidArgumentException When unsupported options are passed
      */
     public function __construct(CacheItemPoolInterface $cache, array $options = array())
     {
         $this->cache = $cache;
 
-        $this->ttl    = isset($options['ttl']) ? (int) $options['ttl'] : 86400;
+        $this->ttl = isset($options['ttl']) ? (int) $options['ttl'] : 86400;
         $this->prefix = isset($options['prefix']) ? $options['prefix'] : 'sf2ses_';
     }
 
     /**
-     * {@inheritDoc}
+     * {@inheritdoc}
      */
     public function open($savePath, $sessionName)
     {
         return true;
     }
 
     /**
-     * {@inheritDoc}
+     * {@inheritdoc}
      */
     public function close()
     {
         return true;
     }
 
     /**
-     * {@inheritDoc}
+     * {@inheritdoc}
      */
     public function read($sessionId)
     {
-        $item = $this->cache->getItem($this->prefix.$sessionId);
+        $item = $this->getCacheItem($sessionId);
         if ($item->isHit()) {
             return $item->get();
         }
@@ -85,31 +86,49 @@ public function read($sessionId)
     }
 
     /**
-     * {@inheritDoc}
+     * {@inheritdoc}
      */
     public function write($sessionId, $data)
     {
-        $item = $this->cache->getItem($this->prefix . $sessionId);
+        $item = $this->getCacheItem($sessionId);
         $item->set($data)
             ->expiresAfter($this->ttl);
 
         return $this->cache->save($item);
     }
 
     /**
-     * {@inheritDoc}
+     * {@inheritdoc}
      */
     public function destroy($sessionId)
     {
-        return $this->cache->deleteItem($this->prefix . $sessionId);
+        if ($this->cache instanceof TaggablePoolInterface) {
+            return $this->cache->deleteItem($this->prefix.$sessionId, ['session']);
+        }
+
+        return $this->cache->deleteItem($this->prefix.$sessionId);
     }
 
     /**
-     * {@inheritDoc}
+     * {@inheritdoc}
      */
     public function gc($lifetime)
     {
         // not required here because cache will auto expire the records anyhow.
         return true;
     }
+
+    /**
+     * @param $sessionId
+     *
+     * @return \Psr\Cache\CacheItemInterface
+     */
+    private function getCacheItem($sessionId)
+    {
+        if ($this->cache instanceof TaggablePoolInterface) {
+            return $this->cache->getItem($this->prefix.$sessionId, ['session']);
+        }
+
+        return $this->cache->getItem($this->prefix.$sessionId);
+    }
 }