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

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <[email protected]>
  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 <[email protected]>
  29.  * @author André Rømcke <[email protected]>
  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 = "\0tags\0";
  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 ?? 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] = $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 ?? 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[self::METADATA_EXPIRY] - self::METADATA_EXPIRY_OFFSET), $metadata[self::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($value['tags'], $oldTags) as $addedTag) {
  105.                         $value['tag-operations']['add'][] = $getId($tagPrefix.$addedTag);
  106.                     }
  107.                     foreach (array_diff($oldTags, $value['tags']) as $removedTag) {
  108.                         $value['tag-operations']['remove'][] = $getId($tagPrefix.$removedTag);
  109.                     }
  111.                     $byLifetime[$ttl][$getId($key)] = $value;
  112.                     $item->metadata = $item->newMetadata;
  113.                 }
  115.                 return $byLifetime;
  116.             },
  117.             null,
  118.             CacheItem::class
  119.         );
  120.     }
  122.     /**
  123.      * Persists several cache items immediately.
  124.      *
  125.      * @param array   $values        The values to cache, indexed by their cache identifier
  126.      * @param int     $lifetime      The lifetime of the cached values, 0 for persisting until manual cleaning
  127.      * @param array[] $addTagData    Hash where key is tag id, and array value is list of cache id's to add to tag
  128.      * @param array[] $removeTagData Hash where key is tag id, and array value is list of cache id's to remove to tag
  129.      *
  130.      * @return array The identifiers that failed to be cached or a boolean stating if caching succeeded or not
  131.      */
  132.     abstract protected function doSave(array $values, int $lifetime, array $addTagData = [], array $removeTagData = []): array;
  134.     /**
  135.      * Removes multiple items from the pool and their corresponding tags.
  136.      *
  137.      * @param array $ids An array of identifiers that should be removed from the pool
  138.      *
  139.      * @return bool
  140.      */
  141.     abstract protected function doDelete(array $ids);
  143.     /**
  144.      * Removes relations between tags and deleted items.
  145.      *
  146.      * @param array $tagData Array of tag => key identifiers that should be removed from the pool
  147.      */
  148.     abstract protected function doDeleteTagRelations(array $tagData): bool;
  150.     /**
  151.      * Invalidates cached items using tags.
  152.      *
  153.      * @param string[] $tagIds An array of tags to invalidate, key is tag and value is tag id
  154.      */
  155.     abstract protected function doInvalidate(array $tagIds): bool;
  157.     /**
  158.      * Delete items and yields the tags they were bound to.
  159.      */
  160.     protected function doDeleteYieldTags(array $ids): iterable
  161.     {
  162.         foreach ($this->doFetch($ids) as $id => $value) {
  163.             yield $id => \is_array($value) && \is_array($value['tags'] ?? null) ? $value['tags'] : [];
  164.         }
  166.         $this->doDelete($ids);
  167.     }
  169.     /**
  170.      * {@inheritdoc}
  171.      */
  172.     public function commit(): bool
  173.     {
  174.         $ok = true;
  175.         $byLifetime = (self::$mergeByLifetime)($this->deferred, $expiredIds, \Closure::fromCallable([$this, 'getId']), self::TAGS_PREFIX, $this->defaultLifetime);
  176.         $retry = $this->deferred = [];
  178.         if ($expiredIds) {
  179.             // Tags are not cleaned up in this case, however that is done on invalidateTags().
  180.             try {
  181.                 $this->doDelete($expiredIds);
  182.             } catch (\Exception $e) {
  183.                 $ok = false;
  184.                 CacheItem::log($this->logger, 'Failed to delete expired items: '.$e->getMessage(), ['exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  185.             }
  186.         }
  187.         foreach ($byLifetime as $lifetime => $values) {
  188.             try {
  189.                 $values = $this->extractTagData($values, $addTagData, $removeTagData);
  190.                 $e = $this->doSave($values, $lifetime, $addTagData, $removeTagData);
  191.             } catch (\Exception $e) {
  192.             }
  193.             if (true === $e || [] === $e) {
  194.                 continue;
  195.             }
  196.             if (\is_array($e) || 1 === \count($values)) {
  197.                 foreach (\is_array($e) ? $e : array_keys($values) as $id) {
  198.                     $ok = false;
  199.                     $v = $values[$id];
  200.                     $type = get_debug_type($v);
  201.                     $message = sprintf('Failed to save key "{key}" of type %s%s', $type, $e instanceof \Exception ? ': '.$e->getMessage() : '.');
  202.                     CacheItem::log($this->logger, $message, ['key' => substr($id, \strlen($this->namespace)), 'exception' => $e instanceof \Exception ? $e : null, 'cache-adapter' => get_debug_type($this)]);
  203.                 }
  204.             } else {
  205.                 foreach ($values as $id => $v) {
  206.                     $retry[$lifetime][] = $id;
  207.                 }
  208.             }
  209.         }
  211.         // When bulk-save failed, retry each item individually
  212.         foreach ($retry as $lifetime => $ids) {
  213.             foreach ($ids as $id) {
  214.                 try {
  215.                     $v = $byLifetime[$lifetime][$id];
  216.                     $values = $this->extractTagData([$id => $v], $addTagData, $removeTagData);
  217.                     $e = $this->doSave($values, $lifetime, $addTagData, $removeTagData);
  218.                 } catch (\Exception $e) {
  219.                 }
  220.                 if (true === $e || [] === $e) {
  221.                     continue;
  222.                 }
  223.                 $ok = false;
  224.                 $type = get_debug_type($v);
  225.                 $message = sprintf('Failed to save key "{key}" of type %s%s', $type, $e instanceof \Exception ? ': '.$e->getMessage() : '.');
  226.                 CacheItem::log($this->logger, $message, ['key' => substr($id, \strlen($this->namespace)), 'exception' => $e instanceof \Exception ? $e : null, 'cache-adapter' => get_debug_type($this)]);
  227.             }
  228.         }
  230.         return $ok;
  231.     }
  233.     /**
  234.      * {@inheritdoc}
  235.      */
  236.     public function deleteItems(array $keys): bool
  237.     {
  238.         if (!$keys) {
  239.             return true;
  240.         }
  242.         $ok = true;
  243.         $ids = [];
  244.         $tagData = [];
  246.         foreach ($keys as $key) {
  247.             $ids[$key] = $this->getId($key);
  248.             unset($this->deferred[$key]);
  249.         }
  251.         try {
  252.             foreach ($this->doDeleteYieldTags(array_values($ids)) as $id => $tags) {
  253.                 foreach ($tags as $tag) {
  254.                     $tagData[$this->getId(self::TAGS_PREFIX.$tag)][] = $id;
  255.                 }
  256.             }
  257.         } catch (\Exception $e) {
  258.             $ok = false;
  259.         }
  261.         try {
  262.             if ((!$tagData || $this->doDeleteTagRelations($tagData)) && $ok) {
  263.                 return true;
  264.             }
  265.         } catch (\Exception $e) {
  266.         }
  268.         // When bulk-delete failed, retry each item individually
  269.         foreach ($ids as $key => $id) {
  270.             try {
  271.                 $e = null;
  272.                 if ($this->doDelete([$id])) {
  273.                     continue;
  274.                 }
  275.             } catch (\Exception $e) {
  276.             }
  277.             $message = 'Failed to delete key "{key}"'.($e instanceof \Exception ? ': '.$e->getMessage() : '.');
  278.             CacheItem::log($this->logger, $message, ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  279.             $ok = false;
  280.         }
  282.         return $ok;
  283.     }
  285.     /**
  286.      * {@inheritdoc}
  287.      */
  288.     public function invalidateTags(array $tags)
  289.     {
  290.         if (empty($tags)) {
  291.             return false;
  292.         }
  294.         $tagIds = [];
  295.         foreach (array_unique($tags) as $tag) {
  296.             $tagIds[] = $this->getId(self::TAGS_PREFIX.$tag);
  297.         }
  299.         try {
  300.             if ($this->doInvalidate($tagIds)) {
  301.                 return true;
  302.             }
  303.         } catch (\Exception $e) {
  304.             CacheItem::log($this->logger, 'Failed to invalidate tags: '.$e->getMessage(), ['exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  305.         }
  307.         return false;
  308.     }
  310.     /**
  311.      * Extracts tags operation data from $values set in mergeByLifetime, and returns values without it.
  312.      */
  313.     private function extractTagData(array $values, ?array &$addTagData, ?array &$removeTagData): array
  314.     {
  315.         $addTagData = $removeTagData = [];
  316.         foreach ($values as $id => $value) {
  317.             foreach ($value['tag-operations']['add'] as $tag => $tagId) {
  318.                 $addTagData[$tagId][] = $id;
  319.             }
  321.             foreach ($value['tag-operations']['remove'] as $tag => $tagId) {
  322.                 $removeTagData[$tagId][] = $id;
  323.             }
  325.             unset($values[$id]['tag-operations']);
  326.         }
  328.         return $values;
  329.     }
  330. }