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

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\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.     /**
  118.      * {@inheritdoc}
  119.      */
  120.     public function invalidateTags(array $tags): bool
  121.     {
  122.         $ids = [];
  123.         foreach ($tags as $tag) {
  124.             \assert('' !== CacheItem::validateKey($tag));
  125.             unset($this->knownTagVersions[$tag]);
  126.             $ids[] = $tag.static::TAGS_PREFIX;
  127.         }
  129.         return !$tags || $this->tags->deleteItems($ids);
  130.     }
  132.     /**
  133.      * {@inheritdoc}
  134.      */
  135.     public function hasItem(mixed $key): bool
  136.     {
  137.         return $this->getItem($key)->isHit();
  138.     }
  140.     /**
  141.      * {@inheritdoc}
  142.      */
  143.     public function getItem(mixed $key): CacheItem
  144.     {
  145.         foreach ($this->getItems([$key]) as $item) {
  146.             return $item;
  147.         }
  148.     }
  150.     /**
  151.      * {@inheritdoc}
  152.      */
  153.     public function getItems(array $keys = []): iterable
  154.     {
  155.         $tagKeys = [];
  156.         $commit = false;
  158.         foreach ($keys as $key) {
  159.             if ('' !== $key && \is_string($key)) {
  160.                 $commit = $commit || isset($this->deferred[$key]);
  161.                 $key = static::TAGS_PREFIX.$key;
  162.                 $tagKeys[$key] = $key; // BC with pools populated before v6.1
  163.             }
  164.         }
  166.         if ($commit) {
  167.             $this->commit();
  168.         }
  170.         try {
  171.             $items = $this->pool->getItems($tagKeys + $keys);
  172.         } catch (InvalidArgumentException $e) {
  173.             $this->pool->getItems($keys); // Should throw an exception
  175.             throw $e;
  176.         }
  178.         $bufferedItems = $itemTags = [];
  180.         foreach ($items as $key => $item) {
  181.             if (isset($tagKeys[$key])) { // BC with pools populated before v6.1
  182.                 if ($item->isHit()) {
  183.                     $itemTags[substr($key, \strlen(static::TAGS_PREFIX))] = $item->get() ?: [];
  184.                 }
  185.                 continue;
  186.             }
  188.             if (null !== $tags = $item->getMetadata()[CacheItem::METADATA_TAGS] ?? null) {
  189.                 $itemTags[$key] = $tags;
  190.             }
  192.             $bufferedItems[$key] = $item;
  193.         }
  195.         $tagVersions = $this->getTagVersions($itemTags, false);
  196.         foreach ($itemTags as $key => $tags) {
  197.             foreach ($tags as $tag => $version) {
  198.                 if ($tagVersions[$tag] !== $version) {
  199.                     unset($itemTags[$key]);
  200.                     continue 2;
  201.                 }
  202.             }
  203.         }
  204.         $tagVersions = null;
  206.         return (self::$setCacheItemTags)($bufferedItems, $itemTags);
  207.     }
  209.     /**
  210.      * {@inheritdoc}
  211.      */
  212.     public function clear(string $prefix = ''): bool
  213.     {
  214.         if ('' !== $prefix) {
  215.             foreach ($this->deferred as $key => $item) {
  216.                 if (str_starts_with($key, $prefix)) {
  217.                     unset($this->deferred[$key]);
  218.                 }
  219.             }
  220.         } else {
  221.             $this->deferred = [];
  222.         }
  224.         if ($this->pool instanceof AdapterInterface) {
  225.             return $this->pool->clear($prefix);
  226.         }
  228.         return $this->pool->clear();
  229.     }
  231.     /**
  232.      * {@inheritdoc}
  233.      */
  234.     public function deleteItem(mixed $key): bool
  235.     {
  236.         return $this->deleteItems([$key]);
  237.     }
  239.     /**
  240.      * {@inheritdoc}
  241.      */
  242.     public function deleteItems(array $keys): bool
  243.     {
  244.         foreach ($keys as $key) {
  245.             if ('' !== $key && \is_string($key)) {
  246.                 $keys[] = static::TAGS_PREFIX.$key; // BC with pools populated before v6.1
  247.             }
  248.         }
  250.         return $this->pool->deleteItems($keys);
  251.     }
  253.     /**
  254.      * {@inheritdoc}
  255.      */
  256.     public function save(CacheItemInterface $item): bool
  257.     {
  258.         if (!$item instanceof CacheItem) {
  259.             return false;
  260.         }
  261.         $this->deferred[$item->getKey()] = $item;
  263.         return $this->commit();
  264.     }
  266.     /**
  267.      * {@inheritdoc}
  268.      */
  269.     public function saveDeferred(CacheItemInterface $item): bool
  270.     {
  271.         if (!$item instanceof CacheItem) {
  272.             return false;
  273.         }
  274.         $this->deferred[$item->getKey()] = $item;
  276.         return true;
  277.     }
  279.     /**
  280.      * {@inheritdoc}
  281.      */
  282.     public function commit(): bool
  283.     {
  284.         if (!$items = $this->deferred) {
  285.             return true;
  286.         }
  288.         $tagVersions = $this->getTagVersions((self::$getTagsByKey)($items), true);
  289.         (self::$setTagVersions)($items, $tagVersions);
  291.         $ok = true;
  292.         foreach ($items as $key => $item) {
  293.             if ($this->pool->saveDeferred($item)) {
  294.                 unset($this->deferred[$key]);
  295.             } else {
  296.                 $ok = false;
  297.             }
  298.         }
  299.         $ok = $this->pool->commit() && $ok;
  301.         $tagVersions = array_keys($tagVersions);
  302.         (self::$setTagVersions)($items, array_combine($tagVersions, $tagVersions));
  304.         return $ok;
  305.     }
  307.     /**
  308.      * {@inheritdoc}
  309.      */
  310.     public function prune(): bool
  311.     {
  312.         return $this->pool instanceof PruneableInterface && $this->pool->prune();
  313.     }
  315.     /**
  316.      * {@inheritdoc}
  317.      */
  318.     public function reset()
  319.     {
  320.         $this->commit();
  321.         $this->knownTagVersions = [];
  322.         $this->pool instanceof ResettableInterface && $this->pool->reset();
  323.         $this->tags instanceof ResettableInterface && $this->tags->reset();
  324.     }
  326.     public function __sleep(): array
  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.         $this->commit();
  339.     }
  341.     private function getTagVersions(array $tagsByKey, bool $persistTags): array
  342.     {
  343.         $tagVersions = [];
  344.         $fetchTagVersions = $persistTags;
  346.         foreach ($tagsByKey as $tags) {
  347.             $tagVersions += $tags;
  348.             if ($fetchTagVersions) {
  349.                 continue;
  350.             }
  351.             foreach ($tags as $tag => $version) {
  352.                 if ($tagVersions[$tag] !== $version) {
  353.                     $fetchTagVersions = true;
  354.                 }
  355.             }
  356.         }
  358.         if (!$tagVersions) {
  359.             return [];
  360.         }
  362.         $now = microtime(true);
  363.         $tags = [];
  364.         foreach ($tagVersions as $tag => $version) {
  365.             $tags[$tag.static::TAGS_PREFIX] = $tag;
  366.             $knownTagVersion = $this->knownTagVersions[$tag] ?? [0, null];
  367.             if ($fetchTagVersions || $now > $knownTagVersion[0] || $knownTagVersion[1] !== $version) {
  368.                 // reuse previously fetched tag versions until the expiration
  369.                 $fetchTagVersions = true;
  370.             }
  371.         }
  373.         if (!$fetchTagVersions) {
  374.             return $tagVersions;
  375.         }
  377.         $newTags = [];
  378.         $newVersion = null;
  379.         $expiration = $now + $this->knownTagVersionsTtl;
  380.         foreach ($this->tags->getItems(array_keys($tags)) as $tag => $version) {
  381.             unset($this->knownTagVersions[$tag = $tags[$tag]]); // update FIFO
  382.             if (null !== $tagVersions[$tag] = $version->get()) {
  383.                 $this->knownTagVersions[$tag] = [$expiration, $tagVersions[$tag]];
  384.             } elseif ($persistTags) {
  385.                 $newTags[$tag] = $version->set($newVersion ??= random_bytes(6));
  386.                 $tagVersions[$tag] = $newVersion;
  387.                 $this->knownTagVersions[$tag] = [$expiration, $newVersion];
  388.             }
  389.         }
  391.         if ($newTags) {
  392.             (self::$saveTags)($this->tags, $newTags);
  393.         }
  395.         while ($now > ($this->knownTagVersions[$tag = array_key_first($this->knownTagVersions)][0] ?? \INF)) {
  396.             unset($this->knownTagVersions[$tag]);
  397.         }
  399.         return $tagVersions;
  400.     }
  401. }