vendor/symfony/cache/Adapter/AbstractTagAwareAdapter.php line 186

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\Log\LoggerAwareInterface;
  15. use Symfony\Component\Cache\CacheItem;
  16. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  17. use Symfony\Component\Cache\ResettableInterface;
  18. use Symfony\Component\Cache\Traits\AbstractAdapterTrait;
  19. use Symfony\Component\Cache\Traits\ContractsTrait;
  20. use Symfony\Contracts\Cache\TagAwareCacheInterface;
  22. /**
  23.  * Abstract for native TagAware adapters.
  24.  *
  25.  * To keep info on tags, the tags are both serialized as part of cache value and provided as tag ids
  26.  * to Adapters on operations when needed for storage to doSave(), doDelete() & doInvalidate().
  27.  *
  28.  * @author Nicolas Grekas <p@tchwork.com>
  29.  * @author André Rømcke <andre.romcke+symfony@gmail.com>
  30.  *
  31.  * @internal
  32.  */
  33. abstract class AbstractTagAwareAdapter implements TagAwareAdapterInterface, TagAwareCacheInterface, LoggerAwareInterface, ResettableInterface
  34. {
  35.     use AbstractAdapterTrait;
  36.     use ContractsTrait;
  38.     private const TAGS_PREFIX = "\1tags\1";
  40.     protected function __construct(string $namespace = '', int $defaultLifetime = 0)
  41.     {
  42.         $this->namespace = '' === $namespace ? '' : CacheItem::validateKey($namespace).':';
  43.         $this->defaultLifetime = $defaultLifetime;
  44.         if (null !== $this->maxIdLength && \strlen($namespace) > $this->maxIdLength - 24) {
  45.             throw new InvalidArgumentException(sprintf('Namespace must be %d chars max, %d given ("%s").', $this->maxIdLength - 24, \strlen($namespace), $namespace));
  46.         }
  47.         self::$createCacheItem ??= \Closure::bind(
  48.             static function ($key, $value, $isHit) {
  49.                 $item = new CacheItem();
  50.                 $item->key = $key;
  51.                 $item->isTaggable = true;
  52.                 // If structure does not match what we expect return item as is (no value and not a hit)
  53.                 if (!\is_array($value) || !\array_key_exists('value', $value)) {
  54.                     return $item;
  55.                 }
  56.                 $item->isHit = $isHit;
  57.                 // Extract value, tags and meta data from the cache value
  58.                 $item->value = $value['value'];
  59.                 $item->metadata[CacheItem::METADATA_TAGS] = isset($value['tags']) ? array_combine($value['tags'], $value['tags']) : [];
  60.                 if (isset($value['meta'])) {
  61.                     // For compactness these values are packed, & expiry is offset to reduce size
  62.                     $v = unpack('Ve/Nc', $value['meta']);
  63.                     $item->metadata[CacheItem::METADATA_EXPIRY] = $v['e'] + CacheItem::METADATA_EXPIRY_OFFSET;
  64.                     $item->metadata[CacheItem::METADATA_CTIME] = $v['c'];
  65.                 }
  67.                 return $item;
  68.             },
  69.             null,
  70.             CacheItem::class
  71.         );
  72.         self::$mergeByLifetime ??= \Closure::bind(
  73.             static function ($deferred, &$expiredIds, $getId, $tagPrefix, $defaultLifetime) {
  74.                 $byLifetime = [];
  75.                 $now = microtime(true);
  76.                 $expiredIds = [];
  78.                 foreach ($deferred as $key => $item) {
  79.                     $key = (string) $key;
  80.                     if (null === $item->expiry) {
  81.                         $ttl = 0 < $defaultLifetime ? $defaultLifetime : 0;
  82.                     } elseif (!$item->expiry) {
  83.                         $ttl = 0;
  84.                     } elseif (0 >= $ttl = (int) (0.1 + $item->expiry - $now)) {
  85.                         $expiredIds[] = $getId($key);
  86.                         continue;
  87.                     }
  88.                     // Store Value and Tags on the cache value
  89.                     if (isset(($metadata = $item->newMetadata)[CacheItem::METADATA_TAGS])) {
  90.                         $value = ['value' => $item->value, 'tags' => $metadata[CacheItem::METADATA_TAGS]];
  91.                         unset($metadata[CacheItem::METADATA_TAGS]);
  92.                     } else {
  93.                         $value = ['value' => $item->value, 'tags' => []];
  94.                     }
  96.                     if ($metadata) {
  97.                         // For compactness, expiry and creation duration are packed, using magic numbers as separators
  98.                         $value['meta'] = pack('VN', (int) (0.1 + $metadata[CacheItem::METADATA_EXPIRY] - CacheItem::METADATA_EXPIRY_OFFSET), $metadata[CacheItem::METADATA_CTIME]);
  99.                     }
  101.                     // Extract tag changes, these should be removed from values in doSave()
  102.                     $value['tag-operations'] = ['add' => [], 'remove' => []];
  103.                     $oldTags = $item->metadata[CacheItem::METADATA_TAGS] ?? [];
  104.                     foreach (array_diff_key($value['tags'], $oldTags) as $addedTag) {
  105.                         $value['tag-operations']['add'][] = $getId($tagPrefix.$addedTag);
  106.                     }
  107.                     foreach (array_diff_key($oldTags, $value['tags']) as $removedTag) {
  108.                         $value['tag-operations']['remove'][] = $getId($tagPrefix.$removedTag);
  109.                     }
  110.                     $value['tags'] = array_keys($value['tags']);
  112.                     $byLifetime[$ttl][$getId($key)] = $value;
  113.                     $item->metadata = $item->newMetadata;
  114.                 }
  116.                 return $byLifetime;
  117.             },
  118.             null,
  119.             CacheItem::class
  120.         );
  121.     }
  123.     /**
  124.      * Persists several cache items immediately.
  125.      *
  126.      * @param array   $values        The values to cache, indexed by their cache identifier
  127.      * @param int     $lifetime      The lifetime of the cached values, 0 for persisting until manual cleaning
  128.      * @param array[] $addTagData    Hash where key is tag id, and array value is list of cache id's to add to tag
  129.      * @param array[] $removeTagData Hash where key is tag id, and array value is list of cache id's to remove to tag
  130.      *
  131.      * @return array The identifiers that failed to be cached or a boolean stating if caching succeeded or not
  132.      */
  133.     abstract protected function doSave(array $values, int $lifetime, array $addTagData = [], array $removeTagData = []): array;
  135.     /**
  136.      * Removes multiple items from the pool and their corresponding tags.
  137.      *
  138.      * @param array $ids An array of identifiers that should be removed from the pool
  139.      */
  140.     abstract protected function doDelete(array $ids): bool;
  142.     /**
  143.      * Removes relations between tags and deleted items.
  144.      *
  145.      * @param array $tagData Array of tag => key identifiers that should be removed from the pool
  146.      */
  147.     abstract protected function doDeleteTagRelations(array $tagData): bool;
  149.     /**
  150.      * Invalidates cached items using tags.
  151.      *
  152.      * @param string[] $tagIds An array of tags to invalidate, key is tag and value is tag id
  153.      */
  154.     abstract protected function doInvalidate(array $tagIds): bool;
  156.     /**
  157.      * Delete items and yields the tags they were bound to.
  158.      */
  159.     protected function doDeleteYieldTags(array $ids): iterable
  160.     {
  161.         foreach ($this->doFetch($ids) as $id => $value) {
  162.             yield $id => \is_array($value) && \is_array($value['tags'] ?? null) ? $value['tags'] : [];
  163.         }
  165.         $this->doDelete($ids);
  166.     }
  168.     public function commit(): bool
  169.     {
  170.         $ok = true;
  171.         $byLifetime = (self::$mergeByLifetime)($this->deferred, $expiredIds, $this->getId(...), self::TAGS_PREFIX, $this->defaultLifetime);
  172.         $retry = $this->deferred = [];
  174.         if ($expiredIds) {
  175.             // Tags are not cleaned up in this case, however that is done on invalidateTags().
  176.             try {
  177.                 $this->doDelete($expiredIds);
  178.             } catch (\Exception $e) {
  179.                 $ok = false;
  180.                 CacheItem::log($this->logger, 'Failed to delete expired items: '.$e->getMessage(), ['exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  181.             }
  182.         }
  183.         foreach ($byLifetime as $lifetime => $values) {
  184.             try {
  185.                 $values = $this->extractTagData($values, $addTagData, $removeTagData);
  186.                 $e = $this->doSave($values, $lifetime, $addTagData, $removeTagData);
  187.             } catch (\Exception $e) {
  188.             }
  189.             if (true === $e || [] === $e) {
  190.                 continue;
  191.             }
  192.             if (\is_array($e) || 1 === \count($values)) {
  193.                 foreach (\is_array($e) ? $e : array_keys($values) as $id) {
  194.                     $ok = false;
  195.                     $v = $values[$id];
  196.                     $type = get_debug_type($v);
  197.                     $message = sprintf('Failed to save key "{key}" of type %s%s', $type, $e instanceof \Exception ? ': '.$e->getMessage() : '.');
  198.                     CacheItem::log($this->logger, $message, ['key' => substr($id, \strlen($this->namespace)), 'exception' => $e instanceof \Exception ? $e : null, 'cache-adapter' => get_debug_type($this)]);
  199.                 }
  200.             } else {
  201.                 foreach ($values as $id => $v) {
  202.                     $retry[$lifetime][] = $id;
  203.                 }
  204.             }
  205.         }
  207.         // When bulk-save failed, retry each item individually
  208.         foreach ($retry as $lifetime => $ids) {
  209.             foreach ($ids as $id) {
  210.                 try {
  211.                     $v = $byLifetime[$lifetime][$id];
  212.                     $values = $this->extractTagData([$id => $v], $addTagData, $removeTagData);
  213.                     $e = $this->doSave($values, $lifetime, $addTagData, $removeTagData);
  214.                 } catch (\Exception $e) {
  215.                 }
  216.                 if (true === $e || [] === $e) {
  217.                     continue;
  218.                 }
  219.                 $ok = false;
  220.                 $type = get_debug_type($v);
  221.                 $message = sprintf('Failed to save key "{key}" of type %s%s', $type, $e instanceof \Exception ? ': '.$e->getMessage() : '.');
  222.                 CacheItem::log($this->logger, $message, ['key' => substr($id, \strlen($this->namespace)), 'exception' => $e instanceof \Exception ? $e : null, 'cache-adapter' => get_debug_type($this)]);
  223.             }
  224.         }
  226.         return $ok;
  227.     }
  229.     public function deleteItems(array $keys): bool
  230.     {
  231.         if (!$keys) {
  232.             return true;
  233.         }
  235.         $ok = true;
  236.         $ids = [];
  237.         $tagData = [];
  239.         foreach ($keys as $key) {
  240.             $ids[$key] = $this->getId($key);
  241.             unset($this->deferred[$key]);
  242.         }
  244.         try {
  245.             foreach ($this->doDeleteYieldTags(array_values($ids)) as $id => $tags) {
  246.                 foreach ($tags as $tag) {
  247.                     $tagData[$this->getId(self::TAGS_PREFIX.$tag)][] = $id;
  248.                 }
  249.             }
  250.         } catch (\Exception) {
  251.             $ok = false;
  252.         }
  254.         try {
  255.             if ((!$tagData || $this->doDeleteTagRelations($tagData)) && $ok) {
  256.                 return true;
  257.             }
  258.         } catch (\Exception) {
  259.         }
  261.         // When bulk-delete failed, retry each item individually
  262.         foreach ($ids as $key => $id) {
  263.             try {
  264.                 $e = null;
  265.                 if ($this->doDelete([$id])) {
  266.                     continue;
  267.                 }
  268.             } catch (\Exception $e) {
  269.             }
  270.             $message = 'Failed to delete key "{key}"'.($e instanceof \Exception ? ': '.$e->getMessage() : '.');
  271.             CacheItem::log($this->logger, $message, ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  272.             $ok = false;
  273.         }
  275.         return $ok;
  276.     }
  278.     public function invalidateTags(array $tags): bool
  279.     {
  280.         if (!$tags) {
  281.             return false;
  282.         }
  284.         $tagIds = [];
  285.         foreach (array_unique($tags) as $tag) {
  286.             $tagIds[] = $this->getId(self::TAGS_PREFIX.$tag);
  287.         }
  289.         try {
  290.             if ($this->doInvalidate($tagIds)) {
  291.                 return true;
  292.             }
  293.         } catch (\Exception $e) {
  294.             CacheItem::log($this->logger, 'Failed to invalidate tags: '.$e->getMessage(), ['exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  295.         }
  297.         return false;
  298.     }
  300.     /**
  301.      * Extracts tags operation data from $values set in mergeByLifetime, and returns values without it.
  302.      */
  303.     private function extractTagData(array $values, ?array &$addTagData, ?array &$removeTagData): array
  304.     {
  305.         $addTagData = $removeTagData = [];
  306.         foreach ($values as $id => $value) {
  307.             foreach ($value['tag-operations']['add'] as $tag => $tagId) {
  308.                 $addTagData[$tagId][] = $id;
  309.             }
  311.             foreach ($value['tag-operations']['remove'] as $tag => $tagId) {
  312.                 $removeTagData[$tagId][] = $id;
  313.             }
  315.             unset($values[$id]['tag-operations']);
  316.         }
  318.         return $values;
  319.     }
  320. }