vendor/symfony/cache/Adapter/TagAwareAdapter.php line 54

  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\Adapter;
  14. use Psr\Cache\CacheItemInterface;
  15. use Psr\Cache\InvalidArgumentException;
  16. use Psr\Log\LoggerAwareInterface;
  17. use Psr\Log\LoggerAwareTrait;
  18. use Symfony\Component\Cache\CacheItem;
  19. use Symfony\Component\Cache\PruneableInterface;
  20. use Symfony\Component\Cache\ResettableInterface;
  21. use Symfony\Component\Cache\Traits\ContractsTrait;
  22. use Symfony\Contracts\Cache\TagAwareCacheInterface;
  24. /**
  25.  * Implements simple and robust tag-based invalidation suitable for use with volatile caches.
  26.  *
  27.  * This adapter works by storing a version for each tags. When saving an item, it is stored together with its tags and
  28.  * their corresponding versions. When retrieving an item, those tag versions are compared to the current version of
  29.  * each tags. Invalidation is achieved by deleting tags, thereby ensuring that their versions change even when the
  30.  * storage is out of space. When versions of non-existing tags are requested for item commits, this adapter assigns a
  31.  * new random version to them.
  32.  *
  33.  * @author Nicolas Grekas <p@tchwork.com>
  34.  * @author Sergey Belyshkin <sbelyshkin@gmail.com>
  35.  */
  36. class TagAwareAdapter implements TagAwareAdapterInterface, TagAwareCacheInterface, PruneableInterface, ResettableInterface, LoggerAwareInterface
  37. {
  38.     use ContractsTrait;
  39.     use LoggerAwareTrait;
  41.     public const TAGS_PREFIX = "\0tags\0";
  43.     private array $deferred = [];
  44.     private AdapterInterface $pool;
  45.     private AdapterInterface $tags;
  46.     private array $knownTagVersions = [];
  47.     private float $knownTagVersionsTtl;
  49.     private static \Closure $setCacheItemTags;
  50.     private static \Closure $setTagVersions;
  51.     private static \Closure $getTagsByKey;
  52.     private static \Closure $saveTags;
  54.     public function __construct(AdapterInterface $itemsPool, AdapterInterface $tagsPool = null, float $knownTagVersionsTtl = 0.15)
  55.     {
  56.         $this->pool = $itemsPool;
  57.         $this->tags = $tagsPool ?? $itemsPool;
  58.         $this->knownTagVersionsTtl = $knownTagVersionsTtl;
  59.         self::$setCacheItemTags ??= \Closure::bind(
  60.             static function (array $items, array $itemTags) {
  61.                 foreach ($items as $key => $item) {
  62.                     $item->isTaggable = true;
  64.                     if (isset($itemTags[$key])) {
  65.                         $tags = array_keys($itemTags[$key]);
  66.                         $item->metadata[CacheItem::METADATA_TAGS] = array_combine($tags, $tags);
  67.                     } else {
  68.                         $item->value = null;
  69.                         $item->isHit = false;
  70.                         $item->metadata = [];
  71.                     }
  72.                 }
  74.                 return $items;
  75.             },
  76.             null,
  77.             CacheItem::class
  78.         );
  79.         self::$setTagVersions ??= \Closure::bind(
  80.             static function (array $items, array $tagVersions) {
  81.                 foreach ($items as $item) {
  82.                     $item->newMetadata[CacheItem::METADATA_TAGS] = array_intersect_key($tagVersions, $item->newMetadata[CacheItem::METADATA_TAGS] ?? []);
  83.                 }
  84.             },
  85.             null,
  86.             CacheItem::class
  87.         );
  88.         self::$getTagsByKey ??= \Closure::bind(
  89.             static function ($deferred) {
  90.                 $tagsByKey = [];
  91.                 foreach ($deferred as $key => $item) {
  92.                     $tagsByKey[$key] = $item->newMetadata[CacheItem::METADATA_TAGS] ?? [];
  93.                     $item->metadata = $item->newMetadata;
  94.                 }
  96.                 return $tagsByKey;
  97.             },
  98.             null,
  99.             CacheItem::class
  100.         );
  101.         self::$saveTags ??= \Closure::bind(
  102.             static function (AdapterInterface $tagsAdapter, array $tags) {
  103.                 ksort($tags);
  105.                 foreach ($tags as $v) {
  106.                     $v->expiry = 0;
  107.                     $tagsAdapter->saveDeferred($v);
  108.                 }
  110.                 return $tagsAdapter->commit();
  111.             },
  112.             null,
  113.             CacheItem::class
  114.         );
  115.     }
  117.     public function invalidateTags(array $tags): bool
  118.     {
  119.         $ids = [];
  120.         foreach ($tags as $tag) {
  121.             \assert('' !== CacheItem::validateKey($tag));
  122.             unset($this->knownTagVersions[$tag]);
  123.             $ids[] = $tag.static::TAGS_PREFIX;
  124.         }
  126.         return !$tags || $this->tags->deleteItems($ids);
  127.     }
  129.     public function hasItem(mixed $key): bool
  130.     {
  131.         return $this->getItem($key)->isHit();
  132.     }
  134.     public function getItem(mixed $key): CacheItem
  135.     {
  136.         foreach ($this->getItems([$key]) as $item) {
  137.             return $item;
  138.         }
  139.     }
  141.     public function getItems(array $keys = []): iterable
  142.     {
  143.         $tagKeys = [];
  144.         $commit = false;
  146.         foreach ($keys as $key) {
  147.             if ('' !== $key && \is_string($key)) {
  148.                 $commit = $commit || isset($this->deferred[$key]);
  149.                 $key = static::TAGS_PREFIX.$key;
  150.                 $tagKeys[$key] = $key; // BC with pools populated before v6.1
  151.             }
  152.         }
  154.         if ($commit) {
  155.             $this->commit();
  156.         }
  158.         try {
  159.             $items = $this->pool->getItems($tagKeys + $keys);
  160.         } catch (InvalidArgumentException $e) {
  161.             $this->pool->getItems($keys); // Should throw an exception
  163.             throw $e;
  164.         }
  166.         $bufferedItems = $itemTags = [];
  168.         foreach ($items as $key => $item) {
  169.             if (isset($tagKeys[$key])) { // BC with pools populated before v6.1
  170.                 if ($item->isHit()) {
  171.                     $itemTags[substr($key, \strlen(static::TAGS_PREFIX))] = $item->get() ?: [];
  172.                 }
  173.                 continue;
  174.             }
  176.             if (null !== $tags = $item->getMetadata()[CacheItem::METADATA_TAGS] ?? null) {
  177.                 $itemTags[$key] = $tags;
  178.             }
  180.             $bufferedItems[$key] = $item;
  181.         }
  183.         $tagVersions = $this->getTagVersions($itemTags, false);
  184.         foreach ($itemTags as $key => $tags) {
  185.             foreach ($tags as $tag => $version) {
  186.                 if ($tagVersions[$tag] !== $version) {
  187.                     unset($itemTags[$key]);
  188.                     continue 2;
  189.                 }
  190.             }
  191.         }
  192.         $tagVersions = null;
  194.         return (self::$setCacheItemTags)($bufferedItems, $itemTags);
  195.     }
  197.     public function clear(string $prefix = ''): bool
  198.     {
  199.         if ('' !== $prefix) {
  200.             foreach ($this->deferred as $key => $item) {
  201.                 if (str_starts_with($key, $prefix)) {
  202.                     unset($this->deferred[$key]);
  203.                 }
  204.             }
  205.         } else {
  206.             $this->deferred = [];
  207.         }
  209.         if ($this->pool instanceof AdapterInterface) {
  210.             return $this->pool->clear($prefix);
  211.         }
  213.         return $this->pool->clear();
  214.     }
  216.     public function deleteItem(mixed $key): bool
  217.     {
  218.         return $this->deleteItems([$key]);
  219.     }
  221.     public function deleteItems(array $keys): bool
  222.     {
  223.         foreach ($keys as $key) {
  224.             if ('' !== $key && \is_string($key)) {
  225.                 $keys[] = static::TAGS_PREFIX.$key; // BC with pools populated before v6.1
  226.             }
  227.         }
  229.         return $this->pool->deleteItems($keys);
  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 commit(): bool
  253.     {
  254.         if (!$items = $this->deferred) {
  255.             return true;
  256.         }
  258.         $tagVersions = $this->getTagVersions((self::$getTagsByKey)($items), true);
  259.         (self::$setTagVersions)($items, $tagVersions);
  261.         $ok = true;
  262.         foreach ($items as $key => $item) {
  263.             if ($this->pool->saveDeferred($item)) {
  264.                 unset($this->deferred[$key]);
  265.             } else {
  266.                 $ok = false;
  267.             }
  268.         }
  269.         $ok = $this->pool->commit() && $ok;
  271.         $tagVersions = array_keys($tagVersions);
  272.         (self::$setTagVersions)($items, array_combine($tagVersions, $tagVersions));
  274.         return $ok;
  275.     }
  277.     public function prune(): bool
  278.     {
  279.         return $this->pool instanceof PruneableInterface && $this->pool->prune();
  280.     }
  282.     public function reset()
  283.     {
  284.         $this->commit();
  285.         $this->knownTagVersions = [];
  286.         $this->pool instanceof ResettableInterface && $this->pool->reset();
  287.         $this->tags instanceof ResettableInterface && $this->tags->reset();
  288.     }
  290.     public function __sleep(): array
  291.     {
  292.         throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
  293.     }
  295.     public function __wakeup()
  296.     {
  297.         throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
  298.     }
  300.     public function __destruct()
  301.     {
  302.         $this->commit();
  303.     }
  305.     private function getTagVersions(array $tagsByKey, bool $persistTags): array
  306.     {
  307.         $tagVersions = [];
  308.         $fetchTagVersions = $persistTags;
  310.         foreach ($tagsByKey as $tags) {
  311.             $tagVersions += $tags;
  312.             if ($fetchTagVersions) {
  313.                 continue;
  314.             }
  315.             foreach ($tags as $tag => $version) {
  316.                 if ($tagVersions[$tag] !== $version) {
  317.                     $fetchTagVersions = true;
  318.                 }
  319.             }
  320.         }
  322.         if (!$tagVersions) {
  323.             return [];
  324.         }
  326.         $now = microtime(true);
  327.         $tags = [];
  328.         foreach ($tagVersions as $tag => $version) {
  329.             $tags[$tag.static::TAGS_PREFIX] = $tag;
  330.             $knownTagVersion = $this->knownTagVersions[$tag] ?? [0, null];
  331.             if ($fetchTagVersions || $now > $knownTagVersion[0] || $knownTagVersion[1] !== $version) {
  332.                 // reuse previously fetched tag versions until the expiration
  333.                 $fetchTagVersions = true;
  334.             }
  335.         }
  337.         if (!$fetchTagVersions) {
  338.             return $tagVersions;
  339.         }
  341.         $newTags = [];
  342.         $newVersion = null;
  343.         $expiration = $now + $this->knownTagVersionsTtl;
  344.         foreach ($this->tags->getItems(array_keys($tags)) as $tag => $version) {
  345.             unset($this->knownTagVersions[$tag = $tags[$tag]]); // update FIFO
  346.             if (null !== $tagVersions[$tag] = $version->get()) {
  347.                 $this->knownTagVersions[$tag] = [$expiration, $tagVersions[$tag]];
  348.             } elseif ($persistTags) {
  349.                 $newTags[$tag] = $version->set($newVersion ??= random_bytes(6));
  350.                 $tagVersions[$tag] = $newVersion;
  351.                 $this->knownTagVersions[$tag] = [$expiration, $newVersion];
  352.             }
  353.         }
  355.         if ($newTags) {
  356.             (self::$saveTags)($this->tags, $newTags);
  357.         }
  359.         while ($now > ($this->knownTagVersions[$tag = array_key_first($this->knownTagVersions)][0] ?? \INF)) {
  360.             unset($this->knownTagVersions[$tag]);
  361.         }
  363.         return $tagVersions;
  364.     }
  365. }