redis-cluster-client 0.2.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5160c83d23cb638fc76cf079377981d6778560ba0eb476da03f58d6f4eded9af
-  data.tar.gz: dd0baec0d24de14e2cba10c4ea3f45af7f1bef2db30f609c9551ed2d13c0bf4a
+  metadata.gz: 7fa6c9386e1ffd7571fdc8a29bea08960387d958149b972e1cf27d28eac98da0
+  data.tar.gz: e532422c94e7416df967f772112c77861f4501d5dcd73c2d9893237586077677
 SHA512:
-  metadata.gz: 1cf5c16776bb7ff4c53ffa66e3de3371c1130fed7a4916982e7fba9859ba9ae7505af0bc5e8e02b58f22d116ab74692a4572d835f05672457bac4ddd469e3162
-  data.tar.gz: f08215c00f2b12b00247604917a7f7abc228ddd0e4305c67af38f8e2087a8b3785a22bfbd09ac32f75789719a624be49663f5048f6187318477069e4ef9627a1
+  metadata.gz: ef29a0346608779f6528559e52e348df690baf44db0cd8c9e1fe94e44bf9d282eca81101a1246cb0bff418ec398b2b207eb47563e2b976b6523e0fe6583e55fb
+  data.tar.gz: 7e4059d96f02c078989c7bae6cc4790f1580d0fc721c545a86d694ddae7eb90541573c67bb66a93bc6732b45b1f1ac18a3370b0d3d20df41760be9eb78255f5c

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

@@ -0,0 +1,85 @@
+# 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)
+          @existed_replicas = @replications.reject { |_, v| v.empty? }.values
+        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)
+          @existed_replicas.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, command, args, &block)
-        results, errors = try_map do |_, client|
-          client.send(method, *args, command, &block)
-        end
-
-        return results.values if errors.empty?
-
-        raise ::RedisClient::Cluster::ErrorCollection, errors
+        call_multiple_nodes!(@topology.clients, method, command, args, &block)
       end
 
       def call_primaries(method, command, args, &block)
-        results, errors = try_map do |node_key, client|
-          next if replica?(node_key)
-
-          client.send(method, *args, command, &block)
-        end
-
-        return results.values if errors.empty?
-
-        raise ::RedisClient::Cluster::ErrorCollection, errors
+        call_multiple_nodes!(@topology.primary_clients, method, command, args, &block)
       end
 
       def call_replicas(method, command, args, &block)
-        return call_primaries(method, command, args, &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, command, &block)
-        end
-
-        return results.values if errors.empty?
-
-        raise ::RedisClient::Cluster::ErrorCollection, errors
+        call_multiple_nodes!(@topology.replica_clients, method, command, args, &block)
       end
 
       def send_ping(method, command, args, &block)
-        results, errors = try_map do |_, client|
-          client.send(method, *args, command, &block)
-        end
-
-        return results.values if errors.empty?
+        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,52 +7,54 @@ class RedisClient
   class Cluster
     class Pipeline
       ReplySizeError = Class.new(::RedisClient::Error)
+      MAX_THREADS = Integer(ENV.fetch('REDIS_CLIENT_MAX_THREADS', 5))
 
       def initialize(router, command_builder)
         @router = router
         @command_builder = command_builder
         @grouped = Hash.new([].freeze)
         @size = 0
+        @seed = Random.new_seed
       end
 
       def call(*args, **kwargs, &block)
         command = @command_builder.generate(args, kwargs)
-        node_key = @router.find_node_key(command, primary_only: true)
+        node_key = @router.find_node_key(command, seed: @seed)
         @grouped[node_key] += [[@size, :call_v, command, block]]
         @size += 1
       end
 
       def call_v(args, &block)
         command = @command_builder.generate(args)
-        node_key = @router.find_node_key(command, primary_only: true)
+        node_key = @router.find_node_key(command, seed: @seed)
         @grouped[node_key] += [[@size, :call_v, command, block]]
         @size += 1
       end
 
       def call_once(*args, **kwargs, &block)
         command = @command_builder.generate(args, kwargs)
-        node_key = @router.find_node_key(command, primary_only: true)
+        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, primary_only: true)
+        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, primary_only: true)
+        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, primary_only: true)
+        node_key = @router.find_node_key(command, seed: @seed)
         @grouped[node_key] += [[@size, :blocking_call_v, timeout, command, block]]
         @size += 1
       end
@@ -62,27 +64,30 @@ class RedisClient
       end
 
       # TODO: https://github.com/redis-rb/redis-cluster-client/issues/37 handle redirections
-      def execute # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      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 |(_size, *row, block)|
-                pipeline.send(*row, &block)
+        @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/router.rb

@@ -35,7 +35,7 @@ class RedisClient
         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)
+        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)
@@ -123,7 +123,7 @@ class RedisClient
         retry
       end
 
-      def scan(*command, **kwargs) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      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
@@ -132,7 +132,7 @@ 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
@@ -147,19 +147,19 @@ class RedisClient
         [((result_cursor << 8) + client_index).to_s, result_keys]
       end
 
-      def assign_node(command, primary_only: false)
-        node_key = find_node_key(command, primary_only: primary_only)
+      def assign_node(command)
+        node_key = find_node_key(command)
         find_node(node_key)
       end
 
-      def find_node_key(command, primary_only: false)
+      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
 
@@ -266,12 +266,18 @@ 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!

data/lib/redis_client/cluster.rb

@@ -53,9 +53,10 @@ class RedisClient
     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

data/lib/redis_client/cluster_config.rb

@@ -20,10 +20,19 @@ class RedisClient
 
     InvalidClientConfigError = Class.new(::RedisClient::Error)
 
-    attr_reader :command_builder, :client_config
+    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, client_implementation: Cluster, 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) }
@@ -33,6 +42,17 @@ class RedisClient
       @mutex = Mutex.new
     end
 
+    def dup
+      self.class.new(
+        nodes: @node_configs,
+        replica: @replica,
+        replica_affinity: @replica_affinity,
+        fixed_hostname: @fixed_hostname,
+        client_implementation: @client_implementation,
+        **@client_config
+      )
+    end
+
     def inspect
       "#<#{self.class.name} #{per_node_key.values}>"
     end
@@ -70,10 +90,6 @@ class RedisClient
       @mutex.synchronize { @node_configs << { host: host, port: port } }
     end
 
-    def dup
-      self.class.new(nodes: @node_configs, replica: @replica, fixed_hostname: @fixed_hostname, **@client_config)
-    end
-
     private
 
     def build_node_configs(addrs)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-17 00:00:00.000000000 Z
+date: 2022-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -37,6 +37,10 @@ files:
 - 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