redis-cluster-client 0.0.8 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d13300ba8c7f294d3e4c86932d13775ad22060c172900c01d521b1ed8c2278d6
-  data.tar.gz: d5b457978bb312a718ba57b48b56fac1ceb07a463889835c8190794007ecbf7d
+  metadata.gz: d7c3e9a3b764d9e5fc52670d17c175ee9ccda2dcd56b4a977b0e9a1e0b71d972
+  data.tar.gz: 191e1fe163f6f2fd111e4b2f69638aa28462d74e002f1ff0a11fc0f52cc740cd
 SHA512:
-  metadata.gz: 37fb06428eed5a9cca5b42d27c034f057dd7d6f0c5d0c17e4b42c60a8fa3711127c5ed81f06e0565331f64aa762ccc30ee6674fb541e56a8b322ee50ab7a75ce
-  data.tar.gz: 06d46f93c8c7b7116378d2ef9e4380ccce3aac74c071b709cbacd677ec0b302302b52160c04b2c3523771f69446b96d84e8b4f729765073386c5e5f1f3f27f5b
+  metadata.gz: a42c6a871302686e33026ed570575d5b51637b707501609fdf9e574a5a976e06af388bc69bebd5bb22a58a30741c4b3e43d883d154782675446ce88c49ac2b37
+  data.tar.gz: e2ae0a6dd3af75407cc4d795492afff75e5bc7c01fee84be2ef0761e67dda0d9f93cc103b99219bd1b5e8df9dc3ff1dc86b3406c3a23dc1d011b649c363ab163

data/lib/redis_client/cluster/command.rb

@@ -7,15 +7,21 @@ class RedisClient
   class Cluster
     class Command
       class << self
-        def load(nodes)
-          errors = nodes&.map do |node|
+        def load(nodes) # rubocop:disable Metrics/MethodLength
+          errors = []
+          cmd = nil
+          nodes&.each do |node|
+            break unless cmd.nil?
+
             reply = node.call('COMMAND')
             details = parse_command_details(reply)
-            return ::RedisClient::Cluster::Command.new(details)
-          rescue ::RedisClient::ConnectionError, ::RedisClient::CommandError => e
-            e
+            cmd = ::RedisClient::Cluster::Command.new(details)
+          rescue ::RedisClient::Error => e
+            errors << e
           end
 
+          return cmd unless cmd.nil?
+
           raise ::RedisClient::Cluster::InitialSetupError, errors
         end
 
@@ -75,7 +81,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

@@ -6,8 +6,6 @@ class RedisClient
   class Cluster
     ERR_ARG_NORMALIZATION = ->(arg) { Array[arg].flatten.reject { |e| e.nil? || (e.respond_to?(:empty?) && e.empty?) } }
 
-    # Raised when client connected to redis as cluster mode
-    # and failed to fetch cluster state information by commands.
     class InitialSetupError < ::RedisClient::Error
       def initialize(errors)
         msg = ERR_ARG_NORMALIZATION.call(errors).map(&:message).uniq.join(',')
@@ -15,20 +13,17 @@ class RedisClient
       end
     end
 
-    # Raised when client connected to redis as cluster mode
-    # and some cluster subcommands were called.
     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
     end
 
-    # Raised when error occurs on any node of cluster.
     class ErrorCollection < ::RedisClient::Error
       attr_reader :errors
 
@@ -41,11 +36,10 @@ class RedisClient
 
         @errors = errors
         messages = @errors.map { |node_key, error| "#{node_key}: #{error.message}" }
-        super("Command errors were replied on any node: #{messages.join(', ')}")
+        super("Errors occurred on any node: #{messages.join(', ')}")
       end
     end
 
-    # Raised when cluster client can't select node.
     class AmbiguousNodeError < ::RedisClient::Error
       def initialize(command)
         super("Cluster client doesn't know which node the #{command} command should be sent to.")
@@ -55,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|
@@ -102,7 +101,7 @@ class RedisClient
       end
 
       def each(&block)
-        @clients.values.each(&block)
+        @clients.each_value(&block)
       end
 
       def sample
@@ -129,9 +128,9 @@ class RedisClient
         @clients.fetch(node_key)
       end
 
-      def call_all(method, *command, **kwargs, &block)
+      def call_all(method, *args, **kwargs, &block)
         results, errors = try_map do |_, client|
-          client.send(method, *command, **kwargs, &block)
+          client.send(method, *args, **kwargs, &block)
         end
 
         return results.values if errors.empty?
@@ -139,11 +138,11 @@ class RedisClient
         raise ::RedisClient::Cluster::ErrorCollection, errors
       end
 
-      def call_primaries(method, *command, **kwargs, &block)
+      def call_primaries(method, *args, **kwargs, &block)
         results, errors = try_map do |node_key, client|
           next if replica?(node_key)
 
-          client.send(method, *command, **kwargs, &block)
+          client.send(method, *args, **kwargs, &block)
         end
 
         return results.values if errors.empty?
@@ -151,14 +150,14 @@ class RedisClient
         raise ::RedisClient::Cluster::ErrorCollection, errors
       end
 
-      def call_replicas(method, *command, **kwargs, &block)
-        return call_primaries(method, *command, **kwargs, &block) if replica_disabled?
+      def call_replicas(method, *args, **kwargs, &block)
+        return call_primaries(method, *args, **kwargs, &block) if replica_disabled?
 
         replica_node_keys = @replications.values.map(&:sample)
         results, errors = try_map do |node_key, client|
           next if primary?(node_key) || !replica_node_keys.include?(node_key)
 
-          client.send(method, *command, **kwargs, &block)
+          client.send(method, *args, **kwargs, &block)
         end
 
         return results.values if errors.empty?
@@ -166,9 +165,9 @@ class RedisClient
         raise ::RedisClient::Cluster::ErrorCollection, errors
       end
 
-      def send_ping(method, *command, **kwargs, &block)
+      def send_ping(method, *args, **kwargs, &block)
         results, errors = try_map do |_, client|
-          client.send(method, *command, **kwargs, &block)
+          client.send(method, *args, **kwargs, &block)
         end
 
         return results.values if errors.empty?
@@ -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)
+        @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)
+        @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)
+        @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).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,257 @@
+# 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)
+        @mutex = Mutex.new
+      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
+
+      # @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
+        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_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
+
+      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
+
+        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
+
+      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,134 +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)
+      @router.send_command(:call, *command, **kwargs)
     end
 
     def call_once(*command, **kwargs)
-      send_command(:call_once, *command, **kwargs)
+      @router.send_command(:call_once, *command, **kwargs)
     end
 
     def blocking_call(timeout, *command, **kwargs)
-      node = assign_node(*command)
-      try_send(node, :blocking_call, timeout, *command, **kwargs)
+      @router.send_command(:blocking_call, timeout, *command, **kwargs)
     end
 
     def scan(*args, **kwargs, &block)
@@ -136,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
 
@@ -166,225 +64,12 @@ 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, *command, **kwargs, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-      cmd = command.first.to_s.downcase
-      case cmd
-      when 'acl', 'auth', 'bgrewriteaof', 'bgsave', 'quit', 'save'
-        @node.call_all(method, *command, **kwargs, &block).first
-      when 'flushall', 'flushdb'
-        @node.call_primaries(method, *command, **kwargs, &block).first
-      when 'ping'     then @node.send_ping(method, *command, **kwargs, &block).first
-      when 'wait'     then send_wait_command(method, *command, **kwargs, &block)
-      when 'keys'     then @node.call_replicas(method, *command, **kwargs, &block).flatten.sort
-      when 'dbsize'   then @node.call_replicas(method, *command, **kwargs, &block).sum
-      when 'scan'     then _scan(*command, **kwargs)
-      when 'lastsave' then @node.call_all(method, *command, **kwargs, &block).sort
-      when 'role'     then @node.call_all(method, *command, **kwargs, &block)
-      when 'config'   then send_config_command(method, *command, **kwargs, &block)
-      when 'client'   then send_client_command(method, *command, **kwargs, &block)
-      when 'cluster'  then send_cluster_command(method, *command, **kwargs, &block)
-      when 'readonly', 'readwrite', 'shutdown'
-        raise ::RedisClient::Cluster::OrchestrationCommandNotSupported, cmd
-      when 'memory'   then send_memory_command(method, *command, **kwargs, &block)
-      when 'script'   then send_script_command(method, *command, **kwargs, &block)
-      when 'pubsub'   then send_pubsub_command(method, *command, **kwargs, &block)
-      when 'discard', 'exec', 'multi', 'unwatch'
-        raise ::RedisClient::Cluster::AmbiguousNodeError, cmd
-      else
-        node = assign_node(*command)
-        try_send(node, method, *command, **kwargs, &block)
-      end
-    rescue RedisClient::Cluster::Node::ReloadNeeded
-      update_cluster_info!
-      raise ::RedisClient::Cluster::NodeMightBeDown
-    end
-
-    def send_wait_command(method, *command, retry_count: 3, **kwargs, &block)
-      @node.call_primaries(method, *command, **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')
-      end
-
-      update_cluster_info!
-      retry_count -= 1
-      retry
-    end
-
-    def send_config_command(method, *command, **kwargs, &block)
-      case command[1].to_s.downcase
-      when 'resetstat', 'rewrite', 'set'
-        @node.call_all(method, *command, **kwargs, &block).first
-      else assign_node(*command).send(method, *command, **kwargs, &block)
-      end
-    end
-
-    def send_memory_command(method, *command, **kwargs, &block)
-      case command[1].to_s.downcase
-      when 'stats' then @node.call_all(method, *command, **kwargs, &block)
-      when 'purge' then @node.call_all(method, *command, **kwargs, &block).first
-      else assign_node(*command).send(method, *command, **kwargs, &block)
-      end
-    end
-
-    def send_client_command(method, *command, **kwargs, &block)
-      case command[1].to_s.downcase
-      when 'list' then @node.call_all(method, *command, **kwargs, &block).flatten
-      when 'pause', 'reply', 'setname'
-        @node.call_all(method, *command, **kwargs, &block).first
-      else assign_node(*command).send(method, *command, **kwargs, &block)
-      end
-    end
-
-    def send_cluster_command(method, *command, **kwargs, &block) # rubocop:disable Metrics/MethodLength
-      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, *command, **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, *command, **kwargs, &block)
-      else assign_node(*command).send(method, *command, **kwargs, &block)
-      end
-    end
-
-    def send_script_command(method, *command, **kwargs, &block)
-      case command[1].to_s.downcase
-      when 'debug', 'kill'
-        @node.call_all(method, *command, **kwargs, &block).first
-      when 'flush', 'load'
-        @node.call_primaries(method, *command, **kwargs, &block).first
-      else assign_node(*command).send(method, *command, **kwargs, &block)
-      end
-    end
-
-    def send_pubsub_command(method, *command, **kwargs, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
-      case command[1].to_s.downcase
-      when 'channels' then @node.call_all(method, *command, **kwargs, &block).flatten.uniq.sort
-      when 'numsub'
-        @node.call_all(method, *command, **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, *command, **kwargs, &block).sum
-      else assign_node(*command).send(method, *command, **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
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.11
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-21 00:00:00.000000000 Z
+date: 2022-06-27 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