redis-cluster-client 0.1.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 367df4e02bcd425f14da73b2ff243dfdb7fd44c6cb565bcc46952b939057904f
-  data.tar.gz: bfdb8033d0695fe0389563ad563c8445f9624e99ef6315e7374ee7f2e440fe40
+  metadata.gz: 619becbe41f6cb5c829de9df021a399ac966b1976284e06e7792c0b570061e32
+  data.tar.gz: 5b6ddc1c8410bcf8ab03538bf5dd77d0425d4bf34f170ea026ff4d1c1be2ce8e
 SHA512:
-  metadata.gz: 278740e8829a1def72a411552ed7c17d0d265930c81dfc2b967cfa325a74cdbdbd0adb832dacc77e4c86c8316648695b94044cb6fdf3dd3267617d5f18b95ec1
-  data.tar.gz: 007bf587198b7575dabee128c0500700ef0d10c7b699a632023ce4d80fa788d2a88e851748f041ab5f6453350d7de6f9d8c96bcbc798deec7acbf37b2700ea6a
+  metadata.gz: 658a78bdd61f7e902b2385c73f23f3fa692a73b77a073afc0cb3d0616726a99cb65884ec4ab7cbae2bdd4574444f1de2f639105eaa4f40e1c07c186d7589dff5
+  data.tar.gz: 33b9d88cc33fec6f5a556ae3beb494c9875796088b93a47b647efe02db6f41540d49f3120d5d7114c8757aa78e29b173abd20a8b2a2341861e953a0ab4b0f67a

data/lib/redis-cluster-client.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'redis_cluster_client'

data/lib/redis_client/cluster/node/latency_replica.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'redis_client/cluster/node/replica_mixin'
+
+class RedisClient
+  class Cluster
+    class Node
+      class LatencyReplica
+        include ::RedisClient::Cluster::Node::ReplicaMixin
+
+        attr_reader :replica_clients
+
+        DUMMY_LATENCY_NSEC = 100 * 1000 * 1000 * 1000
+        MEASURE_ATTEMPT_COUNT = 10
+
+        def initialize(replications, options, pool, **kwargs)
+          super
+
+          all_replica_clients = @clients.select { |k, _| @replica_node_keys.include?(k) }
+          latencies = measure_latencies(all_replica_clients)
+          @replications.each_value { |keys| keys.sort_by! { |k| latencies.fetch(k) } }
+          @replica_clients = select_replica_clients(@replications, @clients)
+          @clients_for_scanning = select_clients_for_scanning(@replications, @clients)
+        end
+
+        def clients_for_scanning(seed: nil) # rubocop:disable Lint/UnusedMethodArgument
+          @clients_for_scanning
+        end
+
+        def find_node_key_of_replica(primary_node_key, seed: nil) # rubocop:disable Lint/UnusedMethodArgument
+          @replications.fetch(primary_node_key, EMPTY_ARRAY).first || primary_node_key
+        end
+
+        def any_replica_node_key(seed: nil)
+          random = seed.nil? ? Random : Random.new(seed)
+          @replications.reject { |_, v| v.empty? }.values.sample(random: random).first
+        end
+
+        private
+
+        def measure_latencies(clients) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          latencies = {}
+
+          clients.each_slice(::RedisClient::Cluster::Node::MAX_THREADS) do |chuncked_clients|
+            threads = chuncked_clients.map do |k, v|
+              Thread.new(k, v) do |node_key, client|
+                Thread.pass
+
+                min = DUMMY_LATENCY_NSEC
+                MEASURE_ATTEMPT_COUNT.times do
+                  starting = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+                  client.send(:call_once, 'PING')
+                  duration = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond) - starting
+                  min = duration if duration < min
+                end
+
+                latencies[node_key] = min
+              rescue StandardError
+                latencies[node_key] = DUMMY_LATENCY_NSEC
+              end
+            end
+
+            threads.each(&:join)
+          end
+
+          latencies
+        end
+
+        def select_replica_clients(replications, clients)
+          keys = replications.values.filter_map(&:first)
+          clients.select { |k, _| keys.include?(k) }
+        end
+
+        def select_clients_for_scanning(replications, clients)
+          keys = replications.map do |primary_node_key, replica_node_keys|
+            replica_node_keys.empty? ? primary_node_key : replica_node_keys.first
+          end
+
+          clients.select { |k, _| keys.include?(k) }
+        end
+      end
+    end
+  end
+end

data/lib/redis_client/cluster/node/primary_only.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class RedisClient
+  class Cluster
+    class Node
+      class PrimaryOnly
+        attr_reader :clients
+
+        def initialize(replications, options, pool, **kwargs)
+          @primary_node_keys = replications.keys.sort
+          @clients = build_clients(@primary_node_keys, options, pool, **kwargs)
+        end
+
+        alias primary_clients clients
+        alias replica_clients clients
+
+        def clients_for_scanning(seed: nil) # rubocop:disable Lint/UnusedMethodArgument
+          @clients
+        end
+
+        def find_node_key_of_replica(primary_node_key, seed: nil) # rubocop:disable Lint/UnusedMethodArgument
+          primary_node_key
+        end
+
+        def any_primary_node_key(seed: nil)
+          random = seed.nil? ? Random : Random.new(seed)
+          @primary_node_keys.sample(random: random)
+        end
+
+        alias any_replica_node_key any_primary_node_key
+
+        private
+
+        def build_clients(primary_node_keys, options, pool, **kwargs)
+          options.filter_map do |node_key, option|
+            next if !primary_node_keys.empty? && !primary_node_keys.include?(node_key)
+
+            option = option.merge(kwargs.reject { |k, _| ::RedisClient::Cluster::Node::IGNORE_GENERIC_CONFIG_KEYS.include?(k) })
+            config = ::RedisClient::Cluster::Node::Config.new(**option)
+            client = pool.nil? ? config.new_client : config.new_pool(**pool)
+            [node_key, client]
+          end.to_h
+        end
+      end
+    end
+  end
+end

data/lib/redis_client/cluster/node/random_replica.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'redis_client/cluster/node/replica_mixin'
+
+class RedisClient
+  class Cluster
+    class Node
+      class RandomReplica
+        include ::RedisClient::Cluster::Node::ReplicaMixin
+
+        def replica_clients
+          keys = @replications.values.filter_map(&:sample)
+          @clients.select { |k, _| keys.include?(k) }
+        end
+
+        def clients_for_scanning(seed: nil)
+          random = seed.nil? ? Random : Random.new(seed)
+          keys = @replications.map do |primary_node_key, replica_node_keys|
+            replica_node_keys.empty? ? primary_node_key : replica_node_keys.sample(random: random)
+          end
+
+          clients.select { |k, _| keys.include?(k) }
+        end
+
+        def find_node_key_of_replica(primary_node_key, seed: nil)
+          random = seed.nil? ? Random : Random.new(seed)
+          @replications.fetch(primary_node_key, EMPTY_ARRAY).sample(random: random) || primary_node_key
+        end
+
+        def any_replica_node_key(seed: nil)
+          random = seed.nil? ? Random : Random.new(seed)
+          @replica_node_keys.sample(random: random)
+        end
+      end
+    end
+  end
+end

data/lib/redis_client/cluster/node/replica_mixin.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class RedisClient
+  class Cluster
+    class Node
+      module ReplicaMixin
+        attr_reader :clients, :primary_clients
+
+        EMPTY_ARRAY = [].freeze
+
+        def initialize(replications, options, pool, **kwargs)
+          @replications = replications
+          @primary_node_keys = @replications.keys.sort
+          @replica_node_keys = @replications.values.flatten.sort
+          @clients = build_clients(@primary_node_keys, options, pool, **kwargs)
+          @primary_clients = @clients.select { |k, _| @primary_node_keys.include?(k) }
+        end
+
+        def any_primary_node_key(seed: nil)
+          random = seed.nil? ? Random : Random.new(seed)
+          @primary_node_keys.sample(random: random)
+        end
+
+        private
+
+        def build_clients(primary_node_keys, options, pool, **kwargs)
+          options.filter_map do |node_key, option|
+            option = option.merge(kwargs.reject { |k, _| ::RedisClient::Cluster::Node::IGNORE_GENERIC_CONFIG_KEYS.include?(k) })
+            config = ::RedisClient::Cluster::Node::Config.new(scale_read: !primary_node_keys.include?(node_key), **option)
+            client = pool.nil? ? config.new_client : config.new_pool(**pool)
+            [node_key, client]
+          end.to_h
+        end
+      end
+    end
+  end
+end

data/lib/redis_client/cluster/node.rb

@@ -3,6 +3,9 @@
 require 'redis_client'
 require 'redis_client/config'
 require 'redis_client/cluster/errors'
+require 'redis_client/cluster/node/primary_only'
+require 'redis_client/cluster/node/random_replica'
+require 'redis_client/cluster/node/latency_replica'
 
 class RedisClient
   class Cluster
@@ -13,6 +16,7 @@ class RedisClient
       MIN_SLOT = 0
       MAX_SLOT = SLOT_SIZE - 1
       MAX_STARTUP_SAMPLE = 37
+      MAX_THREADS = Integer(ENV.fetch('REDIS_CLIENT_MAX_THREADS', 5))
       IGNORE_GENERIC_CONFIG_KEYS = %i[url host port path].freeze
 
       ReloadNeeded = Class.new(::RedisClient::Error)
@@ -39,18 +43,22 @@ class RedisClient
           errors = Array.new(startup_size)
           startup_options = options.to_a.sample(MAX_STARTUP_SAMPLE).to_h
           startup_nodes = ::RedisClient::Cluster::Node.new(startup_options, **kwargs)
-          threads = startup_nodes.each_with_index.map do |raw_client, idx|
-            Thread.new(raw_client, idx) do |cli, i|
-              Thread.pass
-              reply = cli.call('CLUSTER', 'NODES')
-              node_info_list[i] = parse_node_info(reply)
-            rescue StandardError => e
-              errors[i] = e
-            ensure
-              cli&.close
+          startup_nodes.each_slice(MAX_THREADS).with_index do |chuncked_startup_nodes, chuncked_idx|
+            threads = chuncked_startup_nodes.each_with_index.map do |raw_client, idx|
+              Thread.new(raw_client, (MAX_THREADS * chuncked_idx) + idx) do |cli, i|
+                Thread.pass
+                reply = cli.call('CLUSTER', 'NODES')
+                node_info_list[i] = parse_node_info(reply)
+              rescue StandardError => e
+                errors[i] = e
+              ensure
+                cli&.close
+              end
             end
+
+            threads.each(&:join)
           end
-          threads.each(&:join)
+
           raise ::RedisClient::Cluster::InitialSetupError, errors if node_info_list.all?(&:nil?)
 
           grouped = node_info_list.compact.group_by do |rows|
@@ -88,11 +96,18 @@ class RedisClient
         end
       end
 
-      def initialize(options, node_info: [], pool: nil, with_replica: false, **kwargs)
-        @with_replica = with_replica
+      def initialize( # rubocop:disable Metrics/ParameterLists
+        options,
+        node_info: [],
+        with_replica: false,
+        replica_affinity: :random,
+        pool: nil,
+        **kwargs
+      )
+
         @slots = build_slot_node_mappings(node_info)
         @replications = build_replication_mappings(node_info)
-        @clients = build_clients(options, pool: pool, **kwargs)
+        @topology = make_topology_class(with_replica, replica_affinity).new(@replications, options, pool, **kwargs)
         @mutex = Mutex.new
       end
 
@@ -101,87 +116,46 @@ class RedisClient
       end
 
       def each(&block)
-        @clients.each_value(&block)
+        @topology.clients.each_value(&block)
       end
 
       def sample
-        @clients.values.sample
+        @topology.clients.values.sample
       end
 
       def node_keys
-        @clients.keys.sort
-      end
-
-      def primary_node_keys
-        @clients.filter_map { |k, _| primary?(k) ? k : nil }.sort
-      end
-
-      def replica_node_keys
-        return primary_node_keys if replica_disabled?
-
-        @clients.filter_map { |k, _| replica?(k) ? k : nil }.sort
+        @topology.clients.keys.sort
       end
 
       def find_by(node_key)
-        raise ReloadNeeded if node_key.nil? || !@clients.key?(node_key)
+        raise ReloadNeeded if node_key.nil? || !@topology.clients.key?(node_key)
 
-        @clients.fetch(node_key)
+        @topology.clients.fetch(node_key)
       end
 
-      def call_all(method, *args, **kwargs, &block)
-        results, errors = try_map do |_, client|
-          client.send(method, *args, **kwargs, &block)
-        end
-
-        return results.values if errors.empty?
-
-        raise ::RedisClient::Cluster::ErrorCollection, errors
+      def call_all(method, command, args, &block)
+        call_multiple_nodes!(@topology.clients, method, command, args, &block)
       end
 
-      def call_primaries(method, *args, **kwargs, &block)
-        results, errors = try_map do |node_key, client|
-          next if replica?(node_key)
-
-          client.send(method, *args, **kwargs, &block)
-        end
-
-        return results.values if errors.empty?
-
-        raise ::RedisClient::Cluster::ErrorCollection, errors
+      def call_primaries(method, command, args, &block)
+        call_multiple_nodes!(@topology.primary_clients, method, command, args, &block)
       end
 
-      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, *args, **kwargs, &block)
-        end
-
-        return results.values if errors.empty?
-
-        raise ::RedisClient::Cluster::ErrorCollection, errors
+      def call_replicas(method, command, args, &block)
+        call_multiple_nodes!(@topology.replica_clients, method, command, args, &block)
       end
 
-      def send_ping(method, *args, **kwargs, &block)
-        results, errors = try_map do |_, client|
-          client.send(method, *args, **kwargs, &block)
-        end
-
-        return results.values if errors.empty?
+      def send_ping(method, command, args, &block)
+        result_values, errors = call_multiple_nodes(@topology.clients, method, command, args, &block)
+        return result_values if errors.empty?
 
         raise ReloadNeeded if errors.values.any?(::RedisClient::ConnectionError)
 
         raise ::RedisClient::Cluster::ErrorCollection, errors
       end
 
-      def scale_reading_clients
-        keys = replica_disabled? ? @replications.keys : @replications.values.map(&:first)
-        @clients.select { |k, _| keys.include?(k) }.values.sort_by do |client|
-          "#{client.config.host}-#{client.config.port}"
-        end
+      def clients_for_scanning(seed: nil)
+        @topology.clients_for_scanning(seed: seed).values.sort_by { |c| "#{c.config.host}-#{c.config.port}" }
       end
 
       def find_node_key_of_primary(slot)
@@ -193,41 +167,33 @@ class RedisClient
         @slots[slot]
       end
 
-      def find_node_key_of_replica(slot)
-        return if slot.nil?
-
-        slot = Integer(slot)
-        return if slot < MIN_SLOT || slot > MAX_SLOT
+      def find_node_key_of_replica(slot, seed: nil)
+        primary_node_key = find_node_key_of_primary(slot)
+        @topology.find_node_key_of_replica(primary_node_key, seed: seed)
+      end
 
-        return @slots[slot] if replica_disabled? || @replications[@slots[slot]].size.zero?
+      def any_primary_node_key(seed: nil)
+        @topology.any_primary_node_key(seed: seed)
+      end
 
-        @replications[@slots[slot]].sample
+      def any_replica_node_key(seed: nil)
+        @topology.any_replica_node_key(seed: seed)
       end
 
       def update_slot(slot, node_key)
         @mutex.synchronize { @slots[slot] = node_key }
       end
 
-      def replicated?(primary_node_key, replica_node_key)
-        return false if @replications.nil? || @replications.size.zero?
-
-        @replications.fetch(primary_node_key).include?(replica_node_key)
-      end
-
       private
 
-      def replica_disabled?
-        !@with_replica
-      end
-
-      def primary?(node_key)
-        !replica?(node_key)
-      end
-
-      def replica?(node_key)
-        return false if @replications.nil? || @replications.size.zero?
-
-        !@replications.key?(node_key)
+      def make_topology_class(with_replica, replica_affinity)
+        if with_replica && replica_affinity == :random
+          ::RedisClient::Cluster::Node::RandomReplica
+        elsif with_replica && replica_affinity == :latency
+          ::RedisClient::Cluster::Node::LatencyReplica
+        else
+          ::RedisClient::Cluster::Node::PrimaryOnly
+        end
       end
 
       def build_slot_node_mappings(node_info)
@@ -250,34 +216,38 @@ class RedisClient
         end
       end
 
-      def build_clients(options, pool: nil, **kwargs)
-        options.filter_map do |node_key, option|
-          next if replica_disabled? && replica?(node_key)
+      def call_multiple_nodes(clients, method, command, args, &block)
+        results, errors = try_map(clients) do |_, client|
+          client.send(method, *args, command, &block)
+        end
+
+        [results.values, errors]
+      end
 
-          config = ::RedisClient::Cluster::Node::Config.new(
-            scale_read: replica?(node_key),
-            **option.merge(kwargs.reject { |k, _| IGNORE_GENERIC_CONFIG_KEYS.include?(k) })
-          )
-          client = pool.nil? ? config.new_client : config.new_pool(**pool)
+      def call_multiple_nodes!(clients, method, command, args, &block)
+        result_values, errors = call_multiple_nodes(clients, method, command, args, &block)
+        return result_values if errors.empty?
 
-          [node_key, client]
-        end.to_h
+        raise ::RedisClient::Cluster::ErrorCollection, errors
       end
 
-      def try_map # rubocop:disable Metrics/MethodLength
+      def try_map(clients) # rubocop:disable Metrics/MethodLength
         results = {}
         errors = {}
-        threads = @clients.map do |k, v|
-          Thread.new(k, v) do |node_key, client|
-            Thread.pass
-            reply = yield(node_key, client)
-            results[node_key] = reply unless reply.nil?
-          rescue StandardError => e
-            errors[node_key] = e
+        clients.each_slice(MAX_THREADS) do |chuncked_clients|
+          threads = chuncked_clients.map do |k, v|
+            Thread.new(k, v) do |node_key, client|
+              Thread.pass
+              reply = yield(node_key, client)
+              results[node_key] = reply unless reply.nil?
+            rescue StandardError => e
+              errors[node_key] = e
+            end
           end
+
+          threads.each(&:join)
         end
 
-        threads.each(&:join)
         [results, errors]
       end
     end

data/lib/redis_client/cluster/pipeline.rb

@@ -7,28 +7,55 @@ class RedisClient
   class Cluster
     class Pipeline
       ReplySizeError = Class.new(::RedisClient::Error)
+      MAX_THREADS = Integer(ENV.fetch('REDIS_CLIENT_MAX_THREADS', 5))
 
-      def initialize(router)
+      def initialize(router, command_builder)
         @router = router
+        @command_builder = command_builder
         @grouped = Hash.new([].freeze)
         @size = 0
+        @seed = Random.new_seed
       end
 
-      def call(*command, **kwargs)
-        node_key = @router.find_node_key(*command, primary_only: true, **kwargs)
-        @grouped[node_key] += [[@size, :call, command, kwargs]]
+      def call(*args, **kwargs, &block)
+        command = @command_builder.generate(args, kwargs)
+        node_key = @router.find_node_key(command, seed: @seed)
+        @grouped[node_key] += [[@size, :call_v, command, block]]
         @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]]
+      def call_v(args, &block)
+        command = @command_builder.generate(args)
+        node_key = @router.find_node_key(command, seed: @seed)
+        @grouped[node_key] += [[@size, :call_v, command, block]]
         @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]]
+      def call_once(*args, **kwargs, &block)
+        command = @command_builder.generate(args, kwargs)
+        node_key = @router.find_node_key(command, seed: @seed)
+        @grouped[node_key] += [[@size, :call_once_v, command, block]]
+        @size += 1
+      end
+
+      def call_once_v(args, &block)
+        command = @command_builder.generate(args)
+        node_key = @router.find_node_key(command, seed: @seed)
+        @grouped[node_key] += [[@size, :call_once_v, command, block]]
+        @size += 1
+      end
+
+      def blocking_call(timeout, *args, **kwargs, &block)
+        command = @command_builder.generate(args, kwargs)
+        node_key = @router.find_node_key(command, seed: @seed)
+        @grouped[node_key] += [[@size, :blocking_call_v, timeout, command, block]]
+        @size += 1
+      end
+
+      def blocking_call_v(timeout, args, &block)
+        command = @command_builder.generate(args)
+        node_key = @router.find_node_key(command, seed: @seed)
+        @grouped[node_key] += [[@size, :blocking_call_v, timeout, command, block]]
         @size += 1
       end
 
@@ -40,29 +67,27 @@ class RedisClient
       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]
+        @grouped.each_slice(MAX_THREADS) do |chuncked_grouped|
+          threads = chuncked_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 |(_size, *row, block)|
+                  pipeline.send(*row, &block)
                 end
               end
-            end
 
-            raise ReplySizeError, "commands: #{rows.size}, replies: #{replies.size}" if rows.size != replies.size
+              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
+              rows.each_with_index { |row, idx| all_replies[row.first] = replies[idx] }
+            rescue StandardError => e
+              errors[node_key] = e
+            end
           end
+
+          threads.each(&:join)
         end
 
-        threads.each(&:join)
         return all_replies if errors.empty?
 
         raise ::RedisClient::Cluster::ErrorCollection, errors

data/lib/redis_client/cluster/pub_sub.rb

@@ -3,15 +3,24 @@
 class RedisClient
   class Cluster
     class PubSub
-      def initialize(router)
+      def initialize(router, command_builder)
         @router = router
+        @command_builder = command_builder
         @pubsub = nil
       end
 
-      def call(*command, **kwargs)
+      def call(*args, **kwargs)
         close
-        @pubsub = @router.assign_node(*command, **kwargs).pubsub
-        @pubsub.call(*command, **kwargs)
+        command = @command_builder.generate(args, kwargs)
+        @pubsub = @router.assign_node(command).pubsub
+        @pubsub.call_v(command)
+      end
+
+      def call_v(command)
+        close
+        command = @command_builder.generate(command)
+        @pubsub = @router.assign_node(command).pubsub
+        @pubsub.call_v(command)
       end
 
       def close

data/lib/redis_client/cluster/router.rb

@@ -20,40 +20,37 @@ class RedisClient
         @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
+        @command_builder = @config.command_builder
       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)
-
+      def send_command(method, command, *args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         cmd = command.first.to_s.downcase
         case cmd
         when 'acl', 'auth', 'bgrewriteaof', 'bgsave', 'quit', 'save'
-          @node.call_all(method, *args, **kwargs, &block).first
+          @node.call_all(method, command, args, &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)
+          @node.call_primaries(method, command, args, &block).first
+        when 'ping'     then @node.send_ping(method, command, args, &block).first
+        when 'wait'     then send_wait_command(method, command, args, &block)
+        when 'keys'     then @node.call_replicas(method, command, args, &block).flatten.sort_by(&:to_s)
+        when 'dbsize'   then @node.call_replicas(method, command, args, &block).select { |e| e.is_a?(Integer) }.sum
+        when 'scan'     then scan(command, seed: 1)
+        when 'lastsave' then @node.call_all(method, command, args, &block).sort_by(&:to_i)
+        when 'role'     then @node.call_all(method, command, args, &block)
+        when 'config'   then send_config_command(method, command, args, &block)
+        when 'client'   then send_client_command(method, command, args, &block)
+        when 'cluster'  then send_cluster_command(method, command, args, &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 'memory'   then send_memory_command(method, command, args, &block)
+        when 'script'   then send_script_command(method, command, args, &block)
+        when 'pubsub'   then send_pubsub_command(method, command, args, &block)
         when 'discard', 'exec', 'multi', 'unwatch'
           raise ::RedisClient::Cluster::AmbiguousNodeError, cmd
         else
-          node = assign_node(*command)
-          try_send(node, method, *args, **kwargs, &block)
+          node = assign_node(command)
+          try_send(node, method, command, args, &block)
         end
       rescue ::RedisClient::Cluster::Node::ReloadNeeded
         update_cluster_info!
@@ -67,7 +64,37 @@ class RedisClient
 
       # @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
+      def try_send(node, method, command, args, retry_count: 3, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        node.send(method, *args, command, &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 => e
+        raise if method == :blocking_call_v || (method == :blocking_call && e.is_a?(RedisClient::ReadTimeoutError))
+        raise if retry_count <= 0
+
+        update_cluster_info!
+        retry_count -= 1
+        retry
+      end
+
+      def try_delegate(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
@@ -96,8 +123,8 @@ class RedisClient
         retry
       end
 
-      def scan(*command, **kwargs) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-        command = @command_builder.generate!(command, kwargs)
+      def scan(*command, seed: nil, **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])
@@ -105,14 +132,14 @@ class RedisClient
         client_index = input_cursor % 256
         raw_cursor = input_cursor >> 8
 
-        clients = @node.scale_reading_clients
+        clients = @node.clients_for_scanning(seed: seed)
 
         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, result_keys = client.call_v(command)
         result_cursor = Integer(result_cursor)
 
         client_index += 1 if result_cursor == 0
@@ -120,21 +147,19 @@ class RedisClient
         [((result_cursor << 8) + client_index).to_s, result_keys]
       end
 
-      def assign_node(*command, **kwargs)
-        node_key = find_node_key(*command, **kwargs)
+      def assign_node(command)
+        node_key = find_node_key(command)
         find_node(node_key)
       end
 
-      def find_node_key(*command, primary_only: false, **kwargs)
-        command = @command_builder.generate!(command, kwargs)
-
+      def find_node_key(command, seed: nil)
         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
+        if @command.should_send_to_primary?(command)
+          @node.find_node_key_of_primary(slot) || @node.any_primary_node_key(seed: seed)
         else
-          @node.find_node_key_of_replica(slot) || @node.replica_node_keys.sample
+          @node.find_node_key_of_replica(slot, seed: seed) || @node.any_replica_node_key(seed: seed)
         end
       end
 
@@ -154,8 +179,8 @@ class RedisClient
 
       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
+      def send_wait_command(method, command, args, retry_count: 3, &block)
+        @node.call_primaries(method, command, args, &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|
@@ -167,82 +192,65 @@ class RedisClient
         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)
-
+      def send_config_command(method, command, args, &block)
         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)
+          @node.call_all(method, command, args, &block).first
+        else assign_node(command).send(method, *args, command, &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)
-
+      def send_memory_command(method, command, args, &block)
         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)
+        when 'stats' then @node.call_all(method, command, args, &block)
+        when 'purge' then @node.call_all(method, command, args, &block).first
+        else assign_node(command).send(method, *args, command, &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)
-
+      def send_client_command(method, command, args, &block)
         case command[1].to_s.downcase
-        when 'list' then @node.call_all(method, *args, **kwargs, &block).flatten
+        when 'list' then @node.call_all(method, command, args, &block).flatten
         when 'pause', 'reply', 'setname'
-          @node.call_all(method, *args, **kwargs, &block).first
-        else assign_node(*command).send(method, *args, **kwargs, &block)
+          @node.call_all(method, command, args, &block).first
+        else assign_node(command).send(method, *args, command, &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)
+      def send_cluster_command(method, command, args, &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, *args, **kwargs, &block).first
+        when 'saveconfig' then @node.call_all(method, command, args, &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)
+          find_node(@node.find_node_key_of_replica(command[2])).send(method, *args, command, &block)
+        else assign_node(command).send(method, *args, command, &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)
-
+      def send_script_command(method, command, args, &block)
         case command[1].to_s.downcase
         when 'debug', 'kill'
-          @node.call_all(method, *args, **kwargs, &block).first
+          @node.call_all(method, command, args, &block).first
         when 'flush', 'load'
-          @node.call_primaries(method, *args, **kwargs, &block).first
-        else assign_node(*command).send(method, *args, **kwargs, &block)
+          @node.call_primaries(method, command, args, &block).first
+        else assign_node(command).send(method, *args, command, &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)
-
+      def send_pubsub_command(method, command, args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         case command[1].to_s.downcase
-        when 'channels' then @node.call_all(method, *args, **kwargs, &block).flatten.uniq.sort_by(&:to_s)
+        when 'channels' then @node.call_all(method, command, args, &block).flatten.uniq.sort_by(&:to_s)
         when 'numsub'
-          @node.call_all(method, *args, **kwargs, &block).reject(&:empty?).map { |e| Hash[*e] }
+          @node.call_all(method, command, args, &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)
+        when 'numpat' then @node.call_all(method, command, args, &block).select { |e| e.is_a?(Integer) }.sum
+        else assign_node(command).send(method, *args, command, &block)
         end
       end
 
@@ -258,18 +266,24 @@ class RedisClient
         find_node(node_key)
       end
 
-      def fetch_cluster_info(config, pool: nil, **kwargs)
+      def fetch_cluster_info(config, pool: nil, **kwargs) # rubocop:disable Metrics/MethodLength
         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)
+        ::RedisClient::Cluster::Node.new(
+          config.per_node_key,
+          node_info: node_info,
+          pool: pool,
+          with_replica: config.use_replica?,
+          replica_affinity: config.replica_affinity,
+          **kwargs
+        )
       end
 
       def update_cluster_info!
         @mutex.synchronize do
           begin
-            @node.call_all(:close)
+            @node.each(&:close)
           rescue ::RedisClient::Cluster::ErrorCollection
             # ignore
           end

data/lib/redis_client/cluster.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'redis_client'
 require 'redis_client/cluster/pipeline'
 require 'redis_client/cluster/pub_sub'
 require 'redis_client/cluster/router'
@@ -9,54 +8,77 @@ class RedisClient
   class Cluster
     ZERO_CURSOR_FOR_SCAN = '0'
 
+    attr_reader :config
+
     def initialize(config, pool: nil, **kwargs)
+      @config = config
       @router = ::RedisClient::Cluster::Router.new(config, pool: pool, **kwargs)
+      @command_builder = config.command_builder
     end
 
     def inspect
       "#<#{self.class.name} #{@router.node.node_keys.join(', ')}>"
     end
 
-    def call(*command, **kwargs, &block)
-      @router.send_command(:call, *command, **kwargs, &block)
+    def call(*args, **kwargs, &block)
+      command = @command_builder.generate(args, kwargs)
+      @router.send_command(:call_v, command, &block)
+    end
+
+    def call_v(command, &block)
+      command = @command_builder.generate(command)
+      @router.send_command(:call_v, command, &block)
+    end
+
+    def call_once(*args, **kwargs, &block)
+      command = @command_builder.generate(args, kwargs)
+      @router.send_command(:call_once_v, command, &block)
+    end
+
+    def call_once_v(command, &block)
+      command = @command_builder.generate(command)
+      @router.send_command(:call_once_v, command, &block)
     end
 
-    def call_once(*command, **kwargs, &block)
-      @router.send_command(:call_once, *command, **kwargs, &block)
+    def blocking_call(timeout, *args, **kwargs, &block)
+      command = @command_builder.generate(args, kwargs)
+      @router.send_command(:blocking_call_v, command, timeout, &block)
     end
 
-    def blocking_call(timeout, *command, **kwargs, &block)
-      @router.send_command(:blocking_call, timeout, *command, **kwargs, &block)
+    def blocking_call_v(timeout, command, &block)
+      command = @command_builder.generate(command)
+      @router.send_command(:blocking_call_v, command, timeout, &block)
     end
 
     def scan(*args, **kwargs, &block)
       raise ArgumentError, 'block required' unless block
 
+      seed = Random.new_seed
       cursor = ZERO_CURSOR_FOR_SCAN
       loop do
-        cursor, keys = @router.scan('SCAN', cursor, *args, **kwargs)
+        cursor, keys = @router.scan('SCAN', cursor, *args, seed: seed, **kwargs)
         keys.each(&block)
         break if cursor == ZERO_CURSOR_FOR_SCAN
       end
     end
 
     def sscan(key, *args, **kwargs, &block)
-      node = @router.assign_node('SSCAN', key)
-      @router.try_send(node, :sscan, key, *args, **kwargs, &block)
+      node = @router.assign_node(['SSCAN', key])
+      @router.try_delegate(node, :sscan, key, *args, **kwargs, &block)
     end
 
     def hscan(key, *args, **kwargs, &block)
-      node = @router.assign_node('HSCAN', key)
-      @router.try_send(node, :hscan, key, *args, **kwargs, &block)
+      node = @router.assign_node(['HSCAN', key])
+      @router.try_delegate(node, :hscan, key, *args, **kwargs, &block)
     end
 
     def zscan(key, *args, **kwargs, &block)
-      node = @router.assign_node('ZSCAN', key)
-      @router.try_send(node, :zscan, key, *args, **kwargs, &block)
+      node = @router.assign_node(['ZSCAN', key])
+      @router.try_delegate(node, :zscan, key, *args, **kwargs, &block)
     end
 
     def pipelined
-      pipeline = ::RedisClient::Cluster::Pipeline.new(@router)
+      pipeline = ::RedisClient::Cluster::Pipeline.new(@router, @command_builder)
       yield pipeline
       return [] if pipeline.empty? == 0
 
@@ -64,11 +86,11 @@ class RedisClient
     end
 
     def pubsub
-      ::RedisClient::Cluster::PubSub.new(@router)
+      ::RedisClient::Cluster::PubSub.new(@router, @command_builder)
     end
 
     def close
-      @router.node.call_all(:close)
+      @router.node.each(&:close)
       nil
     end
 
@@ -77,7 +99,8 @@ class RedisClient
     def method_missing(name, *args, **kwargs, &block)
       if @router.command_exists?(name)
         args.unshift(name)
-        return @router.send_command(:call, *args, **kwargs, &block)
+        command = @command_builder.generate(args, kwargs)
+        return @router.send_command(:call_v, command, &block)
       end
 
       super

data/lib/redis_client/cluster_config.rb

@@ -20,15 +20,25 @@ class RedisClient
 
     InvalidClientConfigError = Class.new(::RedisClient::Error)
 
-    attr_reader :command_builder
+    attr_reader :command_builder, :client_config, :replica_affinity
+
+    def initialize( # rubocop:disable Metrics/ParameterLists
+      nodes: DEFAULT_NODES,
+      replica: false,
+      replica_affinity: :random,
+      fixed_hostname: '',
+      client_implementation: Cluster,
+      **client_config
+    )
 
-    def initialize(nodes: DEFAULT_NODES, replica: false, fixed_hostname: '', **client_config)
       @replica = true & replica
+      @replica_affinity = replica_affinity.to_s.to_sym
       @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)
+      @client_implementation = client_implementation
       @mutex = Mutex.new
     end
 
@@ -36,12 +46,16 @@ class RedisClient
       "#<#{self.class.name} #{per_node_key.values}>"
     end
 
+    def read_timeout
+      @client_config[:read_timeout] || @client_config[:timeout] || RedisClient::Config::DEFAULT_TIMEOUT
+    end
+
     def new_pool(size: 5, timeout: 5, **kwargs)
-      ::RedisClient::Cluster.new(self, pool: { size: size, timeout: timeout }, **kwargs)
+      @client_implementation.new(self, pool: { size: size, timeout: timeout }, **kwargs)
     end
 
     def new_client(**kwargs)
-      ::RedisClient::Cluster.new(self, **kwargs)
+      @client_implementation.new(self, **kwargs)
     end
 
     def per_node_key

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-02 00:00:00.000000000 Z
+date: 2022-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.6'
 description:
 email:
 - proxy0721@gmail.com
@@ -31,11 +31,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/redis-cluster-client.rb
 - lib/redis_client/cluster.rb
 - lib/redis_client/cluster/command.rb
 - lib/redis_client/cluster/errors.rb
 - lib/redis_client/cluster/key_slot_converter.rb
 - lib/redis_client/cluster/node.rb
+- lib/redis_client/cluster/node/latency_replica.rb
+- lib/redis_client/cluster/node/primary_only.rb
+- lib/redis_client/cluster/node/random_replica.rb
+- lib/redis_client/cluster/node/replica_mixin.rb
 - lib/redis_client/cluster/node_key.rb
 - lib/redis_client/cluster/pipeline.rb
 - lib/redis_client/cluster/pub_sub.rb