vendor/symfony/cache/Adapter/RedisTagAwareAdapter.php line 96

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 Predis\Connection\Aggregate\ClusterInterface;
  15. use Predis\Connection\Aggregate\PredisCluster;
  16. use Predis\Connection\Aggregate\ReplicationInterface;
  17. use Predis\Response\ErrorInterface;
  18. use Predis\Response\Status;
  19. use Symfony\Component\Cache\CacheItem;
  20. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  21. use Symfony\Component\Cache\Exception\LogicException;
  22. use Symfony\Component\Cache\Marshaller\DeflateMarshaller;
  23. use Symfony\Component\Cache\Marshaller\MarshallerInterface;
  24. use Symfony\Component\Cache\Marshaller\TagAwareMarshaller;
  25. use Symfony\Component\Cache\Traits\RedisClusterProxy;
  26. use Symfony\Component\Cache\Traits\RedisProxy;
  27. use Symfony\Component\Cache\Traits\RedisTrait;
  29. /**
  30.  * Stores tag id <> cache id relationship as a Redis Set.
  31.  *
  32.  * Set (tag relation info) is stored without expiry (non-volatile), while cache always gets an expiry (volatile) even
  33.  * if not set by caller. Thus if you configure redis with the right eviction policy you can be safe this tag <> cache
  34.  * relationship survives eviction (cache cleanup when Redis runs out of memory).
  35.  *
  36.  * Redis server 2.8+ with any `volatile-*` eviction policy, OR `noeviction` if you're sure memory will NEVER fill up
  37.  *
  38.  * Design limitations:
  39.  *  - Max 4 billion cache keys per cache tag as limited by Redis Set datatype.
  40.  *    E.g. If you use a "all" items tag for expiry instead of clear(), that limits you to 4 billion cache items also.
  41.  *
  42.  * @see https://redis.io/topics/lru-cache#eviction-policies Documentation for Redis eviction policies.
  43.  * @see https://redis.io/topics/data-types#sets Documentation for Redis Set datatype.
  44.  *
  45.  * @author Nicolas Grekas <[email protected]>
  46.  * @author André Rømcke <[email protected]>
  47.  */
  48. class RedisTagAwareAdapter extends AbstractTagAwareAdapter
  49. {
  50.     use RedisTrait;
  52.     /**
  53.      * On cache items without a lifetime set, we set it to 100 days. This is to make sure cache items are
  54.      * preferred to be evicted over tag Sets, if eviction policy is configured according to requirements.
  55.      */
  56.     private const DEFAULT_CACHE_TTL = 8640000;
  58.     /**
  59.      * @var string|null detected eviction policy used on Redis server
  60.      */
  61.     private $redisEvictionPolicy;
  62.     private $namespace;
  64.     /**
  65.      * @param \Redis|\RedisArray|\RedisCluster|\Predis\ClientInterface|RedisProxy|RedisClusterProxy $redis           The redis client
  66.      * @param string                                                                                $namespace       The default namespace
  67.      * @param int                                                                                   $defaultLifetime The default lifetime
  68.      */
  69.     public function __construct($redis, string $namespace = '', int $defaultLifetime = 0, ?MarshallerInterface $marshaller = null)
  70.     {
  71.         if ($redis instanceof \Predis\ClientInterface && $redis->getConnection() instanceof ClusterInterface && !$redis->getConnection() instanceof PredisCluster) {
  72.             throw new InvalidArgumentException(sprintf('Unsupported Predis cluster connection: only "%s" is, "%s" given.', PredisCluster::class, get_debug_type($redis->getConnection())));
  73.         }
  75.         if (\defined('Redis::OPT_COMPRESSION') && ($redis instanceof \Redis || $redis instanceof \RedisArray || $redis instanceof \RedisCluster)) {
  76.             $compression = $redis->getOption(\Redis::OPT_COMPRESSION);
  78.             foreach (\is_array($compression) ? $compression : [$compression] as $c) {
  79.                 if (\Redis::COMPRESSION_NONE !== $c) {
  80.                     throw new InvalidArgumentException(sprintf('phpredis compression must be disabled when using "%s", use "%s" instead.', static::class, DeflateMarshaller::class));
  81.                 }
  82.             }
  83.         }
  85.         $this->init($redis, $namespace, $defaultLifetime, new TagAwareMarshaller($marshaller));
  86.         $this->namespace = $namespace;
  87.     }
  89.     /**
  90.      * {@inheritdoc}
  91.      */
  92.     protected function doSave(array $values, int $lifetime, array $addTagData = [], array $delTagData = []): array
  93.     {
  94.         $eviction = $this->getRedisEvictionPolicy();
  95.         if ('noeviction' !== $eviction && !str_starts_with($eviction, 'volatile-')) {
  96.             throw new LogicException(sprintf('Redis maxmemory-policy setting "%s" is *not* supported by RedisTagAwareAdapter, use "noeviction" or "volatile-*" eviction policies.', $eviction));
  97.         }
  99.         // serialize values
  100.         if (!$serialized = $this->marshaller->marshall($values, $failed)) {
  101.             return $failed;
  102.         }
  104.         // While pipeline isn't supported on RedisCluster, other setups will at least benefit from doing this in one op
  105.         $results = $this->pipeline(static function () use ($serialized, $lifetime, $addTagData, $delTagData, $failed) {
  106.             // Store cache items, force a ttl if none is set, as there is no MSETEX we need to set each one
  107.             foreach ($serialized as $id => $value) {
  108.                 yield 'setEx' => [
  109.                     $id,
  110.                     0 >= $lifetime ? self::DEFAULT_CACHE_TTL : $lifetime,
  111.                     $value,
  112.                 ];
  113.             }
  115.             // Add and Remove Tags
  116.             foreach ($addTagData as $tagId => $ids) {
  117.                 if (!$failed || $ids = array_diff($ids, $failed)) {
  118.                     yield 'sAdd' => array_merge([$tagId], $ids);
  119.                 }
  120.             }
  122.             foreach ($delTagData as $tagId => $ids) {
  123.                 if (!$failed || $ids = array_diff($ids, $failed)) {
  124.                     yield 'sRem' => array_merge([$tagId], $ids);
  125.                 }
  126.             }
  127.         });
  129.         foreach ($results as $id => $result) {
  130.             // Skip results of SADD/SREM operations, they'll be 1 or 0 depending on if set value already existed or not
  131.             if (is_numeric($result)) {
  132.                 continue;
  133.             }
  134.             // setEx results
  135.             if (true !== $result && (!$result instanceof Status || Status::get('OK') !== $result)) {
  136.                 $failed[] = $id;
  137.             }
  138.         }
  140.         return $failed;
  141.     }
  143.     /**
  144.      * {@inheritdoc}
  145.      */
  146.     protected function doDeleteYieldTags(array $ids): iterable
  147.     {
  148.         $lua = <<<'EOLUA'
  149.             local v = redis.call('GET', KEYS[1])
  150.             local e = redis.pcall('UNLINK', KEYS[1])
  152.             if type(e) ~= 'number' then
  153.                 redis.call('DEL', KEYS[1])
  154.             end
  156.             if not v or v:len() <= 13 or v:byte(1) ~= 0x9D or v:byte(6) ~= 0 or v:byte(10) ~= 0x5F then
  157.                 return ''
  158.             end
  160.             return v:sub(14, 13 + v:byte(13) + v:byte(12) * 256 + v:byte(11) * 65536)
  161. EOLUA;
  163.         $results = $this->pipeline(function () use ($ids, $lua) {
  164.             foreach ($ids as $id) {
  165.                 yield 'eval' => $this->redis instanceof \Predis\ClientInterface ? [$lua, 1, $id] : [$lua, [$id], 1];
  166.             }
  167.         });
  169.         foreach ($results as $id => $result) {
  170.             if ($result instanceof \RedisException || $result instanceof ErrorInterface) {
  171.                 CacheItem::log($this->logger, 'Failed to delete key "{key}": '.$result->getMessage(), ['key' => substr($id, \strlen($this->namespace)), 'exception' => $result]);
  173.                 continue;
  174.             }
  176.             try {
  177.                 yield $id => !\is_string($result) || '' === $result ? [] : $this->marshaller->unmarshall($result);
  178.             } catch (\Exception $e) {
  179.                 yield $id => [];
  180.             }
  181.         }
  182.     }
  184.     /**
  185.      * {@inheritdoc}
  186.      */
  187.     protected function doDeleteTagRelations(array $tagData): bool
  188.     {
  189.         $results = $this->pipeline(static function () use ($tagData) {
  190.             foreach ($tagData as $tagId => $idList) {
  191.                 array_unshift($idList, $tagId);
  192.                 yield 'sRem' => $idList;
  193.             }
  194.         });
  195.         foreach ($results as $result) {
  196.             // no-op
  197.         }
  199.         return true;
  200.     }
  202.     /**
  203.      * {@inheritdoc}
  204.      */
  205.     protected function doInvalidate(array $tagIds): bool
  206.     {
  207.         // This script scans the set of items linked to tag: it empties the set
  208.         // and removes the linked items. When the set is still not empty after
  209.         // the scan, it means we're in cluster mode and that the linked items
  210.         // are on other nodes: we move the links to a temporary set and we
  211.         // garbage collect that set from the client side.
  213.         $lua = <<<'EOLUA'
  214.             redis.replicate_commands()
  216.             local cursor = '0'
  217.             local id = KEYS[1]
  218.             repeat
  219.                 local result = redis.call('SSCAN', id, cursor, 'COUNT', 5000);
  220.                 cursor = result[1];
  221.                 local rems = {}
  223.                 for _, v in ipairs(result[2]) do
  224.                     local ok, _ = pcall(redis.call, 'DEL', ARGV[1]..v)
  225.                     if ok then
  226.                         table.insert(rems, v)
  227.                     end
  228.                 end
  229.                 if 0 < #rems then
  230.                     redis.call('SREM', id, unpack(rems))
  231.                 end
  232.             until '0' == cursor;
  234.             redis.call('SUNIONSTORE', '{'..id..'}'..id, id)
  235.             redis.call('DEL', id)
  237.             return redis.call('SSCAN', '{'..id..'}'..id, '0', 'COUNT', 5000)
  238. EOLUA;
  240.         $results = $this->pipeline(function () use ($tagIds, $lua) {
  241.             if ($this->redis instanceof \Predis\ClientInterface) {
  242.                 $prefix = $this->redis->getOptions()->prefix ? $this->redis->getOptions()->prefix->getPrefix() : '';
  243.             } elseif (\is_array($prefix = $this->redis->getOption(\Redis::OPT_PREFIX) ?? '')) {
  244.                 $prefix = current($prefix);
  245.             }
  247.             foreach ($tagIds as $id) {
  248.                 yield 'eval' => $this->redis instanceof \Predis\ClientInterface ? [$lua, 1, $id, $prefix] : [$lua, [$id, $prefix], 1];
  249.             }
  250.         });
  252.         $lua = <<<'EOLUA'
  253.             redis.replicate_commands()
  255.             local id = KEYS[1]
  256.             local cursor = table.remove(ARGV)
  257.             redis.call('SREM', '{'..id..'}'..id, unpack(ARGV))
  259.             return redis.call('SSCAN', '{'..id..'}'..id, cursor, 'COUNT', 5000)
  260. EOLUA;
  262.         $success = true;
  263.         foreach ($results as $id => $values) {
  264.             if ($values instanceof \RedisException || $values instanceof ErrorInterface) {
  265.                 CacheItem::log($this->logger, 'Failed to invalidate key "{key}": '.$values->getMessage(), ['key' => substr($id, \strlen($this->namespace)), 'exception' => $values]);
  266.                 $success = false;
  268.                 continue;
  269.             }
  271.             [$cursor, $ids] = $values;
  273.             while ($ids || '0' !== $cursor) {
  274.                 $this->doDelete($ids);
  276.                 $evalArgs = [$id, $cursor];
  277.                 array_splice($evalArgs, 1, 0, $ids);
  279.                 if ($this->redis instanceof \Predis\ClientInterface) {
  280.                     array_unshift($evalArgs, $lua, 1);
  281.                 } else {
  282.                     $evalArgs = [$lua, $evalArgs, 1];
  283.                 }
  285.                 $results = $this->pipeline(function () use ($evalArgs) {
  286.                     yield 'eval' => $evalArgs;
  287.                 });
  289.                 foreach ($results as [$cursor, $ids]) {
  290.                     // no-op
  291.                 }
  292.             }
  293.         }
  295.         return $success;
  296.     }
  298.     private function getRedisEvictionPolicy(): string
  299.     {
  300.         if (null !== $this->redisEvictionPolicy) {
  301.             return $this->redisEvictionPolicy;
  302.         }
  304.         $hosts = $this->getHosts();
  305.         $host = reset($hosts);
  306.         if ($host instanceof \Predis\Client && $host->getConnection() instanceof ReplicationInterface) {
  307.             // Predis supports info command only on the master in replication environments
  308.             $hosts = [$host->getClientFor('master')];
  309.         }
  311.         foreach ($hosts as $host) {
  312.             $info = $host->info('Memory');
  314.             if ($info instanceof ErrorInterface) {
  315.                 continue;
  316.             }
  318.             $info = $info['Memory'] ?? $info;
  320.             return $this->redisEvictionPolicy = $info['maxmemory_policy'];
  321.         }
  323.         return $this->redisEvictionPolicy = '';
  324.     }
  325. }