redis-cluster-client 0.16.5 → 0.16.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee5d5f4c7bb89d0899ef2c3aec48503580d01a1e84a369f1e9ee0c1f60011f15
-  data.tar.gz: b17966f3f4c74ce89005b49188d769c4e8b6e399d6d65e0c4d68e14868cee9c7
+  metadata.gz: 201f719d07b33c0df8cde529564564e2993495a7817419730b6699047e40c068
+  data.tar.gz: 45790a9f41cd3708e8ffc7c2729e767204711c966cf9dd19aed419b7abc9fb5c
 SHA512:
-  metadata.gz: 580dbda062e93296be5869169a3f8f4d389f7bc7aba34cb473cc1a1877cd8a552a29617bf6e09cc2bea8e372cbf895f28ffd086bf75ce986a2dd448bd7170dae
-  data.tar.gz: d3abefad63034a97613319637fe617b66f64b2053f67ed8c6de7d81350976645c0eec250037fd100b0a4d5e518c3674c96e07fb043c56ffd327a8e918626405d
+  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')
-            ).freeze
+            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

@@ -141,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?
@@ -265,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?
 
@@ -403,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)

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
 
@@ -218,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
@@ -246,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,
@@ -256,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)
@@ -308,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
@@ -316,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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.16.5
+  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.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Redis cluster-aware client for Ruby
 test_files: []