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

  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.      * needs to be set by class, signature is function(string <key>, mixed <value>, bool <isHit>).
  30.      */
  31.     private static \Closure $createCacheItem;
  33.     /**
  34.      * needs to be set by class, signature is function(array <deferred>, string <namespace>, array <&expiredIds>).
  35.      */
  36.     private static \Closure $mergeByLifetime;
  38.     private string $namespace = '';
  39.     private int $defaultLifetime;
  40.     private string $namespaceVersion = '';
  41.     private bool $versioningIsEnabled = false;
  42.     private array $deferred = [];
  43.     private array $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): iterable;
  59.     /**
  60.      * Confirms if the cache contains specified cache item.
  61.      *
  62.      * @param string $id The identifier for which to check existence
  63.      */
  64.     abstract protected function doHave(string $id): bool;
  66.     /**
  67.      * Deletes all items in the pool.
  68.      *
  69.      * @param string $namespace The prefix used for all identifiers managed by this pool
  70.      */
  71.     abstract protected function doClear(string $namespace): bool;
  73.     /**
  74.      * Removes multiple items from the pool.
  75.      *
  76.      * @param array $ids An array of identifiers that should be removed from the pool
  77.      */
  78.     abstract protected function doDelete(array $ids): bool;
  80.     /**
  81.      * Persists several cache items immediately.
  82.      *
  83.      * @param array $values   The values to cache, indexed by their cache identifier
  84.      * @param int   $lifetime The lifetime of the cached values, 0 for persisting until manual cleaning
  85.      *
  86.      * @return array|bool The identifiers that failed to be cached or a boolean stating if caching succeeded or not
  87.      */
  88.     abstract protected function doSave(array $values, int $lifetime): array|bool;
  90.     public function hasItem(mixed $key): bool
  91.     {
  92.         $id = $this->getId($key);
  94.         if (isset($this->deferred[$key])) {
  95.             $this->commit();
  96.         }
  98.         try {
  99.             return $this->doHave($id);
  100.         } catch (\Exception $e) {
  101.             CacheItem::log($this->logger, 'Failed to check if key "{key}" is cached: '.$e->getMessage(), ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  103.             return false;
  104.         }
  105.     }
  107.     public function clear(string $prefix = ''): bool
  108.     {
  109.         $this->deferred = [];
  110.         if ($cleared = $this->versioningIsEnabled) {
  111.             if ('' === $namespaceVersionToClear = $this->namespaceVersion) {
  112.                 foreach ($this->doFetch([static::NS_SEPARATOR.$this->namespace]) as $v) {
  113.                     $namespaceVersionToClear = $v;
  114.                 }
  115.             }
  116.             $namespaceToClear = $this->namespace.$namespaceVersionToClear;
  117.             $namespaceVersion = self::formatNamespaceVersion(mt_rand());
  118.             try {
  119.                 $e = $this->doSave([static::NS_SEPARATOR.$this->namespace => $namespaceVersion], 0);
  120.             } catch (\Exception $e) {
  121.             }
  122.             if (true !== $e && [] !== $e) {
  123.                 $cleared = false;
  124.                 $message = 'Failed to save the new namespace'.($e instanceof \Exception ? ': '.$e->getMessage() : '.');
  125.                 CacheItem::log($this->logger, $message, ['exception' => $e instanceof \Exception ? $e : null, 'cache-adapter' => get_debug_type($this)]);
  126.             } else {
  127.                 $this->namespaceVersion = $namespaceVersion;
  128.                 $this->ids = [];
  129.             }
  130.         } else {
  131.             $namespaceToClear = $this->namespace.$prefix;
  132.         }
  134.         try {
  135.             return $this->doClear($namespaceToClear) || $cleared;
  136.         } catch (\Exception $e) {
  137.             CacheItem::log($this->logger, 'Failed to clear the cache: '.$e->getMessage(), ['exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  139.             return false;
  140.         }
  141.     }
  143.     public function deleteItem(mixed $key): bool
  144.     {
  145.         return $this->deleteItems([$key]);
  146.     }
  148.     public function deleteItems(array $keys): bool
  149.     {
  150.         $ids = [];
  152.         foreach ($keys as $key) {
  153.             $ids[$key] = $this->getId($key);
  154.             unset($this->deferred[$key]);
  155.         }
  157.         try {
  158.             if ($this->doDelete($ids)) {
  159.                 return true;
  160.             }
  161.         } catch (\Exception) {
  162.         }
  164.         $ok = true;
  166.         // When bulk-delete failed, retry each item individually
  167.         foreach ($ids as $key => $id) {
  168.             try {
  169.                 $e = null;
  170.                 if ($this->doDelete([$id])) {
  171.                     continue;
  172.                 }
  173.             } catch (\Exception $e) {
  174.             }
  175.             $message = 'Failed to delete key "{key}"'.($e instanceof \Exception ? ': '.$e->getMessage() : '.');
  176.             CacheItem::log($this->logger, $message, ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  177.             $ok = false;
  178.         }
  180.         return $ok;
  181.     }
  183.     public function getItem(mixed $key): CacheItem
  184.     {
  185.         $id = $this->getId($key);
  187.         if (isset($this->deferred[$key])) {
  188.             $this->commit();
  189.         }
  191.         $isHit = false;
  192.         $value = null;
  194.         try {
  195.             foreach ($this->doFetch([$id]) as $value) {
  196.                 $isHit = true;
  197.             }
  199.             return (self::$createCacheItem)($key, $value, $isHit);
  200.         } catch (\Exception $e) {
  201.             CacheItem::log($this->logger, 'Failed to fetch key "{key}": '.$e->getMessage(), ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  202.         }
  204.         return (self::$createCacheItem)($key, null, false);
  205.     }
  207.     public function getItems(array $keys = []): iterable
  208.     {
  209.         $ids = [];
  210.         $commit = false;
  212.         foreach ($keys as $key) {
  213.             $ids[] = $this->getId($key);
  214.             $commit = $commit || isset($this->deferred[$key]);
  215.         }
  217.         if ($commit) {
  218.             $this->commit();
  219.         }
  221.         try {
  222.             $items = $this->doFetch($ids);
  223.         } catch (\Exception $e) {
  224.             CacheItem::log($this->logger, 'Failed to fetch items: '.$e->getMessage(), ['keys' => $keys, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  225.             $items = [];
  226.         }
  227.         $ids = array_combine($ids, $keys);
  229.         return $this->generateItems($items, $ids);
  230.     }
  232.     public function save(CacheItemInterface $item): bool
  233.     {
  234.         if (!$item instanceof CacheItem) {
  235.             return false;
  236.         }
  237.         $this->deferred[$item->getKey()] = $item;
  239.         return $this->commit();
  240.     }
  242.     public function saveDeferred(CacheItemInterface $item): bool
  243.     {
  244.         if (!$item instanceof CacheItem) {
  245.             return false;
  246.         }
  247.         $this->deferred[$item->getKey()] = $item;
  249.         return true;
  250.     }
  252.     /**
  253.      * Enables/disables versioning of items.
  254.      *
  255.      * When versioning is enabled, clearing the cache is atomic and doesn't require listing existing keys to proceed,
  256.      * but old keys may need garbage collection and extra round-trips to the back-end are required.
  257.      *
  258.      * Calling this method also clears the memoized namespace version and thus forces a resynchronization of it.
  259.      *
  260.      * @return bool the previous state of versioning
  261.      */
  262.     public function enableVersioning(bool $enable = true): bool
  263.     {
  264.         $wasEnabled = $this->versioningIsEnabled;
  265.         $this->versioningIsEnabled = $enable;
  266.         $this->namespaceVersion = '';
  267.         $this->ids = [];
  269.         return $wasEnabled;
  270.     }
  272.     public function reset()
  273.     {
  274.         if ($this->deferred) {
  275.             $this->commit();
  276.         }
  277.         $this->namespaceVersion = '';
  278.         $this->ids = [];
  279.     }
  281.     public function __sleep(): array
  282.     {
  283.         throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
  284.     }
  286.     public function __wakeup()
  287.     {
  288.         throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
  289.     }
  291.     public function __destruct()
  292.     {
  293.         if ($this->deferred) {
  294.             $this->commit();
  295.         }
  296.     }
  298.     private function generateItems(iterable $items, array &$keys): \Generator
  299.     {
  300.         $f = self::$createCacheItem;
  302.         try {
  303.             foreach ($items as $id => $value) {
  304.                 if (!isset($keys[$id])) {
  305.                     throw new InvalidArgumentException(sprintf('Could not match value id "%s" to keys "%s".', $id, implode('", "', $keys)));
  306.                 }
  307.                 $key = $keys[$id];
  308.                 unset($keys[$id]);
  309.                 yield $key => $f($key, $value, true);
  310.             }
  311.         } catch (\Exception $e) {
  312.             CacheItem::log($this->logger, 'Failed to fetch items: '.$e->getMessage(), ['keys' => array_values($keys), 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  313.         }
  315.         foreach ($keys as $key) {
  316.             yield $key => $f($key, null, false);
  317.         }
  318.     }
  320.     /**
  321.      * @internal
  322.      */
  323.     protected function getId(mixed $key)
  324.     {
  325.         if ($this->versioningIsEnabled && '' === $this->namespaceVersion) {
  326.             $this->ids = [];
  327.             $this->namespaceVersion = '1'.static::NS_SEPARATOR;
  328.             try {
  329.                 foreach ($this->doFetch([static::NS_SEPARATOR.$this->namespace]) as $v) {
  330.                     $this->namespaceVersion = $v;
  331.                 }
  332.                 $e = true;
  333.                 if ('1'.static::NS_SEPARATOR === $this->namespaceVersion) {
  334.                     $this->namespaceVersion = self::formatNamespaceVersion(time());
  335.                     $e = $this->doSave([static::NS_SEPARATOR.$this->namespace => $this->namespaceVersion], 0);
  336.                 }
  337.             } catch (\Exception $e) {
  338.             }
  339.             if (true !== $e && [] !== $e) {
  340.                 $message = 'Failed to save the new namespace'.($e instanceof \Exception ? ': '.$e->getMessage() : '.');
  341.                 CacheItem::log($this->logger, $message, ['exception' => $e instanceof \Exception ? $e : null, 'cache-adapter' => get_debug_type($this)]);
  342.             }
  343.         }
  345.         if (\is_string($key) && isset($this->ids[$key])) {
  346.             return $this->namespace.$this->namespaceVersion.$this->ids[$key];
  347.         }
  348.         \assert('' !== CacheItem::validateKey($key));
  349.         $this->ids[$key] = $key;
  351.         if (\count($this->ids) > 1000) {
  352.             $this->ids = \array_slice($this->ids, 500, null, true); // stop memory leak if there are many keys
  353.         }
  355.         if (null === $this->maxIdLength) {
  356.             return $this->namespace.$this->namespaceVersion.$key;
  357.         }
  358.         if (\strlen($id = $this->namespace.$this->namespaceVersion.$key) > $this->maxIdLength) {
  359.             // Use MD5 to favor speed over security, which is not an issue here
  360.             $this->ids[$key] = $id = substr_replace(base64_encode(hash('md5', $key, true)), static::NS_SEPARATOR, -(\strlen($this->namespaceVersion) + 2));
  361.             $id = $this->namespace.$this->namespaceVersion.$id;
  362.         }
  364.         return $id;
  365.     }
  367.     /**
  368.      * @internal
  369.      */
  370.     public static function handleUnserializeCallback(string $class)
  371.     {
  372.         throw new \DomainException('Class not found: '.$class);
  373.     }
  375.     private static function formatNamespaceVersion(int $value): string
  376.     {
  377.         return strtr(substr_replace(base64_encode(pack('V', $value)), static::NS_SEPARATOR, 5), '/', '_');
  378.     }
  379. }