vendor/symfony/symfony/src/Symfony/Component/Cache/Traits/AbstractTrait.php line 222

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Cache\Traits;
  14. use Psr\Log\LoggerAwareTrait;
  15. use Symfony\Component\Cache\CacheItem;
  17. /**
  18.  * @author Nicolas Grekas <p@tchwork.com>
  19.  *
  20.  * @internal
  21.  */
  22. trait AbstractTrait
  23. {
  24.     use LoggerAwareTrait;
  26.     private $namespace;
  27.     private $namespaceVersion = '';
  28.     private $versioningIsEnabled = false;
  29.     private $deferred = [];
  31.     /**
  32.      * @var int|null The maximum length to enforce for identifiers or null when no limit applies
  33.      */
  34.     protected $maxIdLength;
  36.     /**
  37.      * Fetches several cache items.
  38.      *
  39.      * @param array $ids The cache identifiers to fetch
  40.      *
  41.      * @return array|\Traversable The corresponding values found in the cache
  42.      */
  43.     abstract protected function doFetch(array $ids);
  45.     /**
  46.      * Confirms if the cache contains specified cache item.
  47.      *
  48.      * @param string $id The identifier for which to check existence
  49.      *
  50.      * @return bool True if item exists in the cache, false otherwise
  51.      */
  52.     abstract protected function doHave($id);
  54.     /**
  55.      * Deletes all items in the pool.
  56.      *
  57.      * @param string $namespace The prefix used for all identifiers managed by this pool
  58.      *
  59.      * @return bool True if the pool was successfully cleared, false otherwise
  60.      */
  61.     abstract protected function doClear($namespace);
  63.     /**
  64.      * Removes multiple items from the pool.
  65.      *
  66.      * @param array $ids An array of identifiers that should be removed from the pool
  67.      *
  68.      * @return bool True if the items were successfully removed, false otherwise
  69.      */
  70.     abstract protected function doDelete(array $ids);
  72.     /**
  73.      * Persists several cache items immediately.
  74.      *
  75.      * @param array $values   The values to cache, indexed by their cache identifier
  76.      * @param int   $lifetime The lifetime of the cached values, 0 for persisting until manual cleaning
  77.      *
  78.      * @return array|bool The identifiers that failed to be cached or a boolean stating if caching succeeded or not
  79.      */
  80.     abstract protected function doSave(array $values, $lifetime);
  82.     /**
  83.      * {@inheritdoc}
  84.      */
  85.     public function hasItem($key)
  86.     {
  87.         $id = $this->getId($key);
  89.         if (isset($this->deferred[$key])) {
  90.             $this->commit();
  91.         }
  93.         try {
  94.             return $this->doHave($id);
  95.         } catch (\Exception $e) {
  96.             CacheItem::log($this->logger, 'Failed to check if key "{key}" is cached', ['key' => $key, 'exception' => $e]);
  98.             return false;
  99.         }
  100.     }
  102.     /**
  103.      * {@inheritdoc}
  104.      */
  105.     public function clear()
  106.     {
  107.         $this->deferred = [];
  108.         if ($cleared = $this->versioningIsEnabled) {
  109.             $namespaceVersion = substr_replace(base64_encode(pack('V', mt_rand())), static::NS_SEPARATOR, 5);
  110.             try {
  111.                 $cleared = $this->doSave([static::NS_SEPARATOR.$this->namespace => $namespaceVersion], 0);
  112.             } catch (\Exception $e) {
  113.                 $cleared = false;
  114.             }
  115.             if ($cleared = true === $cleared || [] === $cleared) {
  116.                 $this->namespaceVersion = $namespaceVersion;
  117.             }
  118.         }
  120.         try {
  121.             return $this->doClear($this->namespace) || $cleared;
  122.         } catch (\Exception $e) {
  123.             CacheItem::log($this->logger, 'Failed to clear the cache', ['exception' => $e]);
  125.             return false;
  126.         }
  127.     }
  129.     /**
  130.      * {@inheritdoc}
  131.      */
  132.     public function deleteItem($key)
  133.     {
  134.         return $this->deleteItems([$key]);
  135.     }
  137.     /**
  138.      * {@inheritdoc}
  139.      */
  140.     public function deleteItems(array $keys)
  141.     {
  142.         $ids = [];
  144.         foreach ($keys as $key) {
  145.             $ids[$key] = $this->getId($key);
  146.             unset($this->deferred[$key]);
  147.         }
  149.         try {
  150.             if ($this->doDelete($ids)) {
  151.                 return true;
  152.             }
  153.         } catch (\Exception $e) {
  154.         }
  156.         $ok = true;
  158.         // When bulk-delete failed, retry each item individually
  159.         foreach ($ids as $key => $id) {
  160.             try {
  161.                 $e = null;
  162.                 if ($this->doDelete([$id])) {
  163.                     continue;
  164.                 }
  165.             } catch (\Exception $e) {
  166.             }
  167.             CacheItem::log($this->logger, 'Failed to delete key "{key}"', ['key' => $key, 'exception' => $e]);
  168.             $ok = false;
  169.         }
  171.         return $ok;
  172.     }
  174.     /**
  175.      * Enables/disables versioning of items.
  176.      *
  177.      * When versioning is enabled, clearing the cache is atomic and doesn't require listing existing keys to proceed,
  178.      * but old keys may need garbage collection and extra round-trips to the back-end are required.
  179.      *
  180.      * Calling this method also clears the memoized namespace version and thus forces a resynchonization of it.
  181.      *
  182.      * @param bool $enable
  183.      *
  184.      * @return bool the previous state of versioning
  185.      */
  186.     public function enableVersioning($enable = true)
  187.     {
  188.         $wasEnabled = $this->versioningIsEnabled;
  189.         $this->versioningIsEnabled = (bool) $enable;
  190.         $this->namespaceVersion = '';
  192.         return $wasEnabled;
  193.     }
  195.     /**
  196.      * {@inheritdoc}
  197.      */
  198.     public function reset()
  199.     {
  200.         if ($this->deferred) {
  201.             $this->commit();
  202.         }
  203.         $this->namespaceVersion = '';
  204.     }
  206.     /**
  207.      * Like the native unserialize() function but throws an exception if anything goes wrong.
  208.      *
  209.      * @param string $value
  210.      *
  211.      * @return mixed
  212.      *
  213.      * @throws \Exception
  214.      */
  215.     protected static function unserialize($value)
  216.     {
  217.         if ('b:0;' === $value) {
  218.             return false;
  219.         }
  220.         $unserializeCallbackHandler = ini_set('unserialize_callback_func', __CLASS__.'::handleUnserializeCallback');
  221.         try {
  222.             if (false !== $value = unserialize($value)) {
  223.                 return $value;
  224.             }
  225.             throw new \DomainException('Failed to unserialize cached value.');
  226.         } catch (\Error $e) {
  227.             throw new \ErrorException($e->getMessage(), $e->getCode(), \E_ERROR, $e->getFile(), $e->getLine());
  228.         } finally {
  229.             ini_set('unserialize_callback_func', $unserializeCallbackHandler);
  230.         }
  231.     }
  233.     private function getId($key)
  234.     {
  235.         CacheItem::validateKey($key);
  237.         if ($this->versioningIsEnabled && '' === $this->namespaceVersion) {
  238.             $this->namespaceVersion = '1'.static::NS_SEPARATOR;
  239.             try {
  240.                 foreach ($this->doFetch([static::NS_SEPARATOR.$this->namespace]) as $v) {
  241.                     $this->namespaceVersion = $v;
  242.                 }
  243.                 if ('1'.static::NS_SEPARATOR === $this->namespaceVersion) {
  244.                     $this->namespaceVersion = substr_replace(base64_encode(pack('V', time())), static::NS_SEPARATOR, 5);
  245.                     $this->doSave([static::NS_SEPARATOR.$this->namespace => $this->namespaceVersion], 0);
  246.                 }
  247.             } catch (\Exception $e) {
  248.             }
  249.         }
  251.         if (null === $this->maxIdLength) {
  252.             return $this->namespace.$this->namespaceVersion.$key;
  253.         }
  254.         if (\strlen($id = $this->namespace.$this->namespaceVersion.$key) > $this->maxIdLength) {
  255.             $id = $this->namespace.$this->namespaceVersion.substr_replace(base64_encode(hash('sha256', $key, true)), static::NS_SEPARATOR, -(\strlen($this->namespaceVersion) + 22));
  256.         }
  258.         return $id;
  259.     }
  261.     /**
  262.      * @internal
  263.      */
  264.     public static function handleUnserializeCallback($class)
  265.     {
  266.         throw new \DomainException('Class not found: '.$class);
  267.     }
  268. }