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

  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 readonly string $rootNamespace;
  39.     private string $namespace = '';
  40.     private int $defaultLifetime;
  41.     private string $namespaceVersion = '';
  42.     private bool $versioningIsEnabled = false;
  43.     private array $deferred = [];
  44.     private array $ids = [];
  46.     /**
  47.      * The maximum length to enforce for identifiers or null when no limit applies.
  48.      */
  49.     protected ?int $maxIdLength = null;
  51.     /**
  52.      * Fetches several cache items.
  53.      *
  54.      * @param array $ids The cache identifiers to fetch
  55.      */
  56.     abstract protected function doFetch(array $ids): iterable;
  58.     /**
  59.      * Confirms if the cache contains specified cache item.
  60.      *
  61.      * @param string $id The identifier for which to check existence
  62.      */
  63.     abstract protected function doHave(string $id): bool;
  65.     /**
  66.      * Deletes all items in the pool.
  67.      *
  68.      * @param string $namespace The prefix used for all identifiers managed by this pool
  69.      */
  70.     abstract protected function doClear(string $namespace): bool;
  72.     /**
  73.      * Removes multiple items from the pool.
  74.      *
  75.      * @param array $ids An array of identifiers that should be removed from the pool
  76.      */
  77.     abstract protected function doDelete(array $ids): bool;
  79.     /**
  80.      * Persists several cache items immediately.
  81.      *
  82.      * @param array $values   The values to cache, indexed by their cache identifier
  83.      * @param int   $lifetime The lifetime of the cached values, 0 for persisting until manual cleaning
  84.      *
  85.      * @return array|bool The identifiers that failed to be cached or a boolean stating if caching succeeded or not
  86.      */
  87.     abstract protected function doSave(array $values, int $lifetime): array|bool;
  89.     public function hasItem(mixed $key): bool
  90.     {
  91.         $id = $this->getId($key);
  93.         if (isset($this->deferred[$key])) {
  94.             $this->commit();
  95.         }
  97.         try {
  98.             return $this->doHave($id);
  99.         } catch (\Exception $e) {
  100.             CacheItem::log($this->logger, 'Failed to check if key "{key}" is cached: '.$e->getMessage(), ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  102.             return false;
  103.         }
  104.     }
  106.     public function clear(string $prefix = ''): bool
  107.     {
  108.         $this->deferred = [];
  109.         if ($cleared = $this->versioningIsEnabled) {
  110.             $rootNamespace = $this->rootNamespace ??= $this->namespace;
  111.             if ('' === $namespaceVersionToClear = $this->namespaceVersion) {
  112.                 foreach ($this->doFetch([static::NS_SEPARATOR.$rootNamespace]) as $v) {
  113.                     $namespaceVersionToClear = $v;
  114.                 }
  115.             }
  116.             $namespaceToClear = $rootNamespace.$namespaceVersionToClear;
  117.             $namespaceVersion = self::formatNamespaceVersion(mt_rand());
  118.             try {
  119.                 $e = $this->doSave([static::NS_SEPARATOR.$rootNamespace => $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.     public function withSubNamespace(string $namespace): static
  253.     {
  254.         $this->rootNamespace ??= $this->namespace;
  256.         $clone = clone $this;
  257.         $clone->namespace .= CacheItem::validateKey($namespace).static::NS_SEPARATOR;
  259.         return $clone;
  260.     }
  262.     /**
  263.      * Enables/disables versioning of items.
  264.      *
  265.      * When versioning is enabled, clearing the cache is atomic and doesn't require listing existing keys to proceed,
  266.      * but old keys may need garbage collection and extra round-trips to the back-end are required.
  267.      *
  268.      * Calling this method also clears the memoized namespace version and thus forces a resynchronization of it.
  269.      *
  270.      * @return bool the previous state of versioning
  271.      */
  272.     public function enableVersioning(bool $enable = true): bool
  273.     {
  274.         $wasEnabled = $this->versioningIsEnabled;
  275.         $this->versioningIsEnabled = $enable;
  276.         $this->namespaceVersion = '';
  277.         $this->ids = [];
  279.         return $wasEnabled;
  280.     }
  282.     public function reset(): void
  283.     {
  284.         if ($this->deferred) {
  285.             $this->commit();
  286.         }
  287.         $this->namespaceVersion = '';
  288.         $this->ids = [];
  289.     }
  291.     public function __serialize(): array
  292.     {
  293.         throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
  294.     }
  296.     public function __unserialize(array $data): void
  297.     {
  298.         throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
  299.     }
  301.     public function __destruct()
  302.     {
  303.         if ($this->deferred) {
  304.             $this->commit();
  305.         }
  306.     }
  308.     private function generateItems(iterable $items, array &$keys): \Generator
  309.     {
  310.         $f = self::$createCacheItem;
  312.         try {
  313.             foreach ($items as $id => $value) {
  314.                 if (!isset($keys[$id])) {
  315.                     throw new InvalidArgumentException(\sprintf('Could not match value id "%s" to keys "%s".', $id, implode('", "', $keys)));
  316.                 }
  317.                 $key = $keys[$id];
  318.                 unset($keys[$id]);
  319.                 yield $key => $f($key, $value, true);
  320.             }
  321.         } catch (\Exception $e) {
  322.             CacheItem::log($this->logger, 'Failed to fetch items: '.$e->getMessage(), ['keys' => array_values($keys), 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  323.         }
  325.         foreach ($keys as $key) {
  326.             yield $key => $f($key, null, false);
  327.         }
  328.     }
  330.     /**
  331.      * @internal
  332.      */
  333.     protected function getId(mixed $key, ?string $namespace = null): string
  334.     {
  335.         $namespace ??= $this->namespace;
  337.         if ('' !== $this->namespaceVersion) {
  338.             $namespace .= $this->namespaceVersion;
  339.         } elseif ($this->versioningIsEnabled) {
  340.             $rootNamespace = $this->rootNamespace ??= $this->namespace;
  341.             $this->ids = [];
  342.             $this->namespaceVersion = '1'.static::NS_SEPARATOR;
  343.             try {
  344.                 foreach ($this->doFetch([static::NS_SEPARATOR.$rootNamespace]) as $v) {
  345.                     $this->namespaceVersion = $v;
  346.                 }
  347.                 $e = true;
  348.                 if ('1'.static::NS_SEPARATOR === $this->namespaceVersion) {
  349.                     $this->namespaceVersion = self::formatNamespaceVersion(time());
  350.                     $e = $this->doSave([static::NS_SEPARATOR.$rootNamespace => $this->namespaceVersion], 0);
  351.                 }
  352.             } catch (\Exception $e) {
  353.             }
  354.             if (true !== $e && [] !== $e) {
  355.                 $message = 'Failed to save the new namespace'.($e instanceof \Exception ? ': '.$e->getMessage() : '.');
  356.                 CacheItem::log($this->logger, $message, ['exception' => $e instanceof \Exception ? $e : null, 'cache-adapter' => get_debug_type($this)]);
  357.             }
  359.             $namespace .= $this->namespaceVersion;
  360.         }
  362.         if (\is_string($key) && isset($this->ids[$key])) {
  363.             $id = $this->ids[$key];
  364.         } else {
  365.             \assert('' !== CacheItem::validateKey($key));
  366.             $this->ids[$key] = $key;
  368.             if (\count($this->ids) > 1000) {
  369.                 $this->ids = \array_slice($this->ids, 500, null, true); // stop memory leak if there are many keys
  370.             }
  372.             if (null === $this->maxIdLength) {
  373.                 return $namespace.$key;
  374.             }
  375.             if (\strlen($id = $namespace.$key) <= $this->maxIdLength) {
  376.                 return $id;
  377.             }
  379.             // Use xxh128 to favor speed over security, which is not an issue here
  380.             $this->ids[$key] = $id = substr_replace(base64_encode(hash('xxh128', $key, true)), static::NS_SEPARATOR, -(\strlen($this->namespaceVersion) + 2));
  381.         }
  382.         $id = $namespace.$id;
  384.         if (null !== $this->maxIdLength && \strlen($id) > $this->maxIdLength) {
  385.             return base64_encode(hash('xxh128', $id, true));
  386.         }
  388.         return $id;
  389.     }
  391.     /**
  392.      * @internal
  393.      */
  394.     public static function handleUnserializeCallback(string $class): never
  395.     {
  396.         throw new \DomainException('Class not found: '.$class);
  397.     }
  399.     private static function formatNamespaceVersion(int $value): string
  400.     {
  401.         return strtr(substr_replace(base64_encode(pack('V', $value)), static::NS_SEPARATOR, 5), '/', '_');
  402.     }
  403. }