redis-cluster-client 0.0.10 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86d73675660702eb937b5d27925248d16b64fe46306d49da0c2b89ee49b5dc34
-  data.tar.gz: d2472791161a5ba746cc29c504353dc0e8414c093a531ff1017653a5a354d7dd
+  metadata.gz: 367df4e02bcd425f14da73b2ff243dfdb7fd44c6cb565bcc46952b939057904f
+  data.tar.gz: bfdb8033d0695fe0389563ad563c8445f9624e99ef6315e7374ee7f2e440fe40
 SHA512:
-  metadata.gz: bd12c8ebbc013d36ead0ee5bb4f8914ad8e5dec4a302e1aa54890ba36abd2358376bc0329e94b859c9e5c5d71d1a07d11a2f9684db655fef375000e792ca5f0c
-  data.tar.gz: d05782f64503cc104ef789683448d967ca6d71355cdc8a1411e8a92ea98f9412ad94a7a411bc0a93ffffb5ff384f6d3fb6e48ef83cc07bf0fe907872045e2567
+  metadata.gz: 278740e8829a1def72a411552ed7c17d0d265930c81dfc2b967cfa325a74cdbdbd0adb832dacc77e4c86c8316648695b94044cb6fdf3dd3267617d5f18b95ec1
+  data.tar.gz: 007bf587198b7575dabee128c0500700ef0d10c7b699a632023ce4d80fa788d2a88e851748f041ab5f6453350d7de6f9d8c96bcbc798deec7acbf37b2700ea6a

data/lib/redis_client/cluster/command.rb

@@ -55,6 +55,10 @@ class RedisClient
         dig_details(command, :readonly)
       end
 
+      def exists?(name)
+        @details.key?(name.to_s.downcase)
+      end
+
       private
 
       def pick_details(details)
@@ -81,7 +85,7 @@ class RedisClient
         when 'memory'
           command[1].to_s.casecmp('usage').zero? ? 2 : 0
         when 'migrate'
-          command[3] == '""' ? determine_optional_key_position(command, 'keys') : 3
+          command[3].empty? ? determine_optional_key_position(command, 'keys') : 3
         when 'xread', 'xreadgroup'
           determine_optional_key_position(command, 'streams')
         else

data/lib/redis_client/cluster/errors.rb

@@ -16,9 +16,9 @@ class RedisClient
     class OrchestrationCommandNotSupported < ::RedisClient::Error
       def initialize(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 '\
+        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)
       end
@@ -49,8 +49,8 @@ class RedisClient
     class NodeMightBeDown < ::RedisClient::Error
       def initialize(_ = '')
         super(
-          'The client is trying to fetch the latest cluster state '\
-          'because a subset of nodes might be down. '\
+          'The client is trying to fetch the latest cluster state ' \
+          'because a subset of nodes might be down. ' \
           'It might continue to raise errors for a while.'
         )
       end

data/lib/redis_client/cluster/node.rb

@@ -77,9 +77,8 @@ class RedisClient
               arr[8] = []
               next
             end
-
-            arr[8] = arr[8].split(',').map { |r| r.split('-').map { |s| Integer(s) } }
-            arr[8] = arr[8].map { |a| a.size == 1 ? a << a.first : a }.map(&:sort)
+            arr[8] = arr[8..].filter_map { |str| str.start_with?('[') ? nil : str.split('-').map { |s| Integer(s) } }
+                             .map { |a| a.size == 1 ? a << a.first : a }.map(&:sort)
           end
 
           rows.map do |arr|
@@ -181,7 +180,7 @@ class RedisClient
       def scale_reading_clients
         keys = replica_disabled? ? @replications.keys : @replications.values.map(&:first)
         @clients.select { |k, _| keys.include?(k) }.values.sort_by do |client|
-          ::RedisClient::Cluster::NodeKey.build_from_host_port(client.config.host, client.config.port)
+          "#{client.config.host}-#{client.config.port}"
         end
       end
 

data/lib/redis_client/cluster/pipeline.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'redis_client'
+require 'redis_client/cluster/errors'
+
+class RedisClient
+  class Cluster
+    class Pipeline
+      ReplySizeError = Class.new(::RedisClient::Error)
+
+      def initialize(router)
+        @router = router
+        @grouped = Hash.new([].freeze)
+        @size = 0
+      end
+
+      def call(*command, **kwargs)
+        node_key = @router.find_node_key(*command, primary_only: true, **kwargs)
+        @grouped[node_key] += [[@size, :call, command, kwargs]]
+        @size += 1
+      end
+
+      def call_once(*command, **kwargs)
+        node_key = @router.find_node_key(*command, primary_only: true, **kwargs)
+        @grouped[node_key] += [[@size, :call_once, command, kwargs]]
+        @size += 1
+      end
+
+      def blocking_call(timeout, *command, **kwargs)
+        node_key = @router.find_node_key(*command, primary_only: true, **kwargs)
+        @grouped[node_key] += [[@size, :blocking_call, timeout, command, kwargs]]
+        @size += 1
+      end
+
+      def empty?
+        @size.zero?
+      end
+
+      # TODO: https://github.com/redis-rb/redis-cluster-client/issues/37 handle redirections
+      def execute # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        all_replies = Array.new(@size)
+        errors = {}
+        threads = @grouped.map do |k, v|
+          Thread.new(@router, k, v) do |router, node_key, rows|
+            Thread.pass
+            replies = router.find_node(node_key).pipelined do |pipeline|
+              rows.each do |row|
+                case row[1]
+                when :call then pipeline.call(*row[2], **row[3])
+                when :call_once then pipeline.call_once(*row[2], **row[3])
+                when :blocking_call then pipeline.blocking_call(row[2], *row[3], **row[4])
+                else raise NotImplementedError, row[1]
+                end
+              end
+            end
+
+            raise ReplySizeError, "commands: #{rows.size}, replies: #{replies.size}" if rows.size != replies.size
+
+            rows.each_with_index { |row, idx| all_replies[row.first] = replies[idx] }
+          rescue StandardError => e
+            errors[node_key] = e
+          end
+        end
+
+        threads.each(&:join)
+        return all_replies if errors.empty?
+
+        raise ::RedisClient::Cluster::ErrorCollection, errors
+      end
+    end
+  end
+end

data/lib/redis_client/cluster/pub_sub.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class RedisClient
+  class Cluster
+    class PubSub
+      def initialize(router)
+        @router = router
+        @pubsub = nil
+      end
+
+      def call(*command, **kwargs)
+        close
+        @pubsub = @router.assign_node(*command, **kwargs).pubsub
+        @pubsub.call(*command, **kwargs)
+      end
+
+      def close
+        @pubsub&.close
+        @pubsub = nil
+      end
+
+      def next_event(timeout = nil)
+        @pubsub&.next_event(timeout)
+      end
+    end
+  end
+end

data/lib/redis_client/cluster/router.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require 'redis_client'
+require 'redis_client/cluster/command'
+require 'redis_client/cluster/errors'
+require 'redis_client/cluster/key_slot_converter'
+require 'redis_client/cluster/node'
+require 'redis_client/cluster/node_key'
+
+class RedisClient
+  class Cluster
+    class Router
+      ZERO_CURSOR_FOR_SCAN = '0'
+
+      attr_reader :node
+
+      def initialize(config, pool: nil, **kwargs)
+        @config = config.dup
+        @pool = pool
+        @client_kwargs = kwargs
+        @node = fetch_cluster_info(@config, pool: @pool, **@client_kwargs)
+        @command = ::RedisClient::Cluster::Command.load(@node)
+        @command_builder = @config.command_builder
+        @mutex = Mutex.new
+      end
+
+      def send_command(method, *args, **kwargs, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        command = method == :blocking_call && args.size > 1 ? args[1..] : args
+        command = @command_builder.generate!(command, kwargs)
+
+        cmd = command.first.to_s.downcase
+        case cmd
+        when 'acl', 'auth', 'bgrewriteaof', 'bgsave', 'quit', 'save'
+          @node.call_all(method, *args, **kwargs, &block).first
+        when 'flushall', 'flushdb'
+          @node.call_primaries(method, *args, **kwargs, &block).first
+        when 'ping'     then @node.send_ping(method, *args, **kwargs, &block).first
+        when 'wait'     then send_wait_command(method, *args, **kwargs, &block)
+        when 'keys'     then @node.call_replicas(method, *args, **kwargs, &block).flatten.sort_by(&:to_s)
+        when 'dbsize'   then @node.call_replicas(method, *args, **kwargs, &block).select { |e| e.is_a?(Integer) }.sum
+        when 'scan'     then scan(*command, **kwargs)
+        when 'lastsave' then @node.call_all(method, *args, **kwargs, &block).sort_by(&:to_i)
+        when 'role'     then @node.call_all(method, *args, **kwargs, &block)
+        when 'config'   then send_config_command(method, *args, **kwargs, &block)
+        when 'client'   then send_client_command(method, *args, **kwargs, &block)
+        when 'cluster'  then send_cluster_command(method, *args, **kwargs, &block)
+        when 'readonly', 'readwrite', 'shutdown'
+          raise ::RedisClient::Cluster::OrchestrationCommandNotSupported, cmd
+        when 'memory'   then send_memory_command(method, *args, **kwargs, &block)
+        when 'script'   then send_script_command(method, *args, **kwargs, &block)
+        when 'pubsub'   then send_pubsub_command(method, *args, **kwargs, &block)
+        when 'discard', 'exec', 'multi', 'unwatch'
+          raise ::RedisClient::Cluster::AmbiguousNodeError, cmd
+        else
+          node = assign_node(*command)
+          try_send(node, method, *args, **kwargs, &block)
+        end
+      rescue ::RedisClient::Cluster::Node::ReloadNeeded
+        update_cluster_info!
+        raise ::RedisClient::Cluster::NodeMightBeDown
+      rescue ::RedisClient::Cluster::ErrorCollection => e
+        update_cluster_info! if e.errors.values.any? do |err|
+          err.message.start_with?('CLUSTERDOWN Hash slot not served')
+        end
+        raise
+      end
+
+      # @see https://redis.io/topics/cluster-spec#redirection-and-resharding
+      #   Redirection and resharding
+      def try_send(node, method, *args, retry_count: 3, **kwargs, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        node.send(method, *args, **kwargs, &block)
+      rescue ::RedisClient::CommandError => e
+        raise if retry_count <= 0
+
+        if e.message.start_with?('MOVED')
+          node = assign_redirection_node(e.message)
+          retry_count -= 1
+          retry
+        elsif e.message.start_with?('ASK')
+          node = assign_asking_node(e.message)
+          node.call('ASKING')
+          retry_count -= 1
+          retry
+        elsif e.message.start_with?('CLUSTERDOWN Hash slot not served')
+          update_cluster_info!
+          retry_count -= 1
+          retry
+        else
+          raise
+        end
+      rescue ::RedisClient::ConnectionError
+        raise if retry_count <= 0
+
+        update_cluster_info!
+        retry_count -= 1
+        retry
+      end
+
+      def scan(*command, **kwargs) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        command = @command_builder.generate!(command, kwargs)
+
+        command[1] = ZERO_CURSOR_FOR_SCAN if command.size == 1
+        input_cursor = Integer(command[1])
+
+        client_index = input_cursor % 256
+        raw_cursor = input_cursor >> 8
+
+        clients = @node.scale_reading_clients
+
+        client = clients[client_index]
+        return [ZERO_CURSOR_FOR_SCAN, []] unless client
+
+        command[1] = raw_cursor.to_s
+
+        result_cursor, result_keys = client.call(*command, **kwargs)
+        result_cursor = Integer(result_cursor)
+
+        client_index += 1 if result_cursor == 0
+
+        [((result_cursor << 8) + client_index).to_s, result_keys]
+      end
+
+      def assign_node(*command, **kwargs)
+        node_key = find_node_key(*command, **kwargs)
+        find_node(node_key)
+      end
+
+      def find_node_key(*command, primary_only: false, **kwargs)
+        command = @command_builder.generate!(command, kwargs)
+
+        key = @command.extract_first_key(command)
+        slot = key.empty? ? nil : ::RedisClient::Cluster::KeySlotConverter.convert(key)
+
+        if @command.should_send_to_primary?(command) || primary_only
+          @node.find_node_key_of_primary(slot) || @node.primary_node_keys.sample
+        else
+          @node.find_node_key_of_replica(slot) || @node.replica_node_keys.sample
+        end
+      end
+
+      def find_node(node_key, retry_count: 3)
+        @node.find_by(node_key)
+      rescue ::RedisClient::Cluster::Node::ReloadNeeded
+        raise ::RedieClient::Cluster::NodeMightBeDown if retry_count <= 0
+
+        update_cluster_info!
+        retry_count -= 1
+        retry
+      end
+
+      def command_exists?(name)
+        @command.exists?(name)
+      end
+
+      private
+
+      def send_wait_command(method, *args, retry_count: 3, **kwargs, &block)
+        @node.call_primaries(method, *args, **kwargs, &block).select { |r| r.is_a?(Integer) }.sum
+      rescue ::RedisClient::Cluster::ErrorCollection => e
+        raise if retry_count <= 0
+        raise if e.errors.values.none? do |err|
+          err.message.include?('WAIT cannot be used with replica instances')
+        end
+
+        update_cluster_info!
+        retry_count -= 1
+        retry
+      end
+
+      def send_config_command(method, *args, **kwargs, &block)
+        command = method == :blocking_call && args.size > 1 ? args[1..] : args
+        command = @command_builder.generate!(command, kwargs)
+
+        case command[1].to_s.downcase
+        when 'resetstat', 'rewrite', 'set'
+          @node.call_all(method, *args, **kwargs, &block).first
+        else assign_node(*command).send(method, *args, **kwargs, &block)
+        end
+      end
+
+      def send_memory_command(method, *args, **kwargs, &block)
+        command = method == :blocking_call && args.size > 1 ? args[1..] : args
+        command = @command_builder.generate!(command, kwargs)
+
+        case command[1].to_s.downcase
+        when 'stats' then @node.call_all(method, *args, **kwargs, &block)
+        when 'purge' then @node.call_all(method, *args, **kwargs, &block).first
+        else assign_node(*command).send(method, *args, **kwargs, &block)
+        end
+      end
+
+      def send_client_command(method, *args, **kwargs, &block)
+        command = method == :blocking_call && args.size > 1 ? args[1..] : args
+        command = @command_builder.generate!(command, kwargs)
+
+        case command[1].to_s.downcase
+        when 'list' then @node.call_all(method, *args, **kwargs, &block).flatten
+        when 'pause', 'reply', 'setname'
+          @node.call_all(method, *args, **kwargs, &block).first
+        else assign_node(*command).send(method, *args, **kwargs, &block)
+        end
+      end
+
+      def send_cluster_command(method, *args, **kwargs, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        command = method == :blocking_call && args.size > 1 ? args[1..] : args
+        command = @command_builder.generate!(command, kwargs)
+        subcommand = command[1].to_s.downcase
+
+        case subcommand
+        when 'addslots', 'delslots', 'failover', 'forget', 'meet', 'replicate',
+             'reset', 'set-config-epoch', 'setslot'
+          raise ::RedisClient::Cluster::OrchestrationCommandNotSupported, ['cluster', subcommand]
+        when 'saveconfig' then @node.call_all(method, *args, **kwargs, &block).first
+        when 'getkeysinslot'
+          raise ArgumentError, command.join(' ') if command.size != 4
+
+          find_node(@node.find_node_key_of_replica(command[2])).send(method, *args, **kwargs, &block)
+        else assign_node(*command).send(method, *args, **kwargs, &block)
+        end
+      end
+
+      def send_script_command(method, *args, **kwargs, &block)
+        command = method == :blocking_call && args.size > 1 ? args[1..] : args
+        command = @command_builder.generate!(command, kwargs)
+
+        case command[1].to_s.downcase
+        when 'debug', 'kill'
+          @node.call_all(method, *args, **kwargs, &block).first
+        when 'flush', 'load'
+          @node.call_primaries(method, *args, **kwargs, &block).first
+        else assign_node(*command).send(method, *args, **kwargs, &block)
+        end
+      end
+
+      def send_pubsub_command(method, *args, **kwargs, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        command = method == :blocking_call && args.size > 1 ? args[1..] : args
+        command = @command_builder.generate!(command, kwargs)
+
+        case command[1].to_s.downcase
+        when 'channels' then @node.call_all(method, *args, **kwargs, &block).flatten.uniq.sort_by(&:to_s)
+        when 'numsub'
+          @node.call_all(method, *args, **kwargs, &block).reject(&:empty?).map { |e| Hash[*e] }
+               .reduce({}) { |a, e| a.merge(e) { |_, v1, v2| v1 + v2 } }
+        when 'numpat' then @node.call_all(method, *args, **kwargs, &block).select { |e| e.is_a?(Integer) }.sum
+        else assign_node(*command).send(method, *args, **kwargs, &block)
+        end
+      end
+
+      def assign_redirection_node(err_msg)
+        _, slot, node_key = err_msg.split
+        slot = slot.to_i
+        @node.update_slot(slot, node_key)
+        find_node(node_key)
+      end
+
+      def assign_asking_node(err_msg)
+        _, _, node_key = err_msg.split
+        find_node(node_key)
+      end
+
+      def fetch_cluster_info(config, pool: nil, **kwargs)
+        node_info = ::RedisClient::Cluster::Node.load_info(config.per_node_key, **kwargs)
+        node_addrs = node_info.map { |info| ::RedisClient::Cluster::NodeKey.hashify(info[:node_key]) }
+        config.update_node(node_addrs)
+        ::RedisClient::Cluster::Node.new(config.per_node_key,
+                                         node_info: node_info, pool: pool, with_replica: config.use_replica?, **kwargs)
+      end
+
+      def update_cluster_info!
+        @mutex.synchronize do
+          begin
+            @node.call_all(:close)
+          rescue ::RedisClient::Cluster::ErrorCollection
+            # ignore
+          end
+
+          @node = fetch_cluster_info(@config, pool: @pool, **@client_kwargs)
+        end
+      end
+    end
+  end
+end

data/lib/redis_client/cluster.rb

@@ -1,133 +1,32 @@
 # frozen_string_literal: true
 
 require 'redis_client'
-require 'redis_client/cluster/command'
-require 'redis_client/cluster/errors'
-require 'redis_client/cluster/key_slot_converter'
-require 'redis_client/cluster/node'
-require 'redis_client/cluster/node_key'
+require 'redis_client/cluster/pipeline'
+require 'redis_client/cluster/pub_sub'
+require 'redis_client/cluster/router'
 
 class RedisClient
   class Cluster
-    class Pipeline
-      ReplySizeError = Class.new(::RedisClient::Error)
-
-      def initialize(client)
-        @client = client
-        @grouped = Hash.new([].freeze)
-        @size = 0
-      end
-
-      def call(*command, **kwargs)
-        node_key = @client.send(:find_node_key, *command, primary_only: true)
-        @grouped[node_key] += [[@size, :call, command, kwargs]]
-        @size += 1
-      end
-
-      def call_once(*command, **kwargs)
-        node_key = @client.send(:find_node_key, *command, primary_only: true)
-        @grouped[node_key] += [[@size, :call_once, command, kwargs]]
-        @size += 1
-      end
-
-      def blocking_call(timeout, *command, **kwargs)
-        node_key = @client.send(:find_node_key, *command, primary_only: true)
-        @grouped[node_key] += [[@size, :blocking_call, timeout, command, kwargs]]
-        @size += 1
-      end
-
-      def empty?
-        @size.zero?
-      end
-
-      # TODO: https://github.com/redis-rb/redis-cluster-client/issues/37 handle redirections
-      def execute # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-        all_replies = Array.new(@size)
-        errors = {}
-        threads = @grouped.map do |k, v|
-          Thread.new(@client, k, v) do |client, node_key, rows|
-            Thread.pass
-            replies = client.send(:find_node, node_key).pipelined do |pipeline|
-              rows.each do |row|
-                case row[1]
-                when :call then pipeline.call(*row[2], **row[3])
-                when :call_once then pipeline.call_once(*row[2], **row[3])
-                when :blocking_call then pipeline.blocking_call(row[2], *row[3], **row[4])
-                else raise NotImplementedError, row[1]
-                end
-              end
-            end
-
-            raise ReplySizeError, "commands: #{rows.size}, replies: #{replies.size}" if rows.size != replies.size
-
-            rows.each_with_index { |row, idx| all_replies[row.first] = replies[idx] }
-          rescue StandardError => e
-            errors[node_key] = e
-          end
-        end
-
-        threads.each(&:join)
-        return all_replies if errors.empty?
-
-        raise ::RedisClient::Cluster::ErrorCollection, errors
-      end
-    end
-
-    class PubSub
-      def initialize(client)
-        @client = client
-        @pubsub = nil
-      end
-
-      def call(*command, **kwargs)
-        close
-        @pubsub = @client.send(:assign_node, *command).pubsub
-        @pubsub.call(*command, **kwargs)
-      end
-
-      def close
-        @pubsub&.close
-        @pubsub = nil
-      end
-
-      def next_event(timeout = nil)
-        @pubsub&.next_event(timeout)
-      end
-    end
-
     ZERO_CURSOR_FOR_SCAN = '0'
-    CMD_SCAN = 'SCAN'
-    CMD_SSCAN = 'SSCAN'
-    CMD_HSCAN = 'HSCAN'
-    CMD_ZSCAN = 'ZSCAN'
-    CMD_ASKING = 'ASKING'
-    REPLY_OK = 'OK'
-    REPLY_MOVED = 'MOVED'
-    REPLY_ASK = 'ASK'
 
     def initialize(config, pool: nil, **kwargs)
-      @config = config.dup
-      @pool = pool
-      @client_kwargs = kwargs
-      @node = fetch_cluster_info!(@config, pool: @pool, **@client_kwargs)
-      @command = ::RedisClient::Cluster::Command.load(@node)
-      @mutex = Mutex.new
+      @router = ::RedisClient::Cluster::Router.new(config, pool: pool, **kwargs)
     end
 
     def inspect
-      "#<#{self.class.name} #{@node.node_keys.join(', ')}>"
+      "#<#{self.class.name} #{@router.node.node_keys.join(', ')}>"
     end
 
-    def call(*command, **kwargs)
-      send_command(:call, *command, **kwargs)
+    def call(*command, **kwargs, &block)
+      @router.send_command(:call, *command, **kwargs, &block)
     end
 
-    def call_once(*command, **kwargs)
-      send_command(:call_once, *command, **kwargs)
+    def call_once(*command, **kwargs, &block)
+      @router.send_command(:call_once, *command, **kwargs, &block)
     end
 
-    def blocking_call(timeout, *command, **kwargs)
-      send_command(:blocking_call, timeout, *command, **kwargs)
+    def blocking_call(timeout, *command, **kwargs, &block)
+      @router.send_command(:blocking_call, timeout, *command, **kwargs, &block)
     end
 
     def scan(*args, **kwargs, &block)
@@ -135,29 +34,29 @@ class RedisClient
 
       cursor = ZERO_CURSOR_FOR_SCAN
       loop do
-        cursor, keys = _scan(CMD_SCAN, cursor, *args, **kwargs)
+        cursor, keys = @router.scan('SCAN', cursor, *args, **kwargs)
         keys.each(&block)
         break if cursor == ZERO_CURSOR_FOR_SCAN
       end
     end
 
     def sscan(key, *args, **kwargs, &block)
-      node = assign_node(CMD_SSCAN, key)
-      try_send(node, :sscan, key, *args, **kwargs, &block)
+      node = @router.assign_node('SSCAN', key)
+      @router.try_send(node, :sscan, key, *args, **kwargs, &block)
     end
 
     def hscan(key, *args, **kwargs, &block)
-      node = assign_node(CMD_HSCAN, key)
-      try_send(node, :hscan, key, *args, **kwargs, &block)
+      node = @router.assign_node('HSCAN', key)
+      @router.try_send(node, :hscan, key, *args, **kwargs, &block)
     end
 
     def zscan(key, *args, **kwargs, &block)
-      node = assign_node(CMD_ZSCAN, key)
-      try_send(node, :zscan, key, *args, **kwargs, &block)
+      node = @router.assign_node('ZSCAN', key)
+      @router.try_send(node, :zscan, key, *args, **kwargs, &block)
     end
 
     def pipelined
-      pipeline = ::RedisClient::Cluster::Pipeline.new(self)
+      pipeline = ::RedisClient::Cluster::Pipeline.new(@router)
       yield pipeline
       return [] if pipeline.empty? == 0
 
@@ -165,239 +64,29 @@ class RedisClient
     end
 
     def pubsub
-      ::RedisClient::Cluster::PubSub.new(self)
+      ::RedisClient::Cluster::PubSub.new(@router)
     end
 
     def close
-      @node.call_all(:close)
+      @router.node.call_all(:close)
       nil
-    rescue StandardError
-      # ignore
     end
 
     private
 
-    def fetch_cluster_info!(config, pool: nil, **kwargs)
-      node_info = ::RedisClient::Cluster::Node.load_info(config.per_node_key, **kwargs)
-      node_addrs = node_info.map { |info| ::RedisClient::Cluster::NodeKey.hashify(info[:node_key]) }
-      config.update_node(node_addrs)
-      ::RedisClient::Cluster::Node.new(config.per_node_key,
-                                       node_info: node_info, pool: pool, with_replica: config.use_replica?, **kwargs)
-    end
-
-    def send_command(method, *args, **kwargs, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-      command = method == :blocking_call && args.size > 1 ? args[1..] : args
-
-      cmd = command.first.to_s.downcase
-      case cmd
-      when 'acl', 'auth', 'bgrewriteaof', 'bgsave', 'quit', 'save'
-        @node.call_all(method, *args, **kwargs, &block).first
-      when 'flushall', 'flushdb'
-        @node.call_primaries(method, *args, **kwargs, &block).first
-      when 'ping'     then @node.send_ping(method, *args, **kwargs, &block).first
-      when 'wait'     then send_wait_command(method, *args, **kwargs, &block)
-      when 'keys'     then @node.call_replicas(method, *args, **kwargs, &block).flatten.sort
-      when 'dbsize'   then @node.call_replicas(method, *args, **kwargs, &block).sum
-      when 'scan'     then _scan(*command, **kwargs)
-      when 'lastsave' then @node.call_all(method, *args, **kwargs, &block).sort
-      when 'role'     then @node.call_all(method, *args, **kwargs, &block)
-      when 'config'   then send_config_command(method, *args, **kwargs, &block)
-      when 'client'   then send_client_command(method, *args, **kwargs, &block)
-      when 'cluster'  then send_cluster_command(method, *args, **kwargs, &block)
-      when 'readonly', 'readwrite', 'shutdown'
-        raise ::RedisClient::Cluster::OrchestrationCommandNotSupported, cmd
-      when 'memory'   then send_memory_command(method, *args, **kwargs, &block)
-      when 'script'   then send_script_command(method, *args, **kwargs, &block)
-      when 'pubsub'   then send_pubsub_command(method, *args, **kwargs, &block)
-      when 'discard', 'exec', 'multi', 'unwatch'
-        raise ::RedisClient::Cluster::AmbiguousNodeError, cmd
-      else
-        node = assign_node(*command)
-        try_send(node, method, *args, **kwargs, &block)
-      end
-    rescue RedisClient::Cluster::Node::ReloadNeeded
-      update_cluster_info!
-      raise ::RedisClient::Cluster::NodeMightBeDown
-    end
-
-    def send_wait_command(method, *args, retry_count: 3, **kwargs, &block)
-      @node.call_primaries(method, *args, **kwargs, &block).sum
-    rescue RedisClient::Cluster::ErrorCollection => e
-      raise if retry_count <= 0
-      raise if e.errors.values.none? do |err|
-        err.message.include?('WAIT cannot be used with replica instances')
+    def method_missing(name, *args, **kwargs, &block)
+      if @router.command_exists?(name)
+        args.unshift(name)
+        return @router.send_command(:call, *args, **kwargs, &block)
       end
 
-      update_cluster_info!
-      retry_count -= 1
-      retry
+      super
     end
 
-    def send_config_command(method, *args, **kwargs, &block)
-      command = method == :blocking_call && args.size > 1 ? args[1..] : args
+    def respond_to_missing?(name, include_private = false)
+      return true if @router.command_exists?(name)
 
-      case command[1].to_s.downcase
-      when 'resetstat', 'rewrite', 'set'
-        @node.call_all(method, *args, **kwargs, &block).first
-      else assign_node(*command).send(method, *args, **kwargs, &block)
-      end
-    end
-
-    def send_memory_command(method, *args, **kwargs, &block)
-      command = method == :blocking_call && args.size > 1 ? args[1..] : args
-
-      case command[1].to_s.downcase
-      when 'stats' then @node.call_all(method, *args, **kwargs, &block)
-      when 'purge' then @node.call_all(method, *args, **kwargs, &block).first
-      else assign_node(*command).send(method, *args, **kwargs, &block)
-      end
-    end
-
-    def send_client_command(method, *args, **kwargs, &block)
-      command = method == :blocking_call && args.size > 1 ? args[1..] : args
-
-      case command[1].to_s.downcase
-      when 'list' then @node.call_all(method, *args, **kwargs, &block).flatten
-      when 'pause', 'reply', 'setname'
-        @node.call_all(method, *args, **kwargs, &block).first
-      else assign_node(*command).send(method, *args, **kwargs, &block)
-      end
-    end
-
-    def send_cluster_command(method, *args, **kwargs, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      command = method == :blocking_call && args.size > 1 ? args[1..] : args
-      subcommand = command[1].to_s.downcase
-
-      case subcommand
-      when 'addslots', 'delslots', 'failover', 'forget', 'meet', 'replicate',
-           'reset', 'set-config-epoch', 'setslot'
-        raise ::RedisClient::Cluster::OrchestrationCommandNotSupported, ['cluster', subcommand]
-      when 'saveconfig' then @node.call_all(method, *args, **kwargs, &block).first
-      when 'getkeysinslot'
-        raise ArgumentError, command.join(' ') if command.size != 4
-
-        find_node(@node.find_node_key_of_replica(command[2])).send(method, *args, **kwargs, &block)
-      else assign_node(*command).send(method, *args, **kwargs, &block)
-      end
-    end
-
-    def send_script_command(method, *args, **kwargs, &block)
-      command = method == :blocking_call && args.size > 1 ? args[1..] : args
-
-      case command[1].to_s.downcase
-      when 'debug', 'kill'
-        @node.call_all(method, *args, **kwargs, &block).first
-      when 'flush', 'load'
-        @node.call_primaries(method, *args, **kwargs, &block).first
-      else assign_node(*command).send(method, *args, **kwargs, &block)
-      end
-    end
-
-    def send_pubsub_command(method, *args, **kwargs, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      command = method == :blocking_call && args.size > 1 ? args[1..] : args
-
-      case command[1].to_s.downcase
-      when 'channels' then @node.call_all(method, *args, **kwargs, &block).flatten.uniq.sort
-      when 'numsub'
-        @node.call_all(method, *args, **kwargs, &block).reject(&:empty?).map { |e| Hash[*e] }
-             .reduce({}) { |a, e| a.merge(e) { |_, v1, v2| v1 + v2 } }
-      when 'numpat' then @node.call_all(method, *args, **kwargs, &block).sum
-      else assign_node(*command).send(method, *args, **kwargs, &block)
-      end
-    end
-
-    # @see https://redis.io/topics/cluster-spec#redirection-and-resharding
-    #   Redirection and resharding
-    def try_send(node, method, *args, retry_count: 3, **kwargs, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      node.send(method, *args, **kwargs, &block)
-    rescue ::RedisClient::CommandError => e
-      raise if retry_count <= 0
-
-      if e.message.start_with?(REPLY_MOVED)
-        node = assign_redirection_node(e.message)
-        retry_count -= 1
-        retry
-      elsif e.message.start_with?(REPLY_ASK)
-        node = assign_asking_node(e.message)
-        node.call(CMD_ASKING)
-        retry_count -= 1
-        retry
-      else
-        raise
-      end
-    rescue ::RedisClient::ConnectionError
-      raise if retry_count <= 0
-
-      update_cluster_info!
-      retry_count -= 1
-      retry
-    end
-
-    def _scan(*command, **kwargs) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      command[1] = ZERO_CURSOR_FOR_SCAN if command.size == 1
-      input_cursor = Integer(command[1])
-
-      client_index = input_cursor % 256
-      raw_cursor = input_cursor >> 8
-
-      clients = @node.scale_reading_clients
-
-      client = clients[client_index]
-      return [ZERO_CURSOR_FOR_SCAN, []] unless client
-
-      command[1] = raw_cursor.to_s
-
-      result_cursor, result_keys = client.call(*command, **kwargs)
-      result_cursor = Integer(result_cursor)
-
-      client_index += 1 if result_cursor == 0
-
-      [((result_cursor << 8) + client_index).to_s, result_keys]
-    end
-
-    def assign_redirection_node(err_msg)
-      _, slot, node_key = err_msg.split
-      slot = slot.to_i
-      @node.update_slot(slot, node_key)
-      find_node(node_key)
-    end
-
-    def assign_asking_node(err_msg)
-      _, _, node_key = err_msg.split
-      find_node(node_key)
-    end
-
-    def assign_node(*command)
-      node_key = find_node_key(*command)
-      find_node(node_key)
-    end
-
-    def find_node_key(*command, primary_only: false)
-      key = @command.extract_first_key(command)
-      slot = key.empty? ? nil : ::RedisClient::Cluster::KeySlotConverter.convert(key)
-
-      if @command.should_send_to_primary?(command) || primary_only
-        @node.find_node_key_of_primary(slot) || @node.primary_node_keys.sample
-      else
-        @node.find_node_key_of_replica(slot) || @node.replica_node_keys.sample
-      end
-    end
-
-    def find_node(node_key, retry_count: 3)
-      @node.find_by(node_key)
-    rescue ::RedisClient::Cluster::Node::ReloadNeeded
-      raise ::RedieClient::Cluster::NodeMightBeDown if retry_count <= 0
-
-      update_cluster_info!
-      retry_count -= 1
-      retry
-    end
-
-    def update_cluster_info!
-      @mutex.synchronize do
-        close
-        @node = fetch_cluster_info!(@config, pool: @pool, **@client_kwargs)
-      end
+      super
     end
   end
 end

data/lib/redis_client/cluster_config.rb

@@ -4,6 +4,7 @@ require 'uri'
 require 'redis_client'
 require 'redis_client/cluster'
 require 'redis_client/cluster/node_key'
+require 'redis_client/command_builder'
 
 class RedisClient
   class ClusterConfig
@@ -19,11 +20,14 @@ class RedisClient
 
     InvalidClientConfigError = Class.new(::RedisClient::Error)
 
+    attr_reader :command_builder
+
     def initialize(nodes: DEFAULT_NODES, replica: false, fixed_hostname: '', **client_config)
       @replica = true & replica
       @fixed_hostname = fixed_hostname.to_s
       @node_configs = build_node_configs(nodes.dup)
       client_config = client_config.reject { |k, _| IGNORE_GENERIC_CONFIG_KEYS.include?(k) }
+      @command_builder = client_config.fetch(:command_builder, ::RedisClient::CommandBuilder)
       @client_config = merge_generic_config(client_config, @node_configs)
       @mutex = Mutex.new
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.1.0
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-22 00:00:00.000000000 Z
+date: 2022-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -37,6 +37,9 @@ files:
 - lib/redis_client/cluster/key_slot_converter.rb
 - lib/redis_client/cluster/node.rb
 - lib/redis_client/cluster/node_key.rb
+- lib/redis_client/cluster/pipeline.rb
+- lib/redis_client/cluster/pub_sub.rb
+- lib/redis_client/cluster/router.rb
 - lib/redis_client/cluster_config.rb
 - lib/redis_cluster_client.rb
 homepage: https://github.com/redis-rb/redis-cluster-client