redis-cluster-client 0.4.17 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc35dc957459313cb97b78fae42fadb612788e8e65eb49449db24b66294057fa
-  data.tar.gz: 03cf3604892eb1a881123bdfeabaeac30816ed940a827c5390b2320b3e9e26f0
+  metadata.gz: aa2c8f0e32f5e18ea48cd9ceffa81fa084d8634481aa9362d1c5572231ef6491
+  data.tar.gz: ad6f608804f372a6488db63e0182d585c72954f9654590cacdcdc3d116602096
 SHA512:
-  metadata.gz: 7f8de53c53938381fb88c53ac2f13e8b7a78a3ee5653493fe0496acebaf0da57b568fb8c4436f8d19a7ba84d55018d9e4786c3726af2586581d0e7daee7b383f
-  data.tar.gz: 7b65b9e12fd251ca8a6c278c4fb245fc08b114c9cbfac58f88e5aca81d8b9ac9aa4939ef9dbf2ee042f313764b3205a9490453b7a2310915338e50c2871e4c47
+  metadata.gz: 025a8f3d1359eb027cd07effc689f00bf466aee783563b2552a489f24dcdffeb88aa7863f7158af922f61f20987a93205865e7d46ab695b8aa1b194fba0af449
+  data.tar.gz: 67e46fc5427a5f29d4d90e65662591ddb1ca354f333831ac3f908a8b23fd5ef1d0bf30c11195d26391783b11f6ca56f8eb92ad70622da47da63b7520adffdc81

data/lib/redis_client/cluster/concurrent_worker/none.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class RedisClient
+  class Cluster
+    module ConcurrentWorker
+      class None
+        def new_group(size:)
+          ::RedisClient::Cluster::ConcurrentWorker::Group.new(
+            worker: self,
+            queue: Array.new(size),
+            size: size
+          )
+        end
+
+        def push(task)
+          task.exec
+        end
+
+        def close; end
+      end
+    end
+  end
+end

data/lib/redis_client/cluster/concurrent_worker/on_demand.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class RedisClient
+  class Cluster
+    module ConcurrentWorker
+      class OnDemand
+        def initialize(size:)
+          @q = SizedQueue.new(size)
+        end
+
+        def new_group(size:)
+          ::RedisClient::Cluster::ConcurrentWorker::Group.new(
+            worker: self,
+            queue: SizedQueue.new(size),
+            size: size
+          )
+        end
+
+        def push(task)
+          @q << spawn_worker(task, @q)
+        end
+
+        def close
+          @q.clear
+          @q.close
+          nil
+        end
+
+        private
+
+        def spawn_worker(task, queue)
+          Thread.new(task, queue) do |t, q|
+            t.exec
+            q.pop
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis_client/cluster/concurrent_worker/pooled.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'redis_client/pid_cache'
+
+class RedisClient
+  class Cluster
+    module ConcurrentWorker
+      # This class is just an experimental implementation.
+      # Ruby VM allocates 1 MB memory as a stack for a thread.
+      # It is a fixed size but we can modify the size with some environment variables.
+      # So it consumes memory 1 MB multiplied a number of workers.
+      class Pooled
+        def initialize(size:)
+          @size = size
+          setup
+        end
+
+        def new_group(size:)
+          reset if @pid != ::RedisClient::PIDCache.pid
+          ensure_workers if @workers.first.nil?
+          ::RedisClient::Cluster::ConcurrentWorker::Group.new(
+            worker: self,
+            queue: SizedQueue.new(size),
+            size: size
+          )
+        end
+
+        def push(task)
+          @q << task
+        end
+
+        def close
+          @q.clear
+          @workers.each { |t| t&.exit }
+          @workers.clear
+          @q.close
+          @pid = nil
+          nil
+        end
+
+        private
+
+        def setup
+          @q = Queue.new
+          @workers = Array.new(@size)
+          @pid = ::RedisClient::PIDCache.pid
+        end
+
+        def reset
+          close
+          setup
+        end
+
+        def ensure_workers
+          @workers.size.times do |i|
+            @workers[i] = spawn_worker unless @workers[i]&.alive?
+          end
+        end
+
+        def spawn_worker
+          Thread.new(@q) { |q| loop { q.pop.exec } }
+        end
+      end
+    end
+  end
+end

data/lib/redis_client/cluster/concurrent_worker.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'redis_client/cluster/concurrent_worker/on_demand'
+require 'redis_client/cluster/concurrent_worker/pooled'
+require 'redis_client/cluster/concurrent_worker/none'
+
+class RedisClient
+  class Cluster
+    module ConcurrentWorker
+      InvalidNumberOfTasks = Class.new(::RedisClient::Error)
+
+      class Group
+        Task = Struct.new(
+          'RedisClusterClientConcurrentWorkerTask',
+          :id, :queue, :args, :kwargs, :block, :result,
+          keyword_init: true
+        ) do
+          def exec
+            self[:result] = block&.call(*args, **kwargs)
+          rescue StandardError => e
+            self[:result] = e
+          ensure
+            done
+          end
+
+          def done
+            queue&.push(self)
+          rescue ClosedQueueError
+            # something was wrong
+          end
+        end
+
+        def initialize(worker:, queue:, size:)
+          @worker = worker
+          @queue = queue
+          @size = size
+          @count = 0
+        end
+
+        def push(id, *args, **kwargs, &block)
+          raise InvalidNumberOfTasks, "max size reached: #{@count}" if @count == @size
+
+          task = Task.new(id: id, queue: @queue, args: args, kwargs: kwargs, block: block)
+          @worker.push(task)
+          @count += 1
+          nil
+        end
+
+        def each
+          raise InvalidNumberOfTasks, "expected: #{@size}, actual: #{@count}" if @count != @size
+
+          @size.times do
+            task = @queue.pop
+            yield(task.id, task.result)
+          end
+
+          nil
+        end
+
+        def close
+          @queue.clear
+          @queue.close if @queue.respond_to?(:close)
+          @count = 0
+          nil
+        end
+      end
+
+      module_function
+
+      def create(model: :on_demand, size: 5)
+        size = size.positive? ? size : 5
+
+        case model
+        when :on_demand, nil then ::RedisClient::Cluster::ConcurrentWorker::OnDemand.new(size: size)
+        when :pooled then ::RedisClient::Cluster::ConcurrentWorker::Pooled.new(size: size)
+        when :none then ::RedisClient::Cluster::ConcurrentWorker::None.new
+        else raise ArgumentError, "Unknown model: #{model}"
+        end
+      end
+    end
+  end
+end

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

@@ -13,11 +13,11 @@ class RedisClient
         DUMMY_LATENCY_MSEC = 100 * 1000 * 1000
         MEASURE_ATTEMPT_COUNT = 10
 
-        def initialize(replications, options, pool, **kwargs)
+        def initialize(replications, options, pool, concurrent_worker, **kwargs)
           super
 
           all_replica_clients = @clients.select { |k, _| @replica_node_keys.include?(k) }
-          latencies = measure_latencies(all_replica_clients)
+          latencies = measure_latencies(all_replica_clients, concurrent_worker)
           @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)
@@ -39,28 +39,35 @@ class RedisClient
 
         private
 
-        def measure_latencies(clients)
-          clients.each_slice(::RedisClient::Cluster::Node::MAX_THREADS).each_with_object({}) do |chuncked_clients, acc|
-            chuncked_clients
-              .map { |node_key, client| [node_key, build_thread_for_measuring_latency(client)] }
-              .each { |node_key, thread| acc[node_key] = thread.value }
-          end
-        end
+        def measure_latencies(clients, concurrent_worker) # rubocop:disable Metrics/AbcSize
+          return {} if clients.empty?
 
-        def build_thread_for_measuring_latency(client)
-          Thread.new(client) do |cli|
-            min = DUMMY_LATENCY_MSEC
-            MEASURE_ATTEMPT_COUNT.times do
-              starting = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
-              cli.call_once('PING')
-              duration = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond) - starting
-              min = duration if duration < min
-            end
+          work_group = concurrent_worker.new_group(size: clients.size)
+
+          clients.each do |node_key, client|
+            work_group.push(node_key, client) do |cli|
+              min = DUMMY_LATENCY_MSEC
+              MEASURE_ATTEMPT_COUNT.times do
+                starting = obtain_current_time
+                cli.call_once('PING')
+                duration = obtain_current_time - starting
+                min = duration if duration < min
+              end
 
-            min
-          rescue StandardError
-            DUMMY_LATENCY_MSEC
+              min
+            rescue StandardError
+              DUMMY_LATENCY_MSEC
+            end
           end
+
+          latencies = {}
+          work_group.each { |node_key, v| latencies[node_key] = v }
+          work_group.close
+          latencies
+        end
+
+        def obtain_current_time
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
         end
 
         def select_replica_clients(replications, clients)

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

@@ -6,7 +6,7 @@ class RedisClient
       class PrimaryOnly
         attr_reader :clients
 
-        def initialize(replications, options, pool, **kwargs)
+        def initialize(replications, options, pool, _concurrent_worker, **kwargs)
           @primary_node_keys = replications.keys.sort
           @clients = build_clients(@primary_node_keys, options, pool, **kwargs)
         end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'redis_client/cluster/node/replica_mixin'
+
+class RedisClient
+  class Cluster
+    class Node
+      class RandomReplicaOrPrimary
+        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|
+            decide_use_primary?(random, replica_node_keys.size) ? 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)
+
+          replica_node_keys = @replications.fetch(primary_node_key, EMPTY_ARRAY)
+          if decide_use_primary?(random, replica_node_keys.size)
+            primary_node_key
+          else
+            replica_node_keys.sample(random: random) || primary_node_key
+          end
+        end
+
+        def any_replica_node_key(seed: nil)
+          random = seed.nil? ? Random : Random.new(seed)
+          @replica_node_keys.sample(random: random) || any_primary_node_key(seed: seed)
+        end
+
+        private
+
+        # Randomly equally likely choose node to read between primary and all replicas
+        # e.g. 1 primary + 1 replica = 50% probability to read from primary
+        # e.g. 1 primary + 2 replica = 33% probability to read from primary
+        # e.g. 1 primary + 0 replica = 100% probability to read from primary
+        def decide_use_primary?(random, replica_nodes)
+          primary_nodes = 1.0
+          total = primary_nodes + replica_nodes
+          random.rand < primary_nodes / total
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,7 @@ class RedisClient
 
         EMPTY_ARRAY = [].freeze
 
-        def initialize(replications, options, pool, **kwargs)
+        def initialize(replications, options, pool, _concurrent_worker, **kwargs)
           @replications = replications
           @primary_node_keys = @replications.keys.sort
           @replica_node_keys = @replications.values.flatten.sort

data/lib/redis_client/cluster/node.rb

@@ -5,6 +5,7 @@ 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/random_replica_or_primary'
 require 'redis_client/cluster/node/latency_replica'
 
 class RedisClient
@@ -16,7 +17,6 @@ class RedisClient
       MIN_SLOT = 0
       MAX_SLOT = SLOT_SIZE - 1
       MAX_STARTUP_SAMPLE = Integer(ENV.fetch('REDIS_CLIENT_MAX_STARTUP_SAMPLE', 3))
-      MAX_THREADS = Integer(ENV.fetch('REDIS_CLIENT_MAX_THREADS', 5))
       IGNORE_GENERIC_CONFIG_KEYS = %i[url host port path].freeze
       DEAD_FLAGS = %w[fail? fail handshake noaddr noflags].freeze
       ROLE_FLAGS = %w[master slave].freeze
@@ -88,27 +88,40 @@ class RedisClient
       end
 
       class << self
-        def load_info(options, **kwargs) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def load_info(options, concurrent_worker, **kwargs) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          raise ::RedisClient::Cluster::InitialSetupError, [] if options.nil? || options.empty?
+
           startup_size = options.size > MAX_STARTUP_SAMPLE ? MAX_STARTUP_SAMPLE : options.size
+          startup_options = options.to_a.sample(startup_size).to_h
+          startup_nodes = ::RedisClient::Cluster::Node.new(startup_options, concurrent_worker, **kwargs)
+          work_group = concurrent_worker.new_group(size: startup_size)
+
+          startup_nodes.each_with_index do |raw_client, i|
+            work_group.push(i, raw_client) do |client|
+              reply = client.call('CLUSTER', 'NODES')
+              parse_cluster_node_reply(reply)
+            rescue StandardError => e
+              e
+            ensure
+              client&.close
+            end
+          end
+
           node_info_list = errors = nil
-          startup_options = options.to_a.sample(MAX_STARTUP_SAMPLE).to_h
-          startup_nodes = ::RedisClient::Cluster::Node.new(startup_options, **kwargs)
-          startup_nodes.each_slice(MAX_THREADS).with_index do |chuncked_startup_nodes, chuncked_idx|
-            chuncked_startup_nodes
-              .each_with_index
-              .map { |raw_client, idx| [(MAX_THREADS * chuncked_idx) + idx, build_thread_for_cluster_node(raw_client)] }
-              .each do |i, t|
-                case v = t.value
-                when StandardError
-                  errors ||= Array.new(startup_size)
-                  errors[i] = v
-                else
-                  node_info_list ||= Array.new(startup_size)
-                  node_info_list[i] = v
-                end
-              end
+
+          work_group.each do |i, v|
+            case v
+            when StandardError
+              errors ||= Array.new(startup_size)
+              errors[i] = v
+            else
+              node_info_list ||= Array.new(startup_size)
+              node_info_list[i] = v
+            end
           end
 
+          work_group.close
+
           raise ::RedisClient::Cluster::InitialSetupError, errors if node_info_list.nil?
 
           grouped = node_info_list.compact.group_by do |info_list|
@@ -123,17 +136,6 @@ class RedisClient
 
         private
 
-        def build_thread_for_cluster_node(raw_client)
-          Thread.new(raw_client) do |client|
-            reply = client.call('CLUSTER', 'NODES')
-            parse_cluster_node_reply(reply)
-          rescue StandardError => e
-            e
-          ensure
-            client&.close
-          end
-        end
-
         # @see https://redis.io/commands/cluster-nodes/
         # @see https://github.com/redis/redis/blob/78960ad57b8a5e6af743d789ed8fd767e37d42b8/src/cluster.c#L4660-L4683
         def parse_cluster_node_reply(reply) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
@@ -182,6 +184,7 @@ class RedisClient
 
       def initialize(
         options,
+        concurrent_worker,
         node_info_list: [],
         with_replica: false,
         replica_affinity: :random,
@@ -189,9 +192,11 @@ class RedisClient
         **kwargs
       )
 
+        @concurrent_worker = concurrent_worker
         @slots = build_slot_node_mappings(node_info_list)
         @replications = build_replication_mappings(node_info_list)
-        @topology = make_topology_class(with_replica, replica_affinity).new(@replications, options, pool, **kwargs)
+        klass = make_topology_class(with_replica, replica_affinity)
+        @topology = klass.new(@replications, options, pool, @concurrent_worker, **kwargs)
         @mutex = Mutex.new
       end
 
@@ -284,6 +289,8 @@ class RedisClient
       def make_topology_class(with_replica, replica_affinity)
         if with_replica && replica_affinity == :random
           ::RedisClient::Cluster::Node::RandomReplica
+        elsif with_replica && replica_affinity == :random_with_primary
+          ::RedisClient::Cluster::Node::RandomReplicaOrPrimary
         elsif with_replica && replica_affinity == :latency
           ::RedisClient::Cluster::Node::LatencyReplica
         else
@@ -333,32 +340,35 @@ class RedisClient
         raise ::RedisClient::Cluster::ErrorCollection, errors
       end
 
-      def try_map(clients, &block)
-        results = errors = nil
-        clients.each_slice(MAX_THREADS) do |chuncked_clients|
-          chuncked_clients
-            .map { |node_key, client| [node_key, build_thread_for_command(node_key, client, &block)] }
-            .each do |node_key, thread|
-              case v = thread.value
-              when StandardError
-                errors ||= {}
-                errors[node_key] = v
-              else
-                results ||= {}
-                results[node_key] = v
-              end
-            end
+      def try_map(clients, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        return [{}, {}] if clients.empty?
+
+        work_group = @concurrent_worker.new_group(size: clients.size)
+
+        clients.each do |node_key, client|
+          work_group.push(node_key, node_key, client, block) do |nk, cli, blk|
+            blk.call(nk, cli)
+          rescue StandardError => e
+            e
+          end
         end
 
-        [results, errors]
-      end
+        results = errors = nil
 
-      def build_thread_for_command(node_key, client)
-        Thread.new(node_key, client) do |nk, cli|
-          yield(nk, cli)
-        rescue StandardError => e
-          e
+        work_group.each do |node_key, v|
+          case v
+          when StandardError
+            errors ||= {}
+            errors[node_key] = v
+          else
+            results ||= {}
+            results[node_key] = v
+          end
         end
+
+        work_group.close
+
+        [results, errors]
       end
     end
   end

data/lib/redis_client/cluster/pipeline.rb

@@ -95,11 +95,10 @@ class RedisClient
         attr_accessor :replies, :indices
       end
 
-      MAX_THREADS = Integer(ENV.fetch('REDIS_CLIENT_MAX_THREADS', 5))
-
-      def initialize(router, command_builder, seed: Random.new_seed)
+      def initialize(router, command_builder, concurrent_worker, seed: Random.new_seed)
         @router = router
         @command_builder = command_builder
+        @concurrent_worker = concurrent_worker
         @seed = seed
         @pipelines = nil
         @size = 0
@@ -146,27 +145,39 @@ class RedisClient
       end
 
       def execute # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        return if @pipelines.nil? || @pipelines.empty?
+
+        work_group = @concurrent_worker.new_group(size: @pipelines.size)
+
+        @pipelines.each do |node_key, pipeline|
+          work_group.push(node_key, @router.find_node(node_key), pipeline) do |cli, pl|
+            replies = do_pipelining(cli, pl)
+            raise ReplySizeError, "commands: #{pl._size}, replies: #{replies.size}" if pl._size != replies.size
+
+            replies
+          end
+        end
+
         all_replies = errors = nil
-        @pipelines&.each_slice(MAX_THREADS) do |chuncked_pipelines|
-          chuncked_pipelines
-            .map { |node_key, pipeline| [node_key, build_thread_for_pipeline(@router, node_key, pipeline)] }
-            .each do |node_key, thread|
-              case v = thread.value
-              when ::RedisClient::Cluster::Pipeline::RedirectionNeeded
-                all_replies ||= Array.new(@size)
-                pipeline = @pipelines[node_key]
-                v.indices.each { |i| v.replies[i] = handle_redirection(v.replies[i], pipeline, i) }
-                pipeline.outer_indices.each_with_index { |outer, inner| all_replies[outer] = v.replies[inner] }
-              when StandardError
-                errors ||= {}
-                errors[node_key] = v
-              else
-                all_replies ||= Array.new(@size)
-                @pipelines[node_key].outer_indices.each_with_index { |outer, inner| all_replies[outer] = v[inner] }
-              end
-            end
+
+        work_group.each do |node_key, v|
+          case v
+          when ::RedisClient::Cluster::Pipeline::RedirectionNeeded
+            all_replies ||= Array.new(@size)
+            pipeline = @pipelines[node_key]
+            v.indices.each { |i| v.replies[i] = handle_redirection(v.replies[i], pipeline, i) }
+            pipeline.outer_indices.each_with_index { |outer, inner| all_replies[outer] = v.replies[inner] }
+          when StandardError
+            errors ||= {}
+            errors[node_key] = v
+          else
+            all_replies ||= Array.new(@size)
+            @pipelines[node_key].outer_indices.each_with_index { |outer, inner| all_replies[outer] = v[inner] }
+          end
         end
 
+        work_group.close
+
         raise ::RedisClient::Cluster::ErrorCollection, errors unless errors.nil?
 
         all_replies
@@ -182,17 +193,6 @@ class RedisClient
         @pipelines[node_key]
       end
 
-      def build_thread_for_pipeline(router, node_key, pipeline)
-        Thread.new(router, node_key, pipeline) do |rt, nk, pl|
-          replies = do_pipelining(rt.find_node(nk), pl)
-          raise ReplySizeError, "commands: #{pl._size}, replies: #{replies.size}" if pl._size != replies.size
-
-          replies
-        rescue StandardError => e
-          e
-        end
-      end
-
       def do_pipelining(client, pipeline)
         case client
         when ::RedisClient then send_pipeline(client, pipeline)

data/lib/redis_client/cluster/pub_sub.rb

@@ -6,44 +6,47 @@ class RedisClient
   class Cluster
     class PubSub
       class State
-        def initialize(client)
+        def initialize(client, queue)
           @client = client
           @worker = nil
+          @queue = queue
         end
 
         def call(command)
           @client.call_v(command)
         end
 
+        def ensure_worker
+          @worker = spawn_worker(@client, @queue) unless @worker&.alive?
+        end
+
         def close
           @worker.exit if @worker&.alive?
           @client.close
         end
 
-        def take_message(timeout)
-          @worker = subscribe(@client, timeout) if @worker.nil?
-          return if @worker.alive?
-
-          message = @worker.value
-          @worker = nil
-          message
-        end
-
         private
 
-        def subscribe(client, timeout)
-          Thread.new(client, timeout) do |pubsub, to|
-            pubsub.next_event(to)
-          rescue StandardError => e
-            e
+        def spawn_worker(client, queue)
+          # Ruby VM allocates 1 MB memory as a stack for a thread.
+          # It is a fixed size but we can modify the size with some environment variables.
+          # So it consumes memory 1 MB multiplied a number of workers.
+          Thread.new(client, queue) do |pubsub, q|
+            loop do
+              q << pubsub.next_event
+            rescue StandardError => e
+              q << e
+            end
           end
         end
       end
 
+      BUF_SIZE = Integer(ENV.fetch('REDIS_CLIENT_PUBSUB_BUF_SIZE', 1024))
+
       def initialize(router, command_builder)
         @router = router
         @command_builder = command_builder
-        @state_list = []
+        @queue = SizedQueue.new(BUF_SIZE)
         @state_dict = {}
       end
 
@@ -56,26 +59,27 @@ class RedisClient
       end
 
       def close
-        @state_list.each(&:close)
-        @state_list.clear
+        @state_dict.each_value(&:close)
         @state_dict.clear
+        @queue.clear
+        @queue.close
+        nil
       end
 
       def next_event(timeout = nil)
-        return if @state_list.empty?
-
-        @state_list.shuffle!
+        @state_dict.each_value(&:ensure_worker)
         max_duration = calc_max_duration(timeout)
         starting = obtain_current_time
+
         loop do
           break if max_duration > 0 && obtain_current_time - starting > max_duration
 
-          @state_list.each do |pubsub|
-            message = pubsub.take_message(timeout)
-            return message if message
+          case event = @queue.pop(true)
+          when StandardError then raise event
+          when Array then break event
           end
-
-          sleep 0.001
+        rescue ThreadError
+          sleep 0.005
         end
       end
 
@@ -100,8 +104,7 @@ class RedisClient
       def add_state(node_key)
         return @state_dict[node_key] if @state_dict.key?(node_key)
 
-        state = State.new(@router.find_node(node_key).pubsub)
-        @state_list << state
+        state = State.new(@router.find_node(node_key).pubsub, @queue)
         @state_dict[node_key] = state
       end
 

data/lib/redis_client/cluster/router.rb

@@ -16,13 +16,12 @@ class RedisClient
       METHODS_FOR_BLOCKING_CMD = %i[blocking_call_v blocking_call].freeze
       TSF = ->(f, x) { f.nil? ? x : f.call(x) }.curry
 
-      attr_reader :node
-
-      def initialize(config, pool: nil, **kwargs)
+      def initialize(config, concurrent_worker, pool: nil, **kwargs)
         @config = config.dup
+        @concurrent_worker = concurrent_worker
         @pool = pool
         @client_kwargs = kwargs
-        @node = fetch_cluster_info(@config, pool: @pool, **@client_kwargs)
+        @node = fetch_cluster_info(@config, @concurrent_worker, pool: @pool, **@client_kwargs)
         @command = ::RedisClient::Cluster::Command.load(@node.shuffled_nodes)
         @mutex = Mutex.new
         @command_builder = @config.command_builder
@@ -206,6 +205,14 @@ class RedisClient
         find_node(node_key)
       end
 
+      def node_keys
+        @node.node_keys
+      end
+
+      def close
+        @node.each(&:close)
+      end
+
       private
 
       def send_wait_command(method, command, args, retry_count: 3, &block) # rubocop:disable Metrics/AbcSize
@@ -284,12 +291,13 @@ class RedisClient
         end
       end
 
-      def fetch_cluster_info(config, pool: nil, **kwargs)
-        node_info_list = ::RedisClient::Cluster::Node.load_info(config.per_node_key, **kwargs)
+      def fetch_cluster_info(config, concurrent_worker, pool: nil, **kwargs)
+        node_info_list = ::RedisClient::Cluster::Node.load_info(config.per_node_key, concurrent_worker, **kwargs)
         node_addrs = node_info_list.map { |i| ::RedisClient::Cluster::NodeKey.hashify(i.node_key) }
         config.update_node(node_addrs)
         ::RedisClient::Cluster::Node.new(
           config.per_node_key,
+          concurrent_worker,
           node_info_list: node_info_list,
           pool: pool,
           with_replica: config.use_replica?,
@@ -308,7 +316,7 @@ class RedisClient
             # ignore
           end
 
-          @node = fetch_cluster_info(@config, pool: @pool, **@client_kwargs)
+          @node = fetch_cluster_info(@config, @concurrent_worker, pool: @pool, **@client_kwargs)
         end
       end
     end

data/lib/redis_client/cluster.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'redis_client/cluster/concurrent_worker'
 require 'redis_client/cluster/pipeline'
 require 'redis_client/cluster/pub_sub'
 require 'redis_client/cluster/router'
@@ -10,14 +11,15 @@ class RedisClient
 
     attr_reader :config
 
-    def initialize(config, pool: nil, **kwargs)
+    def initialize(config, pool: nil, concurrency: nil, **kwargs)
       @config = config
-      @router = ::RedisClient::Cluster::Router.new(config, pool: pool, **kwargs)
+      @concurrent_worker = ::RedisClient::Cluster::ConcurrentWorker.create(**(concurrency || {}))
+      @router = ::RedisClient::Cluster::Router.new(config, @concurrent_worker, pool: pool, **kwargs)
       @command_builder = config.command_builder
     end
 
     def inspect
-      "#<#{self.class.name} #{@router.node.node_keys.join(', ')}>"
+      "#<#{self.class.name} #{@router.node_keys.join(', ')}>"
     end
 
     def call(*args, **kwargs, &block)
@@ -79,7 +81,7 @@ class RedisClient
 
     def pipelined
       seed = @config.use_replica? && @config.replica_affinity == :random ? nil : Random.new_seed
-      pipeline = ::RedisClient::Cluster::Pipeline.new(@router, @command_builder, seed: seed)
+      pipeline = ::RedisClient::Cluster::Pipeline.new(@router, @command_builder, @concurrent_worker, seed: seed)
       yield pipeline
       return [] if pipeline.empty?
 
@@ -91,7 +93,8 @@ class RedisClient
     end
 
     def close
-      @router.node.each(&:close)
+      @concurrent_worker.close
+      @router.close
       nil
     end
 

data/lib/redis_client/cluster_config.rb

@@ -17,6 +17,7 @@ class RedisClient
     VALID_NODES_KEYS = %i[ssl username password host port db].freeze
     MERGE_CONFIG_KEYS = %i[ssl username password].freeze
     IGNORE_GENERIC_CONFIG_KEYS = %i[url host port path].freeze
+    MAX_WORKERS = Integer(ENV.fetch('REDIS_CLIENT_MAX_THREADS', 5))
 
     InvalidClientConfigError = Class.new(::RedisClient::Error)
 
@@ -27,7 +28,8 @@ class RedisClient
       replica: false,
       replica_affinity: :random,
       fixed_hostname: '',
-      client_implementation: Cluster,
+      concurrency: nil,
+      client_implementation: ::RedisClient::Cluster, # for redis gem
       **client_config
     )
 
@@ -38,6 +40,7 @@ class RedisClient
       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)
+      @concurrency = merge_concurrency_option(concurrency)
       @client_implementation = client_implementation
       @mutex = Mutex.new
     end
@@ -48,6 +51,7 @@ class RedisClient
         replica: @replica,
         replica_affinity: @replica_affinity,
         fixed_hostname: @fixed_hostname,
+        concurrency: @concurrency,
         client_implementation: @client_implementation,
         **@client_config
       )
@@ -58,15 +62,20 @@ class RedisClient
     end
 
     def read_timeout
-      @client_config[:read_timeout] || @client_config[:timeout] || RedisClient::Config::DEFAULT_TIMEOUT
+      @client_config[:read_timeout] || @client_config[:timeout] || ::RedisClient::Config::DEFAULT_TIMEOUT
     end
 
     def new_pool(size: 5, timeout: 5, **kwargs)
-      @client_implementation.new(self, pool: { size: size, timeout: timeout }, **kwargs)
+      @client_implementation.new(
+        self,
+        pool: { size: size, timeout: timeout },
+        concurrency: @concurrency,
+        **kwargs
+      )
     end
 
     def new_client(**kwargs)
-      @client_implementation.new(self, **kwargs)
+      @client_implementation.new(self, concurrency: @concurrency, **kwargs)
     end
 
     def per_node_key
@@ -96,6 +105,15 @@ class RedisClient
 
     private
 
+    def merge_concurrency_option(option)
+      case option
+      when Hash
+        option = option.transform_keys(&:to_sym)
+        { size: MAX_WORKERS }.merge(option)
+      else { size: MAX_WORKERS }
+      end
+    end
+
     def build_node_configs(addrs)
       configs = Array[addrs].flatten.filter_map { |addr| parse_node_addr(addr) }
       raise InvalidClientConfigError, '`nodes` option is empty' if configs.empty?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.4.17
+  version: 0.6.0
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-02 00:00:00.000000000 Z
+date: 2023-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -34,12 +34,17 @@ files:
 - lib/redis-cluster-client.rb
 - lib/redis_client/cluster.rb
 - lib/redis_client/cluster/command.rb
+- lib/redis_client/cluster/concurrent_worker.rb
+- lib/redis_client/cluster/concurrent_worker/none.rb
+- lib/redis_client/cluster/concurrent_worker/on_demand.rb
+- lib/redis_client/cluster/concurrent_worker/pooled.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/random_replica_or_primary.rb
 - lib/redis_client/cluster/node/replica_mixin.rb
 - lib/redis_client/cluster/node_key.rb
 - lib/redis_client/cluster/normalized_cmd_name.rb