redis-cluster-client 0.16.6 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 201f719d07b33c0df8cde529564564e2993495a7817419730b6699047e40c068
-  data.tar.gz: 45790a9f41cd3708e8ffc7c2729e767204711c966cf9dd19aed419b7abc9fb5c
+  metadata.gz: 7df1ba6006c9d3c3e7c242e9406f6443a95aa371c7e77244b73565058f476435
+  data.tar.gz: 5613bf92dc543482c1bcb2e74d61096092c299ef84877b8c06da1174db82c6d4
 SHA512:
-  metadata.gz: '085310367927882a2e2d6547419ca4edc254ea2296411ed0c8f0f7352b48d98c54a6e005cc4e11ab0b5455810fa9b086dfefa9786373f926de520c7972bae5fe'
-  data.tar.gz: 5d3db4f8ecee72af9d44c239bab164c581b4983c21a7eca1063d3724f0f70d1ed5ef73d5b141a43d34a32edc6419210fd839c0d48b61efac18ac88d5306a5a03
+  metadata.gz: 58e9ecaa1aecf6bfb298cba78e08d349f742439a2f5a53e19cd55bb49c8a600b4e4f47a54af1798ef0afe51cb56cf5cf292eda3bdf75e522ed180fa065e37954
+  data.tar.gz: c158336f83f4453e27798a2521c4e282a867db446dfa7e74e988af9e568567235b321b59386bf79ac5d0e32dee0698137755e9c416ceeb3acb150ebfc60d5208

data/lib/redis_client/cluster/command.rb

@@ -9,12 +9,11 @@ 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, :EMPTY_POLICIES, :REQUEST_POLICY_PREFIX,
+      private_constant :EMPTY_HASH, :REQUEST_POLICY_PREFIX,
                        :RESPONSE_POLICY_PREFIX, :SUBCOMMAND_DELIMITER
 
       # @see https://redis.io/docs/latest/commands/command/ The reply of the COMMAND command
@@ -105,15 +104,13 @@ class RedisClient
         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,
+            request_policy: parse_policy_tip(row[7], REQUEST_POLICY_PREFIX),
+            response_policy: parse_policy_tip(row[7], RESPONSE_POLICY_PREFIX),
             subcommands: parse_subcommands(row[9])
           ).freeze
         end
@@ -137,20 +134,10 @@ class RedisClient
         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]
+        # It returns a single value instead of a pair to avoid the allocation of the array.
+        def parse_policy_tip(tips, prefix)
+          tip = tips&.find { |t| t.start_with?(prefix) }
+          tip.nil? ? nil : -tip.delete_prefix(prefix)
         end
 
         # The information of the subcommands is available in the redis 7.0 or later.
@@ -164,7 +151,7 @@ class RedisClient
 
             # 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)
+            acc[i.nil? ? name : name[i + 1, name.size]] = build_spec(row)
           end.freeze
         end
       end

data/lib/redis_client/cluster/node_key.rb

@@ -26,7 +26,7 @@ class RedisClient
         pos = node_key.rindex(DELIMITER, -1)
         return [node_key, nil] if pos.nil?
 
-        [node_key[0, pos], node_key[(pos + 1)..]]
+        [node_key[0, pos], node_key[pos + 1, node_key.size]]
       end
 
       def split_bracketed(node_key)
@@ -36,7 +36,7 @@ class RedisClient
         return nil if end_bracket.nil?
 
         host = node_key[1, end_bracket - 1]
-        remainder = node_key[(end_bracket + 1)..]
+        remainder = node_key[end_bracket + 1, node_key.size]
         port = remainder.start_with?(DELIMITER) ? remainder[1..] : nil
         [host, port]
       end

data/lib/redis_client/cluster/router/routing_table.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'redis_client/cluster/errors'
+
+class RedisClient
+  class Cluster
+    class Router
+      # The routing table for the commands which shouldn't be routed by their keys.
+      # The built-in entries can be overridden with the `command_routings` option of the config.
+      class RoutingTable
+        BuildError = Class.new(::RedisClient::Cluster::Error)
+        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
+          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' => 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,
+            'acl' => all_node_first_action,
+            'auth' => all_node_first_action,
+            'bgrewriteaof' => all_node_first_action,
+            'bgsave' => all_node_first_action,
+            'quit' => all_node_first_action,
+            'save' => all_node_first_action,
+            '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,
+            'discard' => keyless_action,
+            'exec' => keyless_action,
+            'multi' => keyless_action,
+            'unwatch' => keyless_action
+          }.each_with_object({}) do |(k, v), acc|
+            acc[k] = v.freeze
+            acc[k.upcase] = v.freeze
+          end
+        end.call.freeze
+
+        # 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 :RoutingAction, :PICK_FIRST, :FLATTEN_STRINGS, :SUM_NUM, :SORT_NUMBERS,
+                         :DEDICATED_ACTIONS, :POLICY_ACTIONS
+
+        class << self
+          # Builds the routing table: the built-in entries overridden by the command routings
+          # which the config validated and normalized. A nil routing removes the built-in entry
+          # of the command, so that the command follows the default resolution: the command tips
+          # which the server reports, or the routing by its key.
+          # It raises a BuildError for an unnormalized input as a defense, e.g. an unsupported policy.
+          def build(routings)
+            return DEDICATED_ACTIONS if routings.nil? || routings.empty?
+
+            routings.each_with_object(DEDICATED_ACTIONS.dup) do |(key, policies), acc|
+              merge_action(acc, key, fetch_action(key, policies))
+            end.freeze
+          end
+
+          def find_policy_action(request_policy, response_policy)
+            POLICY_ACTIONS.dig(request_policy, response_policy)
+          end
+
+          private
+
+          # Stores both the lowercase and the uppercase keys to avoid a per-call case conversion.
+          def merge_action(table, key, action)
+            if action.nil?
+              table.delete(key)
+              table.delete(key.upcase)
+            else
+              table[key] = action
+              table[key.upcase] = action
+            end
+          end
+
+          def fetch_action(key, policies)
+            return if policies.nil?
+
+            action = POLICY_ACTIONS.dig(policies[:request_policy], policies[:response_policy])
+            return action unless action.nil?
+
+            raise BuildError, "the policies of the #{key} command are unsupported: #{policies.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis_client/cluster/router.rb

@@ -11,106 +11,20 @@ require 'redis_client/cluster/transaction'
 require 'redis_client/cluster/optimistic_locking'
 require 'redis_client/cluster/pipeline'
 require 'redis_client/cluster/error_identification'
+require 'redis_client/cluster/router/routing_table'
 
 class RedisClient
   class Cluster
     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
-        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' => 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,
-          'acl' => all_node_first_action,
-          'auth' => all_node_first_action,
-          'bgrewriteaof' => all_node_first_action,
-          'bgsave' => all_node_first_action,
-          'quit' => all_node_first_action,
-          'save' => all_node_first_action,
-          '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,
-          'discard' => keyless_action,
-          'exec' => keyless_action,
-          'multi' => keyless_action,
-          'unwatch' => keyless_action
-        }.each_with_object({}) do |(k, v), acc|
-          acc[k] = v.freeze
-          acc[k.upcase] = v.freeze
-        end
-      end.call.freeze
-
-      # 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
+      private_constant :ZERO_CURSOR_FOR_SCAN, :TSF
 
       attr_reader :config
 
       def initialize(config, concurrent_worker, pool: nil, **kwargs)
         @config = config
+        @dedicated_actions = RoutingTable.build(config.command_routings)
         @concurrent_worker = concurrent_worker
         @pool = pool
         @client_kwargs = kwargs
@@ -124,7 +38,7 @@ class RedisClient
       end
 
       def send_command(method, command, *args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        action = DEDICATED_ACTIONS[command.first]
+        action = @dedicated_actions[command.first]
         if action.nil?
           cmd_spec = @command.get_spec(command)
           action = find_policy_action(cmd_spec)
@@ -350,7 +264,7 @@ class RedisClient
         request_policy = cmd_spec.request_policy
         return if request_policy.nil?
 
-        POLICY_ACTIONS.dig(request_policy, cmd_spec.response_policy)
+        RoutingTable.find_policy_action(request_policy, cmd_spec.response_policy)
       end
 
       def send_command_to_all_nodes(method, command, args, &block)

data/lib/redis_client/cluster_config.rb

@@ -6,6 +6,7 @@ require 'redis_client/cluster'
 require 'redis_client/cluster/errors'
 require 'redis_client/cluster/node_key'
 require 'redis_client/cluster/noop_command_builder'
+require 'redis_client/cluster/router/routing_table'
 require 'redis_client/command_builder'
 
 class RedisClient
@@ -25,10 +26,18 @@ class RedisClient
     SLOW_COMMAND_TIMEOUT = Float(ENV.fetch('REDIS_CLIENT_SLOW_COMMAND_TIMEOUT', -1))
     # Controls the balance between startup load and stability during initialization or cluster state changes.
     MAX_STARTUP_SAMPLE = Integer(ENV.fetch('REDIS_CLIENT_MAX_STARTUP_SAMPLE', 3))
+    VALID_COMMAND_ROUTING_KEYS = %i[request_policy response_policy].freeze
+    # Routing these could wedge the state of the connections in the pool,
+    # e.g. leave them inside a MULTI or a subscription.
+    UNSAFE_COMMAND_ROUTINGS = %w[
+      multi exec discard watch unwatch
+      subscribe unsubscribe psubscribe punsubscribe ssubscribe sunsubscribe
+    ].freeze
 
     private_constant :DEFAULT_HOST, :DEFAULT_PORT, :DEFAULT_SCHEME, :SECURE_SCHEME, :DEFAULT_NODES,
                      :VALID_SCHEMES, :VALID_NODES_KEYS, :MERGE_CONFIG_KEYS, :IGNORE_GENERIC_CONFIG_KEYS,
-                     :MAX_WORKERS, :SLOW_COMMAND_TIMEOUT, :MAX_STARTUP_SAMPLE
+                     :MAX_WORKERS, :SLOW_COMMAND_TIMEOUT, :MAX_STARTUP_SAMPLE,
+                     :VALID_COMMAND_ROUTING_KEYS, :UNSAFE_COMMAND_ROUTINGS
 
     InvalidClientConfigError = Class.new(::RedisClient::Cluster::Error)
 
@@ -39,9 +48,9 @@ class RedisClient
     private_constant :SENSITIVE_INSPECT_KEYS, :INSPECT_REDACTED_KEYS, :INSPECT_PLACEHOLDER
 
     attr_reader :command_builder, :client_config, :replica_affinity, :slow_command_timeout,
-                :connect_with_original_config, :startup_nodes, :max_startup_sample, :id
+                :connect_with_original_config, :startup_nodes, :max_startup_sample, :id, :command_routings
 
-    def initialize( # rubocop:disable Metrics/ParameterLists
+    def initialize( # rubocop:disable Metrics/ParameterLists, Metrics/AbcSize
       nodes: DEFAULT_NODES,
       replica: false,
       replica_affinity: :random,
@@ -52,6 +61,7 @@ class RedisClient
       slow_command_timeout: SLOW_COMMAND_TIMEOUT,
       command_builder: ::RedisClient::CommandBuilder,
       max_startup_sample: MAX_STARTUP_SAMPLE,
+      command_routings: nil,
       **client_config
     )
       @replica = true & replica
@@ -67,6 +77,7 @@ class RedisClient
       @client_implementation = client_implementation
       @slow_command_timeout = slow_command_timeout
       @max_startup_sample = max_startup_sample
+      @command_routings = normalize_command_routings(command_routings)
       @id = client_config[:id]
     end
 
@@ -197,6 +208,52 @@ class RedisClient
       raise InvalidClientConfigError, e.message
     end
 
+    def normalize_command_routings(routings)
+      return if routings.nil? || (routings.is_a?(Hash) && routings.empty?)
+      raise InvalidClientConfigError, "`command_routings` option must be a Hash: #{routings.class}" unless routings.is_a?(Hash)
+
+      routings.each_with_object({}) do |(name, value), acc|
+        acc[normalize_command_routing_name(name)] = normalize_command_routing_value(name, value)
+      end.freeze
+    end
+
+    def normalize_command_routing_name(name)
+      raise InvalidClientConfigError, "`command_routings` option includes an invalid command name: #{name.inspect}" unless name.is_a?(String) || name.is_a?(Symbol)
+
+      key = name.to_s.downcase
+      raise InvalidClientConfigError, '`command_routings` option includes an empty command name' if key.empty?
+      raise InvalidClientConfigError, "`command_routings` option can route a command, not a subcommand: #{name.inspect}" if key.match?(/\s/)
+      raise InvalidClientConfigError, "`command_routings` option can't route the command which changes the state of a connection: #{key}" if UNSAFE_COMMAND_ROUTINGS.include?(key)
+
+      -key
+    end
+
+    def normalize_command_routing_value(name, value)
+      return if value.nil? || (value.is_a?(Hash) && value.empty?)
+      raise InvalidClientConfigError, "`command_routings` option includes an invalid routing of #{name}: #{value.inspect}" unless value.is_a?(Hash)
+
+      normalize_command_routing_policies(name, value.transform_keys { |k| k.respond_to?(:to_sym) ? k.to_sym : k })
+    end
+
+    def normalize_command_routing_policies(name, policies)
+      unknown_keys = policies.keys - VALID_COMMAND_ROUTING_KEYS
+      raise InvalidClientConfigError, "`command_routings` option includes unknown keys of #{name}: #{unknown_keys.join(', ')}" unless unknown_keys.empty?
+      raise InvalidClientConfigError, "`command_routings` option needs the request_policy key of #{name}" if policies[:request_policy].nil?
+
+      build_command_routing_policies(name, policies[:request_policy], policies[:response_policy])
+    end
+
+    def build_command_routing_policies(name, request_policy, response_policy)
+      request_policy = -request_policy.to_s
+      response_policy = response_policy.nil? ? nil : -response_policy.to_s
+      if ::RedisClient::Cluster::Router::RoutingTable.find_policy_action(request_policy, response_policy).nil?
+        raise InvalidClientConfigError,
+              "`command_routings` option includes unsupported policies of #{name}: request_policy=#{request_policy}, response_policy=#{response_policy.inspect}"
+      end
+
+      { request_policy: request_policy, response_policy: response_policy }.freeze
+    end
+
     def merge_generic_config(client_config, node_configs)
       cfg = node_configs.first || {}
       client_config.reject { |k, _| IGNORE_GENERIC_CONFIG_KEYS.include?(k) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.16.6
+  version: 0.17.0
 platform: ruby
 authors:
 - Taishi Kasuga
@@ -51,6 +51,7 @@ files:
 - lib/redis_client/cluster/pipeline.rb
 - lib/redis_client/cluster/pub_sub.rb
 - lib/redis_client/cluster/router.rb
+- lib/redis_client/cluster/router/routing_table.rb
 - lib/redis_client/cluster/transaction.rb
 - lib/redis_client/cluster_config.rb
 - lib/redis_cluster_client.rb