redis-cluster-client 0.11.0 → 0.13.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d885c147de46fd113d493e60bd340cac591ecc94b7eafcfddbd6044abe10f79a
-  data.tar.gz: f13c1012ef977e8f9c3e38d928c5c3eb95ba2242761fa992033323c115b318f9
+  metadata.gz: 0abe95ee2079026038121cd93e8ae7929726ee4206b3d1f401dc7ed82f1da2c8
+  data.tar.gz: 7fa2e9c6c20d814f54e2fcf8045094869b4b5fc6c39144a8900328a9f5401abc
 SHA512:
-  metadata.gz: 68c939431088425c7735c68b4af0949bc5918837d9f19878c62d71aa1fec6e31efee5de2868325447a9e4672c108299a86cc6d047447ef10e7987daa04ecb1e9
-  data.tar.gz: f8ae784f6977151fd825c34878e7f6162175cd828d0b81a92da07e5af96a00a56467ffbed3822f24c198f2373900dc20ea69f8446e3468fc7ba54945baa44f65
+  metadata.gz: 26be35f5eb57e7280b8a38441f3d80c4956638a68418cf6964bdbf27d4cb3051f5955179b90066409c908ce771f3ee4286d0e569711d198ffcbfc22a70cc49bf
+  data.tar.gz: 976db1b41a2d3592dac70bf25ea8f44308824bbc7009082dd54fe68ad01b934e1b572b89df1f3b9e45b791851966c909a022defae45f4d9c3270469e9d6acc88

data/lib/redis_client/cluster/command.rb

@@ -3,7 +3,6 @@
 require 'redis_client'
 require 'redis_client/cluster/errors'
 require 'redis_client/cluster/key_slot_converter'
-require 'redis_client/cluster/normalized_cmd_name'
 
 class RedisClient
   class Cluster
@@ -12,10 +11,11 @@ class RedisClient
       EMPTY_HASH = {}.freeze
       EMPTY_ARRAY = [].freeze
 
+      private_constant :EMPTY_STRING, :EMPTY_HASH, :EMPTY_ARRAY
+
       Detail = Struct.new(
         'RedisCommand',
         :first_key_position,
-        :last_key_position,
         :key_step,
         :write?,
         :readonly?,
@@ -23,13 +23,13 @@ class RedisClient
       )
 
       class << self
-        def load(nodes, slow_command_timeout: -1)
+        def load(nodes, slow_command_timeout: -1) # rubocop:disable Metrics/AbcSize
           cmd = errors = nil
 
           nodes&.each do |node|
             regular_timeout = node.read_timeout
             node.read_timeout = slow_command_timeout > 0.0 ? slow_command_timeout : regular_timeout
-            reply = node.call('COMMAND')
+            reply = node.call('command')
             node.read_timeout = regular_timeout
             commands = parse_command_reply(reply)
             cmd = ::RedisClient::Cluster::Command.new(commands)
@@ -41,20 +41,33 @@ class RedisClient
 
           return cmd unless cmd.nil?
 
-          raise ::RedisClient::Cluster::InitialSetupError, errors
+          raise ::RedisClient::Cluster::InitialSetupError.from_errors(errors)
         end
 
         private
 
-        def parse_command_reply(rows)
+        def parse_command_reply(rows) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
           rows&.each_with_object({}) do |row, acc|
-            next if row[0].nil?
+            next if row.first.nil?
+
+            # TODO: in redis 7.0 or later, subcommand information included in the command reply
+
+            pos = case row.first
+                  when 'eval', 'evalsha', 'zinterstore', 'zunionstore' then 3
+                  when 'object', 'xgroup' then 2
+                  when 'migrate', 'xread', 'xreadgroup' then 0
+                  else row[3]
+                  end
 
-            acc[row[0].downcase] = ::RedisClient::Cluster::Command::Detail.new(
-              first_key_position: row[3],
-              last_key_position: row[4],
+            writable = case row.first
+                       when 'xgroup' then true
+                       else row[2].include?('write')
+                       end
+
+            acc[row.first] = ::RedisClient::Cluster::Command::Detail.new(
+              first_key_position: pos,
               key_step: row[5],
-              write?: row[2].include?('write'),
+              write?: writable,
               readonly?: row[2].include?('readonly')
             )
           end.freeze || EMPTY_HASH
@@ -69,89 +82,48 @@ class RedisClient
         i = determine_first_key_position(command)
         return EMPTY_STRING if i == 0
 
-        (command[i].is_a?(Array) ? command[i].flatten.first : command[i]).to_s
-      end
-
-      def extract_all_keys(command)
-        keys_start = determine_first_key_position(command)
-        keys_end = determine_last_key_position(command, keys_start)
-        keys_step = determine_key_step(command)
-        return EMPTY_ARRAY if [keys_start, keys_end, keys_step].any?(&:zero?)
-
-        keys_end = [keys_end, command.size - 1].min
-        # use .. inclusive range because keys_end is a valid index.
-        (keys_start..keys_end).step(keys_step).map { |i| command[i] }
+        command[i]
       end
 
       def should_send_to_primary?(command)
-        name = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
-        @commands[name]&.write?
+        find_command_info(command.first)&.write?
       end
 
       def should_send_to_replica?(command)
-        name = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
-        @commands[name]&.readonly?
+        find_command_info(command.first)&.readonly?
       end
 
       def exists?(name)
-        @commands.key?(::RedisClient::Cluster::NormalizedCmdName.instance.get_by_name(name))
+        @commands.key?(name) || @commands.key?(name.to_s.downcase(:ascii))
       end
 
       private
 
-      def determine_first_key_position(command) # rubocop:disable Metrics/CyclomaticComplexity
-        case name = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
-        when 'eval', 'evalsha', 'zinterstore', 'zunionstore' then 3
-        when 'object' then 2
-        when 'memory'
-          command[1].to_s.casecmp('usage').zero? ? 2 : 0
-        when 'migrate'
-          command[3].empty? ? determine_optional_key_position(command, 'keys') : 3
-        when 'xread', 'xreadgroup'
-          determine_optional_key_position(command, 'streams')
-        else
-          @commands[name]&.first_key_position.to_i
-        end
+      def find_command_info(name)
+        @commands[name] || @commands[name.to_s.downcase(:ascii)]
       end
 
-      # IMPORTANT: this determines the last key position INCLUSIVE of the last key -
-      # i.e. command[determine_last_key_position(command)] is a key.
-      # This is in line with what Redis returns from COMMANDS.
-      def determine_last_key_position(command, keys_start) # rubocop:disable Metrics/AbcSize
-        case name = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
-        when 'eval', 'evalsha', 'zinterstore', 'zunionstore'
-          # EVALSHA sha1 numkeys [key [key ...]] [arg [arg ...]]
-          # ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE <SUM | MIN | MAX>]
-          command[2].to_i + 2
-        when 'object', 'memory'
-          # OBJECT [ENCODING | FREQ | IDLETIME | REFCOUNT] key
-          # MEMORY USAGE key [SAMPLES count]
-          keys_start
-        when 'migrate'
-          # MIGRATE host port <key | ""> destination-db timeout [COPY] [REPLACE] [AUTH password | AUTH2 username password] [KEYS key [key ...]]
-          command[3].empty? ? (command.length - 1) : 3
-        when 'xread', 'xreadgroup'
-          # XREAD [COUNT count] [BLOCK milliseconds] STREAMS key [key ...] id [id ...]
-          keys_start + ((command.length - keys_start) / 2) - 1
+      def determine_first_key_position(command) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+        i = find_command_info(command.first)&.first_key_position.to_i
+        return i if i > 0
+
+        cmd_name = command.first
+        if cmd_name.casecmp('xread').zero?
+          determine_optional_key_position(command, 'streams')
+        elsif cmd_name.casecmp('xreadgroup').zero?
+          determine_optional_key_position(command, 'streams')
+        elsif cmd_name.casecmp('migrate').zero?
+          command[3].empty? ? determine_optional_key_position(command, 'keys') : 3
+        elsif cmd_name.casecmp('memory').zero?
+          command[1].to_s.casecmp('usage').zero? ? 2 : 0
         else
-          # If there is a fixed, non-variable number of keys, don't iterate past that.
-          if @commands[name].last_key_position >= 0
-            @commands[name].last_key_position
-          else
-            command.length + @commands[name].last_key_position
-          end
+          i
         end
       end
 
-      def determine_optional_key_position(command, option_name) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        idx = command&.flatten&.map(&:to_s)&.map(&:downcase)&.index(option_name&.downcase)
-        idx.nil? ? 0 : idx + 1
-      end
-
-      def determine_key_step(command)
-        name = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
-        # Some commands like EVALSHA have zero as the step in COMMANDS somehow.
-        @commands[name].key_step == 0 ? 1 : @commands[name].key_step
+      def determine_optional_key_position(command, option_name)
+        i = command.index { |v| v.to_s.casecmp(option_name).zero? }
+        i.nil? ? 0 : i + 1
       end
     end
   end

data/lib/redis_client/cluster/concurrent_worker/on_demand.rb

@@ -5,6 +5,8 @@ class RedisClient
     module ConcurrentWorker
       class OnDemand
         def initialize(size:)
+          raise ArgumentError, "size must be positive: #{size}" unless size.positive?
+
           @q = SizedQueue.new(size)
         end
 

data/lib/redis_client/cluster/concurrent_worker/pooled.rb

@@ -11,6 +11,8 @@ class RedisClient
       # So it consumes memory 1 MB multiplied a number of workers.
       class Pooled
         def initialize(size:)
+          raise ArgumentError, "size must be positive: #{size}" unless size.positive?
+
           @size = size
           setup
         end

data/lib/redis_client/cluster/concurrent_worker.rb

@@ -71,14 +71,12 @@ class RedisClient
 
       module_function
 
-      def create(model: :on_demand, size: 5)
-        size = size.positive? ? size : 5
-
+      def create(model: :none, size: 5)
         case model
-        when :on_demand, nil then ::RedisClient::Cluster::ConcurrentWorker::OnDemand.new(size: size)
-        when :pooled then ::RedisClient::Cluster::ConcurrentWorker::Pooled.new(size: size)
         when :none then ::RedisClient::Cluster::ConcurrentWorker::None.new
-        else raise ArgumentError, "Unknown model: #{model}"
+        when :on_demand then ::RedisClient::Cluster::ConcurrentWorker::OnDemand.new(size: size)
+        when :pooled then ::RedisClient::Cluster::ConcurrentWorker::Pooled.new(size: size)
+        else raise ArgumentError, "unknown model: #{model}"
         end
       end
     end

data/lib/redis_client/cluster/errors.rb

@@ -4,50 +4,70 @@ require 'redis_client'
 
 class RedisClient
   class Cluster
+    class Error < ::RedisClient::Error
+      def with_config(config)
+        @config = config
+        self
+      end
+    end
+
     ERR_ARG_NORMALIZATION = ->(arg) { Array[arg].flatten.reject { |e| e.nil? || (e.respond_to?(:empty?) && e.empty?) } }
+    Ractor.make_shareable(ERR_ARG_NORMALIZATION) if Object.const_defined?(:Ractor, false) && Ractor.respond_to?(:make_shareable)
+
+    private_constant :ERR_ARG_NORMALIZATION
 
-    class InitialSetupError < ::RedisClient::Error
-      def initialize(errors)
+    class InitialSetupError < Error
+      def self.from_errors(errors)
         msg = ERR_ARG_NORMALIZATION.call(errors).map(&:message).uniq.join(',')
-        super("Redis client could not fetch cluster information: #{msg}")
+        new("Redis client could not fetch cluster information: #{msg}")
       end
     end
 
-    class OrchestrationCommandNotSupported < ::RedisClient::Error
-      def initialize(command)
+    class OrchestrationCommandNotSupported < Error
+      def self.from_command(command)
         str = ERR_ARG_NORMALIZATION.call(command).map(&:to_s).join(' ').upcase
         msg = "#{str} command should be used with care " \
               'only by applications orchestrating Redis Cluster, like redis-cli, ' \
               'and the command if used out of the right context can leave the cluster ' \
               'in a wrong state or cause data loss.'
-        super(msg)
+        new(msg)
       end
     end
 
-    class ErrorCollection < ::RedisClient::Error
+    class ErrorCollection < Error
+      EMPTY_HASH = {}.freeze
+
+      private_constant :EMPTY_HASH
       attr_reader :errors
 
-      def initialize(errors)
-        @errors = {}
+      def self.with_errors(errors)
         if !errors.is_a?(Hash) || errors.empty?
-          super('')
-          return
+          new(errors.to_s).with_errors(EMPTY_HASH)
+        else
+          messages = errors.map { |node_key, error| "#{node_key}: (#{error.class}) #{error.message}" }.freeze
+          new(messages.join(', ')).with_errors(errors)
         end
+      end
+
+      def initialize(error_message = nil)
+        @errors = nil
+        super
+      end
 
-        @errors = errors
-        messages = @errors.map { |node_key, error| "#{node_key}: #{error.message}" }
-        super("Errors occurred on any node: #{messages.join(', ')}")
+      def with_errors(errors)
+        @errors = errors if @errors.nil?
+        self
       end
     end
 
-    class AmbiguousNodeError < ::RedisClient::Error
-      def initialize(command)
-        super("Cluster client doesn't know which node the #{command} command should be sent to.")
+    class AmbiguousNodeError < Error
+      def self.from_command(command)
+        new("Cluster client doesn't know which node the #{command} command should be sent to.")
       end
     end
 
-    class NodeMightBeDown < ::RedisClient::Error
-      def initialize(_ = '')
+    class NodeMightBeDown < Error
+      def initialize(_error_message = nil)
         super(
           'The client is trying to fetch the latest cluster state ' \
           'because a subset of nodes might be down. ' \

data/lib/redis_client/cluster/key_slot_converter.rb

@@ -3,6 +3,7 @@
 class RedisClient
   class Cluster
     module KeySlotConverter
+      HASH_SLOTS = 16_384
       EMPTY_STRING = ''
       LEFT_BRACKET = '{'
       RIGHT_BRACKET = '}'
@@ -41,7 +42,8 @@ class RedisClient
         0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
       ].freeze
 
-      HASH_SLOTS = 16_384
+      private_constant :HASH_SLOTS, :EMPTY_STRING,
+                       :LEFT_BRACKET, :RIGHT_BRACKET, :XMODEM_CRC16_LOOKUP
 
       module_function
 

data/lib/redis_client/cluster/node/base_topology.rb

@@ -8,6 +8,8 @@ class RedisClient
         EMPTY_HASH = {}.freeze
         EMPTY_ARRAY = [].freeze
 
+        private_constant :IGNORE_GENERIC_CONFIG_KEYS, :EMPTY_HASH, :EMPTY_ARRAY
+
         attr_reader :clients, :primary_clients, :replica_clients
 
         def initialize(pool, concurrent_worker, **kwargs)
@@ -52,7 +54,7 @@ class RedisClient
         def connect_to_new_nodes(options)
           (options.keys - @clients.keys).each do |node_key|
             option = options[node_key].merge(@client_options)
-            config = ::RedisClient::Cluster::Node::Config.new(scale_read: !@primary_node_keys.include?(node_key), **option)
+            config = ::RedisClient::Cluster::Node::Config.new(scale_read: @replica_node_keys.include?(node_key), **option)
             client = @pool.nil? ? config.new_client : config.new_pool(**@pool)
             @clients[node_key] = client
           end

data/lib/redis_client/cluster/node/latency_replica.rb

@@ -9,6 +9,8 @@ class RedisClient
         DUMMY_LATENCY_MSEC = 100 * 1000 * 1000
         MEASURE_ATTEMPT_COUNT = 10
 
+        private_constant :DUMMY_LATENCY_MSEC, :MEASURE_ATTEMPT_COUNT
+
         def clients_for_scanning(seed: nil) # rubocop:disable Lint/UnusedMethodArgument
           @clients_for_scanning
         end
@@ -45,7 +47,7 @@ class RedisClient
               min = DUMMY_LATENCY_MSEC
               MEASURE_ATTEMPT_COUNT.times do
                 starting = obtain_current_time
-                cli.call_once('PING')
+                cli.call_once('ping')
                 duration = obtain_current_time - starting
                 min = duration if duration < min
               end

data/lib/redis_client/cluster/node.rb

@@ -7,6 +7,7 @@ require 'redis_client/cluster/node/primary_only'
 require 'redis_client/cluster/node/random_replica'
 require 'redis_client/cluster/node/random_replica_or_primary'
 require 'redis_client/cluster/node/latency_replica'
+require 'redis_client/cluster/node_key'
 
 class RedisClient
   class Cluster
@@ -23,8 +24,12 @@ class RedisClient
       ROLE_FLAGS = %w[master slave].freeze
       EMPTY_ARRAY = [].freeze
       EMPTY_HASH = {}.freeze
+      STATE_REFRESH_INTERVAL = (3..10).freeze
 
-      ReloadNeeded = Class.new(::RedisClient::Error)
+      private_constant :USE_CHAR_ARRAY_SLOT, :SLOT_SIZE, :MIN_SLOT, :MAX_SLOT,
+                       :DEAD_FLAGS, :ROLE_FLAGS, :EMPTY_ARRAY, :EMPTY_HASH
+
+      ReloadNeeded = Class.new(::RedisClient::Cluster::Error)
 
       Info = Struct.new(
         'RedisClusterNode',
@@ -39,12 +44,18 @@ class RedisClient
         def replica?
           role == 'slave'
         end
+
+        def serialize(str)
+          str << id << node_key << role << primary_id << config_epoch
+        end
       end
 
       class CharArray
         BASE = ''
         PADDING = '0'
 
+        private_constant :BASE, :PADDING
+
         def initialize(size, elements)
           @elements = elements
           @string = String.new(BASE, encoding: Encoding::BINARY, capacity: size)
@@ -80,11 +91,9 @@ class RedisClient
           super(**kwargs)
         end
 
-        private
-
-        def build_connection_prelude
+        def connection_prelude
           prelude = super.dup
-          prelude << ['READONLY'] if @scale_read
+          prelude << ['readonly'] if @scale_read
           prelude.freeze
         end
       end
@@ -98,6 +107,8 @@ class RedisClient
         @config = config
         @mutex = Mutex.new
         @last_reloaded_at = nil
+        @reload_times = 0
+        @random = Random.new
       end
 
       def inspect
@@ -140,7 +151,7 @@ class RedisClient
 
         raise ReloadNeeded if errors.values.any?(::RedisClient::ConnectionError)
 
-        raise ::RedisClient::Cluster::ErrorCollection, errors
+        raise ::RedisClient::Cluster::ErrorCollection.with_errors(errors)
       end
 
       def clients_for_scanning(seed: nil)
@@ -259,7 +270,7 @@ class RedisClient
         result_values, errors = call_multiple_nodes(clients, method, command, args, &block)
         return result_values if errors.nil? || errors.empty?
 
-        raise ::RedisClient::Cluster::ErrorCollection, errors
+        raise ::RedisClient::Cluster::ErrorCollection.with_errors(errors)
       end
 
       def try_map(clients, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
@@ -301,7 +312,7 @@ class RedisClient
           work_group.push(i, raw_client) do |client|
             regular_timeout = client.read_timeout
             client.read_timeout = @config.slow_command_timeout > 0.0 ? @config.slow_command_timeout : regular_timeout
-            reply = client.call('CLUSTER', 'NODES')
+            reply = client.call_once('cluster', 'nodes')
             client.read_timeout = regular_timeout
             parse_cluster_node_reply(reply)
           rescue StandardError => e
@@ -326,13 +337,11 @@ class RedisClient
 
         work_group.close
 
-        raise ::RedisClient::Cluster::InitialSetupError, errors if node_info_list.nil?
+        raise ::RedisClient::Cluster::InitialSetupError.from_errors(errors) if node_info_list.nil?
 
         grouped = node_info_list.compact.group_by do |info_list|
           info_list.sort_by!(&:id)
-          info_list.each_with_object(String.new(capacity: 128 * info_list.size)) do |e, a|
-            a << e.id << e.node_key << e.role << e.primary_id << e.config_epoch
-          end
+          info_list.each_with_object(String.new(capacity: 128 * info_list.size)) { |e, a| e.serialize(a) }
         end
 
         grouped.max_by { |_, v| v.size }[1].first
@@ -367,6 +376,48 @@ class RedisClient
         end
       end
 
+      def parse_cluster_slots_reply(reply) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        reply.group_by { |e| e[2][2] }.each_with_object([]) do |(primary_id, group), acc|
+          slots = group.map { |e| e[0, 2] }.freeze
+
+          group.first[2..].each do |arr|
+            ip = arr[0]
+            next if ip.nil? || ip.empty? || ip == '?'
+
+            id = arr[2]
+            role = id == primary_id ? 'master' : 'slave'
+            acc << ::RedisClient::Cluster::Node::Info.new(
+              id: id,
+              node_key: NodeKey.build_from_host_port(ip, arr[1]),
+              role: role,
+              primary_id: role == 'master' ? nil : primary_id,
+              slots: role == 'master' ? slots : EMPTY_ARRAY
+            )
+          end
+        end.freeze
+      end
+
+      def parse_cluster_shards_reply(reply) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        reply.each_with_object([]) do |shard, acc|
+          nodes = shard.fetch('nodes')
+          primary_id = nodes.find { |n| n.fetch('role') == 'master' }.fetch('id')
+
+          nodes.each do |node|
+            ip = node.fetch('ip')
+            next if node.fetch('health') != 'online' || ip.nil? || ip.empty? || ip == '?'
+
+            role = node.fetch('role')
+            acc << ::RedisClient::Cluster::Node::Info.new(
+              id: node.fetch('id'),
+              node_key: NodeKey.build_from_host_port(ip, node['port'] || node['tls-port']),
+              role: role == 'master' ? role : 'slave',
+              primary_id: role == 'master' ? nil : primary_id,
+              slots: role == 'master' ? shard.fetch('slots').each_slice(2).to_a.freeze : EMPTY_ARRAY
+            )
+          end
+        end.freeze
+      end
+
       # As redirection node_key is dependent on `cluster-preferred-endpoint-type` config,
       # node_key should use hostname if present in CLUSTER NODES output.
       #
@@ -414,15 +465,27 @@ class RedisClient
         # performed the reload.
         # Probably in the future we should add a circuit breaker to #reload itself, and stop trying if the cluster is
         # obviously not working.
-        wait_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        wait_start = obtain_current_time
         @mutex.synchronize do
           return if @last_reloaded_at && @last_reloaded_at > wait_start
 
+          if @last_reloaded_at && @reload_times > 1
+            # Mitigate load of servers by naive logic. Don't sleep with exponential backoff.
+            now = obtain_current_time
+            elapsed = @last_reloaded_at + @random.rand(STATE_REFRESH_INTERVAL) * 1_000_000
+            return if now < elapsed
+          end
+
           r = yield
-          @last_reloaded_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          @last_reloaded_at = obtain_current_time
+          @reload_times += 1
           r
         end
       end
+
+      def obtain_current_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+      end
     end
   end
 end

data/lib/redis_client/cluster/node_key.rb

@@ -8,6 +8,8 @@ class RedisClient
     module NodeKey
       DELIMITER = ':'
 
+      private_constant :DELIMITER
+
       module_function
 
       def hashify(node_key)

data/lib/redis_client/cluster/noop_command_builder.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class RedisClient
+  class Cluster
+    module NoopCommandBuilder
+      module_function
+
+      def generate(args, _kwargs = nil)
+        args
+      end
+    end
+  end
+end

data/lib/redis_client/cluster/optimistic_locking.rb

@@ -11,38 +11,53 @@ class RedisClient
         @asking = false
       end
 
-      def watch(keys)
+      def watch(keys) # rubocop:disable Metrics/AbcSize
         slot = find_slot(keys)
         raise ::RedisClient::Cluster::Transaction::ConsistencyError, "unsafe watch: #{keys.join(' ')}" if slot.nil?
 
-        # We have not yet selected a node for this transaction, initially, which means we can handle
-        # redirections freely initially (i.e. for the first WATCH call)
-        node = @router.find_primary_node_by_slot(slot)
-        handle_redirection(node, retry_count: 1) do |nd|
+        handle_redirection(slot, retry_count: 1) do |nd|
           nd.with do |c|
             c.ensure_connected_cluster_scoped(retryable: false) do
-              c.call('ASKING') if @asking
-              c.call('WATCH', *keys)
+              c.call('asking') if @asking
+              c.call('watch', *keys)
               begin
                 yield(c, slot, @asking)
               rescue ::RedisClient::ConnectionError
                 # No need to unwatch on a connection error.
                 raise
               rescue StandardError
-                c.call('UNWATCH')
+                c.call('unwatch')
                 raise
               end
+            rescue ::RedisClient::CommandError => e
+              @router.renew_cluster_state if e.message.start_with?('CLUSTERDOWN')
+              raise
             end
+          rescue ::RedisClient::ConnectionError
+            @router.renew_cluster_state
+            raise
           end
         end
       end
 
       private
 
-      def handle_redirection(node, retry_count: 1, &blk)
-        @router.handle_redirection(node, retry_count: retry_count) do |nd|
+      def handle_redirection(slot, retry_count: 1, &blk)
+        # We have not yet selected a node for this transaction, initially, which means we can handle
+        # redirections freely initially (i.e. for the first WATCH call)
+        node = @router.find_primary_node_by_slot(slot)
+        times_block_executed = 0
+        @router.handle_redirection(node, nil, retry_count: retry_count) do |nd|
+          times_block_executed += 1
           handle_asking_once(nd, &blk)
         end
+      rescue ::RedisClient::ConnectionError
+        # Deduct the number of retries that happened _inside_ router#handle_redirection from our remaining
+        # _external_ retries. Always deduct at least one in case handle_redirection raises without trying the block.
+        retry_count -= [times_block_executed, 1].min
+        raise if retry_count < 0
+
+        retry
       end
 
       def handle_asking_once(node)