redis-cluster-client 0.16.4 → 0.16.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80b5e1d6525a06ecf8747239269b110528bf9efc99ff3424108033c85cdc011a
-  data.tar.gz: 35b5aba54bc61e3731509c7ba3959289ddcfb30e40193f365fc26f62f4c7e60d
+  metadata.gz: 201f719d07b33c0df8cde529564564e2993495a7817419730b6699047e40c068
+  data.tar.gz: 45790a9f41cd3708e8ffc7c2729e767204711c966cf9dd19aed419b7abc9fb5c
 SHA512:
-  metadata.gz: ab546dc6dc75d1ec1733c5cd5f29a451881d71db8c21e587be92ab77c2f12f602100468626b742a1d87caa98aa27699906f9aefd7d9cff02512c3be1e355bdd4
-  data.tar.gz: 741326d16416834940e08c7084019080188d3e6b252c6dafdf3037bb9a40e2f9aafc0dc771fce7ac4edbb50af6d630067fb3646f4e7f1016ab72d7ceafb04940
+  metadata.gz: '085310367927882a2e2d6547419ca4edc254ea2296411ed0c8f0f7352b48d98c54a6e005cc4e11ab0b5455810fa9b086dfefa9786373f926de520c7972bae5fe'
+  data.tar.gz: 5d3db4f8ecee72af9d44c239bab164c581b4983c21a7eca1063d3724f0f70d1ed5ef73d5b141a43d34a32edc6419210fd839c0d48b61efac18ac88d5306a5a03

data/lib/redis_client/cluster/command.rb

@@ -9,15 +9,25 @@ class RedisClient
     class Command
       EMPTY_STRING = ''
       EMPTY_HASH = {}.freeze
+      EMPTY_POLICIES = [nil, nil].freeze
+      REQUEST_POLICY_PREFIX = 'request_policy:'
+      RESPONSE_POLICY_PREFIX = 'response_policy:'
+      SUBCOMMAND_DELIMITER = '|'
 
-      private_constant :EMPTY_HASH
+      private_constant :EMPTY_HASH, :EMPTY_POLICIES, :REQUEST_POLICY_PREFIX,
+                       :RESPONSE_POLICY_PREFIX, :SUBCOMMAND_DELIMITER
 
+      # @see https://redis.io/docs/latest/commands/command/ The reply of the COMMAND command
+      # @see https://redis.io/docs/latest/develop/reference/command-tips/ Command tips
       Spec = Struct.new(
         'RedisCommandSpec',
         :first_key_position,
         :key_step,
         :write?,
         :readonly?,
+        :request_policy,
+        :response_policy,
+        :subcommands,
         keyword_init: true
       ) do
         def extract_first_key(command)
@@ -86,40 +96,92 @@ class RedisClient
 
         private
 
-        def parse_command_reply(rows) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        def parse_command_reply(rows)
           rows&.each_with_object({}) do |row, acc|
             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
-
-            writable = case row.first
-                       when 'xgroup' then true
-                       else row[2].include?('write')
-                       end
-
-            acc[row.first] = ::RedisClient::Cluster::Command::Spec.new(
-              first_key_position: pos,
-              key_step: row[5],
-              write?: writable,
-              readonly?: row[2].include?('readonly')
-            )
+            acc[row.first] = build_spec(row)
           end.freeze || EMPTY_HASH
         end
+
+        def build_spec(row)
+          request_policy, response_policy = parse_tips(row[7])
+
+          ::RedisClient::Cluster::Command::Spec.new(
+            first_key_position: parse_first_key_position(row),
+            key_step: row[5],
+            write?: parse_writability(row),
+            readonly?: row[2].include?('readonly'),
+            request_policy: request_policy,
+            response_policy: response_policy,
+            subcommands: parse_subcommands(row[9])
+          ).freeze
+        end
+
+        # The redis 6.2 or earlier doesn't include the information of the subcommands in the reply.
+        # These hard-coded positions are the fallback for such old versions.
+        def parse_first_key_position(row)
+          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
+        end
+
+        def parse_writability(row)
+          case row.first
+          when 'xgroup' then true
+          else row[2].include?('write')
+          end
+        end
+
+        # The command tips are available in the redis 7.0 or later.
+        def parse_tips(tips)
+          return EMPTY_POLICIES if tips.nil? || tips.empty?
+
+          request_policy = response_policy = nil
+
+          tips.each do |tip|
+            if tip.start_with?(REQUEST_POLICY_PREFIX)
+              request_policy = -tip[REQUEST_POLICY_PREFIX.size..]
+            elsif tip.start_with?(RESPONSE_POLICY_PREFIX)
+              response_policy = -tip[RESPONSE_POLICY_PREFIX.size..]
+            end
+          end
+
+          [request_policy, response_policy]
+        end
+
+        # The information of the subcommands is available in the redis 7.0 or later.
+        # A container command such as XINFO reports its key positions per subcommand.
+        def parse_subcommands(rows)
+          return if rows.nil? || rows.empty?
+
+          rows.each_with_object({}) do |row, acc|
+            name = row.first
+            next if name.nil?
+
+            # The server replies with a full name of the subcommand such as `xinfo|stream`.
+            i = name.index(SUBCOMMAND_DELIMITER)
+            acc[i.nil? ? name : name[(i + 1)..]] = build_spec(row)
+          end.freeze
+        end
       end
 
       def initialize(commands)
         @commands = commands || EMPTY_HASH
       end
 
-      def get_spec(name)
-        @commands[name] || @commands[name.to_s.downcase(:ascii)]
+      def get_spec(command) # rubocop:disable Metrics/AbcSize
+        name = command.first
+        spec = @commands[name] || @commands[name.to_s.downcase(:ascii)]
+        return spec if spec.nil? || spec.subcommands.nil?
+
+        subcommand = command[1]
+        return spec if subcommand.nil?
+
+        spec.subcommands[subcommand] || spec.subcommands[subcommand.to_s.downcase(:ascii)] || spec
       end
 
       def exists?(name)

data/lib/redis_client/cluster/node.rb

@@ -53,15 +53,10 @@ class RedisClient
       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)
-          size.times { @string << PADDING }
+          @string = String.new('', encoding: Encoding::BINARY, capacity: size)
+          size.times { @string << 0xff }
         end
 
         def [](index)
@@ -146,6 +141,16 @@ class RedisClient
         call_multiple_nodes!(@topology.replica_clients, method, command, args, &block)
       end
 
+      # for the `response_policy:one_succeeded` command tip
+      def call_all_leniently(method, command, args, &block)
+        call_multiple_nodes_leniently(@topology.clients, method, command, args, &block)
+      end
+
+      # for the `response_policy:one_succeeded` command tip
+      def call_primaries_leniently(method, command, args, &block)
+        call_multiple_nodes_leniently(@topology.primary_clients, method, command, args, &block)
+      end
+
       def send_ping(method, command, args, &block)
         result_values, errors = call_multiple_nodes(@topology.clients, method, command, args, &block)
         return result_values if errors.nil? || errors.empty?
@@ -270,6 +275,13 @@ class RedisClient
         raise ::RedisClient::Cluster::ErrorCollection.with_errors(errors)
       end
 
+      def call_multiple_nodes_leniently(clients, method, command, args, &block)
+        result_values, errors = call_multiple_nodes(clients, method, command, args, &block)
+        return result_values unless result_values.nil? || result_values.empty?
+
+        raise ::RedisClient::Cluster::ErrorCollection.with_errors(errors)
+      end
+
       def try_map(clients, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         return [{}, {}] if clients.empty?
 
@@ -314,7 +326,6 @@ class RedisClient
             e
           ensure
             client.read_timeout = regular_timeout
-            client&.close
           end
         end
 
@@ -378,7 +389,7 @@ class RedisClient
             config_epoch: fields[6],
             link_state: fields[7],
             slots: slots
-          )
+          ).freeze
         end
       end
 
@@ -398,7 +409,7 @@ class RedisClient
               role: role,
               primary_id: role == 'master' ? EMPTY_STRING : primary_id,
               slots: role == 'master' ? slots : EMPTY_ARRAY
-            )
+            ).freeze
           end
         end
       end
@@ -409,7 +420,7 @@ class RedisClient
           shard = shard.each_slice(2).to_h if resp2
           nodes = shard.fetch('nodes')
           nodes = nodes.map { |n| n.each_slice(2).to_h } if resp2
-          primary_id = nodes.find { |n| n.fetch('role') == 'master' }.fetch('id')
+          primary_id = nodes.find { |n| n.fetch('role') == 'master' }&.fetch('id') || EMPTY_STRING
 
           nodes.each do |node|
             host = pick_shard_host(node)
@@ -422,7 +433,7 @@ class RedisClient
               role: role == 'master' ? role : 'slave',
               primary_id: role == 'master' ? EMPTY_STRING : primary_id,
               slots: role == 'master' ? shard.fetch('slots').each_slice(2).to_a.freeze : EMPTY_ARRAY
-            )
+            ).freeze
           end
         end
       end

data/lib/redis_client/cluster/optimistic_locking.rb

@@ -2,6 +2,7 @@
 
 require 'redis_client'
 require 'redis_client/cluster/transaction'
+require 'redis_client/cluster/error_identification'
 
 class RedisClient
   class Cluster
@@ -54,7 +55,7 @@ class RedisClient
       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 == 0 ? 1 : [times_block_executed, 1].min
+        retry_count -= times_block_executed > 1 ? times_block_executed : 1
         raise if retry_count < 0
 
         retry

data/lib/redis_client/cluster/pipeline.rb

@@ -23,10 +23,6 @@ class RedisClient
           @outer_indices << index
         end
 
-        def get_inner_index(outer_index)
-          @outer_indices&.find_index(outer_index)
-        end
-
         def get_callee_method(inner_index)
           if @timeouts.is_a?(Array) && !@timeouts[inner_index].nil?
             :blocking_call_v
@@ -66,6 +62,7 @@ class RedisClient
             if result.is_a?(::RedisClient::Error)
               result._set_command(commands[index])
               result._set_config(config)
+              result._set_retry_attempt(@retry_attempt)
 
               if result.is_a?(::RedisClient::CommandError) && result.message.start_with?('MOVED', 'ASK')
                 redirection_indices ||= []

data/lib/redis_client/cluster/pub_sub.rb

@@ -61,17 +61,7 @@ class RedisClient
       end
 
       BUF_SIZE = Integer(ENV.fetch('REDIS_CLIENT_PUBSUB_BUF_SIZE', 1024))
-      RECOVERY_BASE_INTERVAL = Float(ENV.fetch('REDIS_CLIENT_PUBSUB_RECOVERY_INTERVAL_SEC', 1.0))
-      RECOVERY_MAX_INTERVAL = Float(ENV.fetch('REDIS_CLIENT_PUBSUB_RECOVERY_MAX_INTERVAL_SEC', 30.0))
-      RECOVERY_MAX_ATTEMPTS = Integer(ENV.fetch('REDIS_CLIENT_PUBSUB_RECOVERY_MAX_ATTEMPTS', 10))
-      SUBSCRIBE_COMMANDS = %w[subscribe psubscribe ssubscribe].freeze
-      UNSUBSCRIBE_TO_SUBSCRIBE = {
-        'unsubscribe' => 'subscribe',
-        'punsubscribe' => 'psubscribe',
-        'sunsubscribe' => 'ssubscribe'
-      }.freeze
-      private_constant :BUF_SIZE, :RECOVERY_BASE_INTERVAL, :RECOVERY_MAX_INTERVAL, :RECOVERY_MAX_ATTEMPTS,
-                       :SUBSCRIBE_COMMANDS, :UNSUBSCRIBE_TO_SUBSCRIBE
+      private_constant :BUF_SIZE
 
       def initialize(router, command_builder)
         @router = router
@@ -84,14 +74,14 @@ class RedisClient
       def call(*args, **kwargs)
         command = @command_builder.generate(args, kwargs)
         _call(command)
-        remember(command)
+        remember_subscription(command)
         nil
       end
 
       def call_v(command)
         command = @command_builder.generate(command)
         _call(command)
-        remember(command)
+        remember_subscription(command)
         nil
       end
 
@@ -128,35 +118,6 @@ class RedisClient
 
       private
 
-      def remember(command)
-        cmd = command.first.to_s.downcase
-        if SUBSCRIBE_COMMANDS.include?(cmd)
-          @commands << command
-        elsif (subscribe_cmd = UNSUBSCRIBE_TO_SUBSCRIBE[cmd])
-          forget_subscriptions(subscribe_cmd, command[1..])
-        else
-          @commands << command
-        end
-      end
-
-      def forget_subscriptions(subscribe_cmd, channels)
-        if channels.nil? || channels.empty?
-          @commands.reject! { |c| c.first.to_s.casecmp(subscribe_cmd).zero? }
-        else
-          @commands.reject! { |c| prune_entry(c, subscribe_cmd, channels) }
-        end
-      end
-
-      def prune_entry(entry, subscribe_cmd, channels)
-        return false unless entry.first.to_s.casecmp(subscribe_cmd).zero?
-
-        remaining = entry[1..] - channels
-        return true if remaining.empty?
-
-        entry.replace([entry.first, *remaining])
-        false
-      end
-
       def _call(command) # rubocop:disable Metrics/AbcSize
         if command.first.casecmp('subscribe').zero?
           call_to_single_state(command)
@@ -227,14 +188,44 @@ class RedisClient
           break
         rescue ::RedisClient::ConnectionError, ::RedisClient::Cluster::NodeMightBeDown
           attempt += 1
-          raise if attempt >= RECOVERY_MAX_ATTEMPTS
+          raise if attempt >= 10
 
           sleep recovery_interval(attempt)
         end
       end
 
       def recovery_interval(attempt)
-        [RECOVERY_BASE_INTERVAL * (2**(attempt - 1)), RECOVERY_MAX_INTERVAL].min
+        [1.0 * (2**(attempt - 1)), 30.0].min
+      end
+
+      def remember_subscription(command) # rubocop:disable Metrics/AbcSize
+        if command.first.casecmp('subscribe').zero?
+          @commands << command
+        elsif command.first.casecmp('psubscribe').zero?
+          @commands << command
+        elsif command.first.casecmp('ssubscribe').zero?
+          @commands << command
+        elsif command.first.casecmp('unsubscribe').zero?
+          forget_subscriptions('subscribe', command[1, command.size])
+        elsif command.first.casecmp('punsubscribe').zero?
+          forget_subscriptions('psubscribe', command[1, command.size])
+        elsif command.first.casecmp('sunsubscribe').zero?
+          forget_subscriptions('ssubscribe', command[1, command.size])
+        end
+      end
+
+      def forget_subscriptions(subscribe_cmd, channels)
+        @commands.map! do |command|
+          next command unless command.first.casecmp(subscribe_cmd).zero?
+          next if channels.nil? || channels.empty?
+
+          remaining = command[1, command.size] - channels
+          next if remaining.empty?
+
+          [command.first, *remaining]
+        end
+
+        @commands.compact!
       end
     end
   end

data/lib/redis_client/cluster/router.rb

@@ -17,38 +17,39 @@ class RedisClient
     class Router
       ZERO_CURSOR_FOR_SCAN = '0'
       TSF = ->(f, x) { f.nil? ? x : f.call(x) }.curry
+      RoutingAction = Struct.new('RedisCommandRoutingAction', :method_name, :reply_transformer, keyword_init: true)
+      PICK_FIRST = ->(reply) { reply.first } # rubocop:disable Style/SymbolProc
+      FLATTEN_STRINGS = ->(reply) { reply.flatten.sort_by(&:to_s) }
+      SUM_NUM = ->(reply) { reply.select { |e| e.is_a?(Integer) }.sum }
+      SORT_NUMBERS = ->(reply) { reply.sort_by(&:to_i) }
+      if Object.const_defined?(:Ractor, false) && Ractor.respond_to?(:make_shareable)
+        Ractor.make_shareable(PICK_FIRST)
+        Ractor.make_shareable(FLATTEN_STRINGS)
+        Ractor.make_shareable(SUM_NUM)
+        Ractor.make_shareable(SORT_NUMBERS)
+      end
       DEDICATED_ACTIONS = lambda do # rubocop:disable Metrics/BlockLength
-        action = Struct.new('RedisCommandRoutingAction', :method_name, :reply_transformer, keyword_init: true)
-        pick_first = ->(reply) { reply.first } # rubocop:disable Style/SymbolProc
-        flatten_strings = ->(reply) { reply.flatten.sort_by(&:to_s) }
-        sum_num = ->(reply) { reply.select { |e| e.is_a?(Integer) }.sum }
-        sort_numbers = ->(reply) { reply.sort_by(&:to_i) }
-        if Object.const_defined?(:Ractor, false) && Ractor.respond_to?(:make_shareable)
-          Ractor.make_shareable(pick_first)
-          Ractor.make_shareable(flatten_strings)
-          Ractor.make_shareable(sum_num)
-          Ractor.make_shareable(sort_numbers)
-        end
-        multiple_key_action = action.new(method_name: :send_multiple_keys_command)
-        all_node_first_action = action.new(method_name: :send_command_to_all_nodes, reply_transformer: pick_first)
-        primary_first_action = action.new(method_name: :send_command_to_primaries, reply_transformer: pick_first)
-        not_supported_action = action.new(method_name: :fail_not_supported_command)
-        keyless_action = action.new(method_name: :fail_keyless_command)
+        multiple_key_action = RoutingAction.new(method_name: :send_multiple_keys_command)
+        all_node_first_action = RoutingAction.new(method_name: :send_command_to_all_nodes, reply_transformer: PICK_FIRST)
+        primary_first_action = RoutingAction.new(method_name: :send_command_to_primaries, reply_transformer: PICK_FIRST)
+        not_supported_action = RoutingAction.new(method_name: :fail_not_supported_command)
+        keyless_action = RoutingAction.new(method_name: :fail_keyless_command)
+        single_node_action = RoutingAction.new(method_name: :assign_node_and_send_command)
         {
-          'ping' => action.new(method_name: :send_ping_command, reply_transformer: pick_first),
-          'wait' => action.new(method_name: :send_wait_command),
-          'keys' => action.new(method_name: :send_command_to_replicas, reply_transformer: flatten_strings),
-          'dbsize' => action.new(method_name: :send_command_to_replicas, reply_transformer: sum_num),
-          'scan' => action.new(method_name: :send_scan_command),
-          'lastsave' => action.new(method_name: :send_command_to_all_nodes, reply_transformer: sort_numbers),
-          'role' => action.new(method_name: :send_command_to_all_nodes),
-          'config' => action.new(method_name: :send_config_command),
-          'client' => action.new(method_name: :send_client_command),
-          'cluster' => action.new(method_name: :send_cluster_command),
-          'memory' => action.new(method_name: :send_memory_command),
-          'script' => action.new(method_name: :send_script_command),
-          'pubsub' => action.new(method_name: :send_pubsub_command),
-          'watch' => action.new(method_name: :send_watch_command),
+          'ping' => RoutingAction.new(method_name: :send_ping_command, reply_transformer: PICK_FIRST),
+          'wait' => RoutingAction.new(method_name: :send_wait_command),
+          'keys' => RoutingAction.new(method_name: :send_command_to_replicas, reply_transformer: FLATTEN_STRINGS),
+          'dbsize' => RoutingAction.new(method_name: :send_command_to_replicas, reply_transformer: SUM_NUM),
+          'scan' => RoutingAction.new(method_name: :send_scan_command),
+          'lastsave' => RoutingAction.new(method_name: :send_command_to_all_nodes, reply_transformer: SORT_NUMBERS),
+          'role' => RoutingAction.new(method_name: :send_command_to_all_nodes),
+          'config' => RoutingAction.new(method_name: :send_config_command),
+          'client' => RoutingAction.new(method_name: :send_client_command),
+          'cluster' => RoutingAction.new(method_name: :send_cluster_command),
+          'memory' => RoutingAction.new(method_name: :send_memory_command),
+          'script' => RoutingAction.new(method_name: :send_script_command),
+          'pubsub' => RoutingAction.new(method_name: :send_pubsub_command),
+          'watch' => RoutingAction.new(method_name: :send_watch_command),
           'mget' => multiple_key_action,
           'mset' => multiple_key_action,
           'del' => multiple_key_action,
@@ -61,6 +62,10 @@ class RedisClient
           'select' => all_node_first_action,
           'flushall' => primary_first_action,
           'flushdb' => primary_first_action,
+          # The redis 7.0 tags RANDOMKEY with `request_policy:all_shards` but without any response policy.
+          # It was corrected to `response_policy:special` in the redis 7.2.
+          # This entry keeps the historical single node routing for the redis 7.0.
+          'randomkey' => single_node_action,
           'readonly' => not_supported_action,
           'readwrite' => not_supported_action,
           'shutdown' => not_supported_action,
@@ -74,7 +79,33 @@ class RedisClient
         end
       end.call.freeze
 
-      private_constant :ZERO_CURSOR_FOR_SCAN, :TSF, :DEDICATED_ACTIONS
+      # The routing which the command tips of the COMMAND command reply instruct.
+      # The `multi_shard` and the `special` request policies are out of scope.
+      # The `special` response policy is also out of scope because the aggregation is undefined,
+      # and the fan-out would change the return value of commands such as INFO.
+      # The `agg_min`, `agg_max` and `agg_logical_*` response policies are out of scope too:
+      # the only reachable command with them today is WAITAOF, whose reply is an array,
+      # and the aggregation of array replies is undefined. Such a command falls back to
+      # the single node routing until a command with a settled semantics appears.
+      # The entries of the DEDICATED_ACTIONS take precedence over these to keep the existing behavior.
+      # @see https://redis.io/docs/latest/develop/reference/command-tips/
+      POLICY_ACTIONS = {
+        'all_shards' => {
+          nil => RoutingAction.new(method_name: :send_command_to_primaries).freeze,
+          'all_succeeded' => RoutingAction.new(method_name: :send_command_to_primaries, reply_transformer: PICK_FIRST).freeze,
+          'one_succeeded' => RoutingAction.new(method_name: :send_command_to_primaries_leniently, reply_transformer: PICK_FIRST).freeze,
+          'agg_sum' => RoutingAction.new(method_name: :send_command_to_primaries, reply_transformer: SUM_NUM).freeze
+        }.freeze,
+        'all_nodes' => {
+          nil => RoutingAction.new(method_name: :send_command_to_all_nodes).freeze,
+          'all_succeeded' => RoutingAction.new(method_name: :send_command_to_all_nodes, reply_transformer: PICK_FIRST).freeze,
+          'one_succeeded' => RoutingAction.new(method_name: :send_command_to_all_nodes_leniently, reply_transformer: PICK_FIRST).freeze,
+          'agg_sum' => RoutingAction.new(method_name: :send_command_to_all_nodes, reply_transformer: SUM_NUM).freeze
+        }.freeze
+      }.freeze
+
+      private_constant :ZERO_CURSOR_FOR_SCAN, :TSF, :RoutingAction, :PICK_FIRST, :FLATTEN_STRINGS,
+                       :SUM_NUM, :SORT_NUMBERS, :DEDICATED_ACTIONS, :POLICY_ACTIONS
 
       attr_reader :config
 
@@ -94,7 +125,12 @@ class RedisClient
 
       def send_command(method, command, *args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         action = DEDICATED_ACTIONS[command.first]
-        return assign_node_and_send_command(method, command, args, &block) if action.nil?
+        if action.nil?
+          cmd_spec = @command.get_spec(command)
+          action = find_policy_action(cmd_spec)
+          return assign_node_and_send_command(method, command, args, cmd_spec: cmd_spec, &block) if action.nil?
+        end
+
         return send(action.method_name, method, command, args, &block) if action.reply_transformer.nil?
 
         reply = send(action.method_name, method, command, args)
@@ -124,8 +160,8 @@ class RedisClient
       end
 
       # @see https://redis.io/docs/reference/cluster-spec/#redirection-and-resharding Redirection and resharding
-      def assign_node_and_send_command(method, command, args, retry_count: 3, &block)
-        node = assign_node(command)
+      def assign_node_and_send_command(method, command, args, retry_count: 3, cmd_spec: nil, &block)
+        node = assign_node(command, cmd_spec: cmd_spec)
         send_command_to_node(node, method, command, args, retry_count: retry_count, &block)
       end
 
@@ -167,19 +203,20 @@ class RedisClient
         raise unless ::RedisClient::Cluster::ErrorIdentification.client_owns_error?(e, node)
 
         renew_cluster_state
-        retry_count -= 1
+        raise if command.nil? || command.empty?
 
-        if retry_count >= 0
-          # Find the node to use for this command - if this fails for some reason, though, re-use
-          # the old node.
-          begin
-            node = find_node(find_node_key(command)) if command
-          rescue StandardError # rubocop:disable Lint/SuppressedException
-          end
-          retry
+        retry_count -= 1
+        raise if retry_count < 0
+
+        # Find the node to use for this command - if this fails for some reason, though, re-use
+        # the old node.
+        begin
+          node = find_node(find_node_key(command))
+        rescue StandardError
+          raise e
         end
 
-        raise
+        retry
       end
 
       def scan(command, seed: nil) # rubocop:disable Metrics/AbcSize
@@ -217,9 +254,9 @@ class RedisClient
         end
       end
 
-      def assign_node(command)
+      def assign_node(command, cmd_spec: nil)
         handle_node_reload_error do
-          node_key = find_node_key(command)
+          node_key = find_node_key(command, cmd_spec: cmd_spec)
           @node.find_by(node_key)
         end
       end
@@ -227,7 +264,7 @@ class RedisClient
       def find_node_key_by_key(key, seed: nil, primary: false)
         if key && !key.empty?
           slot = ::RedisClient::Cluster::KeySlotConverter.convert(key)
-          node_key = primary ? @node.find_node_key_of_primary(slot) : @node.find_node_key_of_replica(slot)
+          node_key = primary ? @node.find_node_key_of_primary(slot) : @node.find_node_key_of_replica(slot, seed: seed)
           if node_key.nil?
             renew_cluster_state
             raise ::RedisClient::Cluster::NodeMightBeDown.new.with_config(@config)
@@ -245,8 +282,8 @@ class RedisClient
         end
       end
 
-      def find_node_key(command, seed: nil)
-        cmd_spec = @command.get_spec(command.first)
+      def find_node_key(command, seed: nil, cmd_spec: nil)
+        cmd_spec = @command.get_spec(command) if cmd_spec.nil?
         find_node_key_by_key(
           cmd_spec&.extract_first_key(command),
           seed: seed,
@@ -255,14 +292,14 @@ class RedisClient
       end
 
       def find_primary_node_key(command)
-        key = @command.get_spec(command.first)&.extract_first_key(command)
+        key = @command.get_spec(command)&.extract_first_key(command)
         return unless key&.size&.> 0
 
         find_node_key_by_key(key, primary: true)
       end
 
       def find_slot(command)
-        find_slot_by_key(@command.get_spec(command.first)&.extract_first_key(command))
+        find_slot_by_key(@command.get_spec(command)&.extract_first_key(command))
       end
 
       def find_slot_by_key(key)
@@ -307,6 +344,15 @@ class RedisClient
 
       private
 
+      def find_policy_action(cmd_spec)
+        return if cmd_spec.nil?
+
+        request_policy = cmd_spec.request_policy
+        return if request_policy.nil?
+
+        POLICY_ACTIONS.dig(request_policy, cmd_spec.response_policy)
+      end
+
       def send_command_to_all_nodes(method, command, args, &block)
         @node.call_all(method, command, args, &block)
       end
@@ -315,6 +361,14 @@ class RedisClient
         @node.call_primaries(method, command, args, &block)
       end
 
+      def send_command_to_all_nodes_leniently(method, command, args, &block)
+        @node.call_all_leniently(method, command, args, &block)
+      end
+
+      def send_command_to_primaries_leniently(method, command, args, &block)
+        @node.call_primaries_leniently(method, command, args, &block)
+      end
+
       def send_command_to_replicas(method, command, args, &block)
         @node.call_replicas(method, command, args, &block)
       end

data/lib/redis_client/cluster/transaction.rb

@@ -171,7 +171,7 @@ class RedisClient
           send_transaction(node, redirect: redirect - 1)
         elsif err.message.start_with?('ASK')
           node = @router.assign_asking_node(err.message)
-          try_asking(node) ? send_transaction(node, redirect: redirect - 1) : err
+          try_asking(node) ? send_transaction(node, redirect: redirect - 1) : raise(err)
         elsif err.message.start_with?('CLUSTERDOWN')
           @router.renew_cluster_state if @watching_slot.nil?
           raise err

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.16.4
+  version: 0.16.6
 platform: ruby
 authors:
 - Taishi Kasuga
@@ -74,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Redis cluster-aware client for Ruby
 test_files: []