vendor/symfony/cache/Traits/AbstractAdapterTrait.php line 209

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\Cache\CacheItemInterface;
  15. use Psr\Log\LoggerAwareTrait;
  16. use Symfony\Component\Cache\CacheItem;
  17. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  19. /**
  20.  * @author Nicolas Grekas <p@tchwork.com>
  21.  *
  22.  * @internal
  23.  */
  24. trait AbstractAdapterTrait
  25. {
  26.     use LoggerAwareTrait;
  28.     /**
  29.      * @var \Closure needs to be set by class, signature is function(string <key>, mixed <value>, bool <isHit>)
  30.      */
  31.     private static $createCacheItem;
  33.     /**
  34.      * @var \Closure needs to be set by class, signature is function(array <deferred>, string <namespace>, array <&expiredIds>)
  35.      */
  36.     private static $mergeByLifetime;
  38.     private $namespace = '';
  39.     private $defaultLifetime;
  40.     private $namespaceVersion = '';
  41.     private $versioningIsEnabled = false;
  42.     private $deferred = [];
  43.     private $ids = [];
  45.     /**
  46.      * @var int|null The maximum length to enforce for identifiers or null when no limit applies
  47.      */
  48.     protected $maxIdLength;
  50.     /**
  51.      * Fetches several cache items.
  52.      *
  53.      * @param array $ids The cache identifiers to fetch
  54.      *
  55.      * @return array|\Traversable
  56.      */
  57.     abstract protected function doFetch(array $ids);
  59.     /**
  60.      * Confirms if the cache contains specified cache item.
  61.      *
  62.      * @param string $id The identifier for which to check existence
  63.      *
  64.      * @return bool
  65.      */
  66.     abstract protected function doHave(string $id);
  68.     /**
  69.      * Deletes all items in the pool.
  70.      *
  71.      * @param string $namespace The prefix used for all identifiers managed by this pool
  72.      *
  73.      * @return bool
  74.      */
  75.     abstract protected function doClear(string $namespace);
  77.     /**
  78.      * Removes multiple items from the pool.
  79.      *
  80.      * @param array $ids An array of identifiers that should be removed from the pool
  81.      *
  82.      * @return bool
  83.      */
  84.     abstract protected function doDelete(array $ids);
  86.     /**
  87.      * Persists several cache items immediately.
  88.      *
  89.      * @param array $values   The values to cache, indexed by their cache identifier
  90.      * @param int   $lifetime The lifetime of the cached values, 0 for persisting until manual cleaning
  91.      *
  92.      * @return array|bool The identifiers that failed to be cached or a boolean stating if caching succeeded or not
  93.      */
  94.     abstract protected function doSave(array $values, int $lifetime);
  96.     /**
  97.      * {@inheritdoc}
  98.      *
  99.      * @return bool
  100.      */
  101.     public function hasItem($key)
  102.     {
  103.         $id = $this->getId($key);
  105.         if (isset($this->deferred[$key])) {
  106.             $this->commit();
  107.         }
  109.         try {
  110.             return $this->doHave($id);
  111.         } catch (\Exception $e) {
  112.             CacheItem::log($this->logger, 'Failed to check if key "{key}" is cached: '.$e->getMessage(), ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  114.             return false;
  115.         }
  116.     }
  118.     /**
  119.      * {@inheritdoc}
  120.      *
  121.      * @return bool
  122.      */
  123.     public function clear(string $prefix = '')
  124.     {
  125.         $this->deferred = [];
  126.         if ($cleared = $this->versioningIsEnabled) {
  127.             if ('' === $namespaceVersionToClear = $this->namespaceVersion) {
  128.                 foreach ($this->doFetch([static::NS_SEPARATOR.$this->namespace]) as $v) {
  129.                     $namespaceVersionToClear = $v;
  130.                 }
  131.             }
  132.             $namespaceToClear = $this->namespace.$namespaceVersionToClear;
  133.             $namespaceVersion = strtr(substr_replace(base64_encode(pack('V', mt_rand())), static::NS_SEPARATOR, 5), '/', '_');
  134.             try {
  135.                 $cleared = $this->doSave([static::NS_SEPARATOR.$this->namespace => $namespaceVersion], 0);
  136.             } catch (\Exception $e) {
  137.                 $cleared = false;
  138.             }
  139.             if ($cleared = true === $cleared || [] === $cleared) {
  140.                 $this->namespaceVersion = $namespaceVersion;
  141.                 $this->ids = [];
  142.             }
  143.         } else {
  144.             $namespaceToClear = $this->namespace.$prefix;
  145.         }
  147.         try {
  148.             return $this->doClear($namespaceToClear) || $cleared;
  149.         } catch (\Exception $e) {
  150.             CacheItem::log($this->logger, 'Failed to clear the cache: '.$e->getMessage(), ['exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  152.             return false;
  153.         }
  154.     }
  156.     /**
  157.      * {@inheritdoc}
  158.      *
  159.      * @return bool
  160.      */
  161.     public function deleteItem($key)
  162.     {
  163.         return $this->deleteItems([$key]);
  164.     }
  166.     /**
  167.      * {@inheritdoc}
  168.      *
  169.      * @return bool
  170.      */
  171.     public function deleteItems(array $keys)
  172.     {
  173.         $ids = [];
  175.         foreach ($keys as $key) {
  176.             $ids[$key] = $this->getId($key);
  177.             unset($this->deferred[$key]);
  178.         }
  180.         try {
  181.             if ($this->doDelete($ids)) {
  182.                 return true;
  183.             }
  184.         } catch (\Exception $e) {
  185.         }
  187.         $ok = true;
  189.         // When bulk-delete failed, retry each item individually
  190.         foreach ($ids as $key => $id) {
  191.             try {
  192.                 $e = null;
  193.                 if ($this->doDelete([$id])) {
  194.                     continue;
  195.                 }
  196.             } catch (\Exception $e) {
  197.             }
  198.             $message = 'Failed to delete key "{key}"'.($e instanceof \Exception ? ': '.$e->getMessage() : '.');
  199.             CacheItem::log($this->logger, $message, ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  200.             $ok = false;
  201.         }
  203.         return $ok;
  204.     }
  206.     /**
  207.      * {@inheritdoc}
  208.      */
  209.     public function getItem($key)
  210.     {
  211.         $id = $this->getId($key);
  213.         if (isset($this->deferred[$key])) {
  214.             $this->commit();
  215.         }
  217.         $isHit = false;
  218.         $value = null;
  220.         try {
  221.             foreach ($this->doFetch([$id]) as $value) {
  222.                 $isHit = true;
  223.             }
  225.             return (self::$createCacheItem)($key, $value, $isHit);
  226.         } catch (\Exception $e) {
  227.             CacheItem::log($this->logger, 'Failed to fetch key "{key}": '.$e->getMessage(), ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  228.         }
  230.         return (self::$createCacheItem)($key, null, false);
  231.     }
  233.     /**
  234.      * {@inheritdoc}
  235.      */
  236.     public function getItems(array $keys = [])
  237.     {
  238.         $ids = [];
  239.         $commit = false;
  241.         foreach ($keys as $key) {
  242.             $ids[] = $this->getId($key);
  243.             $commit = $commit || isset($this->deferred[$key]);
  244.         }
  246.         if ($commit) {
  247.             $this->commit();
  248.         }
  250.         try {
  251.             $items = $this->doFetch($ids);
  252.         } catch (\Exception $e) {
  253.             CacheItem::log($this->logger, 'Failed to fetch items: '.$e->getMessage(), ['keys' => $keys, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  254.             $items = [];
  255.         }
  256.         $ids = array_combine($ids, $keys);
  258.         return $this->generateItems($items, $ids);
  259.     }
  261.     /**
  262.      * {@inheritdoc}
  263.      *
  264.      * @return bool
  265.      */
  266.     public function save(CacheItemInterface $item)
  267.     {
  268.         if (!$item instanceof CacheItem) {
  269.             return false;
  270.         }
  271.         $this->deferred[$item->getKey()] = $item;
  273.         return $this->commit();
  274.     }
  276.     /**
  277.      * {@inheritdoc}
  278.      *
  279.      * @return bool
  280.      */
  281.     public function saveDeferred(CacheItemInterface $item)
  282.     {
  283.         if (!$item instanceof CacheItem) {
  284.             return false;
  285.         }
  286.         $this->deferred[$item->getKey()] = $item;
  288.         return true;
  289.     }
  291.     /**
  292.      * Enables/disables versioning of items.
  293.      *
  294.      * When versioning is enabled, clearing the cache is atomic and doesn't require listing existing keys to proceed,
  295.      * but old keys may need garbage collection and extra round-trips to the back-end are required.
  296.      *
  297.      * Calling this method also clears the memoized namespace version and thus forces a resynchonization of it.
  298.      *
  299.      * @return bool the previous state of versioning
  300.      */
  301.     public function enableVersioning(bool $enable = true)
  302.     {
  303.         $wasEnabled = $this->versioningIsEnabled;
  304.         $this->versioningIsEnabled = $enable;
  305.         $this->namespaceVersion = '';
  306.         $this->ids = [];
  308.         return $wasEnabled;
  309.     }
  311.     /**
  312.      * {@inheritdoc}
  313.      */
  314.     public function reset()
  315.     {
  316.         if ($this->deferred) {
  317.             $this->commit();
  318.         }
  319.         $this->namespaceVersion = '';
  320.         $this->ids = [];
  321.     }
  323.     /**
  324.      * @return array
  325.      */
  326.     public function __sleep()
  327.     {
  328.         throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
  329.     }
  331.     public function __wakeup()
  332.     {
  333.         throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
  334.     }
  336.     public function __destruct()
  337.     {
  338.         if ($this->deferred) {
  339.             $this->commit();
  340.         }
  341.     }
  343.     private function generateItems(iterable $items, array &$keys): \Generator
  344.     {
  345.         $f = self::$createCacheItem;
  347.         try {
  348.             foreach ($items as $id => $value) {
  349.                 if (!isset($keys[$id])) {
  350.                     throw new InvalidArgumentException(sprintf('Could not match value id "%s" to keys "%s".', $id, implode('", "', $keys)));
  351.                 }
  352.                 $key = $keys[$id];
  353.                 unset($keys[$id]);
  354.                 yield $key => $f($key, $value, true);
  355.             }
  356.         } catch (\Exception $e) {
  357.             CacheItem::log($this->logger, 'Failed to fetch items: '.$e->getMessage(), ['keys' => array_values($keys), 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  358.         }
  360.         foreach ($keys as $key) {
  361.             yield $key => $f($key, null, false);
  362.         }
  363.     }
  365.     private function getId($key)
  366.     {
  367.         if ($this->versioningIsEnabled && '' === $this->namespaceVersion) {
  368.             $this->ids = [];
  369.             $this->namespaceVersion = '1'.static::NS_SEPARATOR;
  370.             try {
  371.                 foreach ($this->doFetch([static::NS_SEPARATOR.$this->namespace]) as $v) {
  372.                     $this->namespaceVersion = $v;
  373.                 }
  374.                 if ('1'.static::NS_SEPARATOR === $this->namespaceVersion) {
  375.                     $this->namespaceVersion = strtr(substr_replace(base64_encode(pack('V', time())), static::NS_SEPARATOR, 5), '/', '_');
  376.                     $this->doSave([static::NS_SEPARATOR.$this->namespace => $this->namespaceVersion], 0);
  377.                 }
  378.             } catch (\Exception $e) {
  379.             }
  380.         }
  382.         if (\is_string($key) && isset($this->ids[$key])) {
  383.             return $this->namespace.$this->namespaceVersion.$this->ids[$key];
  384.         }
  385.         \assert('' !== CacheItem::validateKey($key));
  386.         $this->ids[$key] = $key;
  388.         if (\count($this->ids) > 1000) {
  389.             array_splice($this->ids, 0, 500); // stop memory leak if there are many keys
  390.         }
  392.         if (null === $this->maxIdLength) {
  393.             return $this->namespace.$this->namespaceVersion.$key;
  394.         }
  395.         if (\strlen($id = $this->namespace.$this->namespaceVersion.$key) > $this->maxIdLength) {
  396.             // Use MD5 to favor speed over security, which is not an issue here
  397.             $this->ids[$key] = $id = substr_replace(base64_encode(hash('md5', $key, true)), static::NS_SEPARATOR, -(\strlen($this->namespaceVersion) + 2));
  398.             $id = $this->namespace.$this->namespaceVersion.$id;
  399.         }
  401.         return $id;
  402.     }
  404.     /**
  405.      * @internal
  406.      */
  407.     public static function handleUnserializeCallback(string $class)
  408.     {
  409.         throw new \DomainException('Class not found: '.$class);
  410.     }
  411. }