redis-cluster-client 0.4.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e29792dd4eb3b7609baa8943b25a385c87dd36767ba679e9c9209be765a670b
-  data.tar.gz: 367d7cb722ef026b76c7f200237c1c64a0dced84026c78a43feb55a72eb7accb
+  metadata.gz: 82e7044600bf789f17ab9db7287beb76ebdb8c1b24c3816523da64af6a836038
+  data.tar.gz: ca55b62fc6a4252999f4fd0080cc267bfa31609eb8c9645265072bf374e61231
 SHA512:
-  metadata.gz: c3b7eb12f99b928072eeb00f4465afc5be3a3cb07aeabfc821369151f94ebbf12029409317c21b57cb628710e786e1e423b84f543b7430c23d89f71e9fe9339b
-  data.tar.gz: c317f99c5bb51be184f4aab415017260237e3614e535565649bb90d79a2b47c7b9edfb07c83b3a96ead85849c7bd97639ce6d60eb1f957df351908ae098f6795
+  metadata.gz: fe4e0e00d82ec9afab61a96265d1f0eb6f580ce6f9b1721df1135b2b298b21c99de46f0f04cba48a5173a299896897de80037e3256ed39f9605c6f51d3c3fd0c
+  data.tar.gz: 956d3d22f40b00c6ec8608d06d33bb85e2ba0af810ffa68a30c51469423c7542eb52f33f71695dfe02a4c2e2577b4f870dd7684c920276adb205bf5df61630bd

data/lib/redis_client/cluster/command.rb

@@ -7,6 +7,8 @@ require 'redis_client/cluster/normalized_cmd_name'
 class RedisClient
   class Cluster
     class Command
+      SLOW_COMMAND_TIMEOUT = Float(ENV.fetch('REDIS_CLIENT_SLOW_COMMAND_TIMEOUT', -1))
+
       EMPTY_STRING = ''
       LEFT_BRACKET = '{'
       RIGHT_BRACKET = '}'
@@ -25,7 +27,10 @@ class RedisClient
           cmd = errors = nil
 
           nodes&.each do |node|
+            regular_timeout = node.read_timeout
+            node.read_timeout = SLOW_COMMAND_TIMEOUT > 0.0 ? SLOW_COMMAND_TIMEOUT : regular_timeout
             reply = node.call('COMMAND')
+            node.read_timeout = regular_timeout
             commands = parse_command_reply(reply)
             cmd = ::RedisClient::Cluster::Command.new(commands)
             break

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class RedisClient
+  class Cluster
+    module ConcurrentWorker
+      class None
+        def new_group(size:)
+          ::RedisClient::Cluster::ConcurrentWorker::Group.new(
+            worker: self,
+            queue: [],
+            size: size
+          )
+        end
+
+        def push(task)
+          task.exec
+        end
+
+        def close; end
+
+        def inspect
+          "#<#{self.class.name} main thread only>"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# 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
+
+        def inspect
+          "#<#{self.class.name} active: #{@q.size}, max: #{@q.max}>"
+        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,72 @@
+# 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
+
+        def inspect
+          "#<#{self.class.name} tasks: #{@q.size}, workers: #{@size}>"
+        end
+
+        private
+
+        def setup
+          @q = Queue.new
+          @workers = Array.new(@size)
+          @pid = ::RedisClient::PIDCache.pid
+        end
+
+        def reset
+          close
+          setup
+        end
+
+        def ensure_workers
+          @size.times do |i|
+            @workers[i] = spawn_worker unless @workers[i]&.alive?
+          end
+        end
+
+        def spawn_worker
+          Thread.new(@q) do |q|
+            loop { q.pop.exec }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis_client/cluster/concurrent_worker.rb

@@ -0,0 +1,86 @@
+# 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(StandardError)
+
+      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
+
+        def inspect
+          "#<#{self.class.name} size: #{@count}, max: #{@size}, worker: #{@worker.class.name}>"
+        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

@@ -10,14 +10,14 @@ class RedisClient
 
         attr_reader :replica_clients
 
-        DUMMY_LATENCY_NSEC = 100 * 1000 * 1000 * 1000
+        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,31 +39,35 @@ class RedisClient
 
         private
 
-        def measure_latencies(clients) # rubocop:disable Metrics/AbcSize
-          clients.each_slice(::RedisClient::Cluster::Node::MAX_THREADS).each_with_object({}) do |chuncked_clients, acc|
-            threads = chuncked_clients.map do |k, v|
-              Thread.new(k, v) do |node_key, client|
-                Thread.current[:node_key] = node_key
-
-                min = DUMMY_LATENCY_NSEC
-                MEASURE_ATTEMPT_COUNT.times do
-                  starting = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
-                  client.call_once('PING')
-                  duration = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond) - starting
-                  min = duration if duration < min
-                end
-
-                Thread.current[:latency] = min
-              rescue StandardError
-                Thread.current[:latency] = DUMMY_LATENCY_NSEC
+        def measure_latencies(clients, concurrent_worker) # rubocop:disable Metrics/AbcSize
+          return {} if clients.empty?
+
+          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
-            end
 
-            threads.each do |t|
-              t.join
-              acc[t[:node_key]] = t[:latency]
+              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
@@ -24,12 +24,12 @@ class RedisClient
         private
 
         def build_clients(primary_node_keys, options, pool, **kwargs)
-          options.filter_map do |node_key, option|
+          options.to_h 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

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
@@ -12,11 +13,18 @@ class RedisClient
     class Node
       include Enumerable
 
+      # It affects to strike a balance between load and stability in initialization or changed states.
+      MAX_STARTUP_SAMPLE = Integer(ENV.fetch('REDIS_CLIENT_MAX_STARTUP_SAMPLE', 3))
+
+      # It's used with slow queries of fetching meta data like CLUSTER NODES, COMMAND and so on.
+      SLOW_COMMAND_TIMEOUT = Float(ENV.fetch('REDIS_CLIENT_SLOW_COMMAND_TIMEOUT', -1))
+
+      # less memory consumption, but slow
+      USE_CHAR_ARRAY_SLOT = Integer(ENV.fetch('REDIS_CLIENT_USE_CHAR_ARRAY_SLOT', 1)) == 1
+
       SLOT_SIZE = 16_384
       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
       DEAD_FLAGS = %w[fail? fail handshake noaddr noflags].freeze
       ROLE_FLAGS = %w[master slave].freeze
@@ -88,36 +96,43 @@ 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
-          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|
-            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.current[:index] = i
-                reply = cli.call('CLUSTER', 'NODES')
-                Thread.current[:info] = parse_cluster_node_reply(reply)
-              rescue StandardError => e
-                Thread.current[:error] = e
-              ensure
-                cli&.close
-              end
+          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|
+              regular_timeout = client.read_timeout
+              client.read_timeout = SLOW_COMMAND_TIMEOUT > 0.0 ? SLOW_COMMAND_TIMEOUT : regular_timeout
+              reply = client.call('CLUSTER', 'NODES')
+              client.read_timeout = regular_timeout
+              parse_cluster_node_reply(reply)
+            rescue StandardError => e
+              e
+            ensure
+              client&.close
             end
+          end
+
+          node_info_list = errors = nil
 
-            threads.each do |t|
-              t.join
-              if t.key?(:info)
-                node_info_list ||= Array.new(startup_size)
-                node_info_list[t[:index]] = t[:info]
-              elsif t.key?(:error)
-                errors ||= Array.new(startup_size)
-                errors[t[:index]] = t[:error]
-              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|
@@ -180,6 +195,7 @@ class RedisClient
 
       def initialize(
         options,
+        concurrent_worker,
         node_info_list: [],
         with_replica: false,
         replica_affinity: :random,
@@ -187,9 +203,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
 
@@ -240,6 +258,10 @@ class RedisClient
         @topology.clients_for_scanning(seed: seed).values.sort_by { |c| "#{c.config.host}-#{c.config.port}" }
       end
 
+      def replica_clients
+        @topology.replica_clients.values
+      end
+
       def find_node_key_of_primary(slot)
         return if slot.nil?
 
@@ -278,6 +300,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
@@ -297,7 +321,7 @@ class RedisClient
       end
 
       def make_array_for_slot_node_mappings(node_info_list)
-        return Array.new(SLOT_SIZE) if node_info_list.count(&:primary?) > 256
+        return Array.new(SLOT_SIZE) if !USE_CHAR_ARRAY_SLOT || node_info_list.count(&:primary?) > 256
 
         primary_node_keys = node_info_list.select(&:primary?).map(&:node_key)
         ::RedisClient::Cluster::Node::CharArray.new(SLOT_SIZE, primary_node_keys)
@@ -327,31 +351,34 @@ class RedisClient
         raise ::RedisClient::Cluster::ErrorCollection, errors
       end
 
-      def try_map(clients) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        results = errors = nil
-        clients.each_slice(MAX_THREADS) do |chuncked_clients|
-          threads = chuncked_clients.map do |k, v|
-            Thread.new(k, v) do |node_key, client|
-              Thread.current[:node_key] = node_key
-              reply = yield(node_key, client)
-              Thread.current[:result] = reply
-            rescue StandardError => e
-              Thread.current[:error] = e
-            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
 
-          threads.each do |t|
-            t.join
-            if t.key?(:result)
-              results ||= {}
-              results[t[:node_key]] = t[:result]
-            elsif t.key?(:error)
-              errors ||= {}
-              errors[t[:node_key]] = t[:error]
-            end
+        results = errors = nil
+
+        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

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,42 +145,39 @@ class RedisClient
       end
 
       def execute # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        all_replies = errors = nil
-        @pipelines&.each_slice(MAX_THREADS) do |chuncked_pipelines|
-          threads = chuncked_pipelines.map do |node_key, pipeline|
-            Thread.new(node_key, pipeline) do |nk, pl|
-              Thread.current[:node_key] = nk
-              replies = do_pipelining(@router.find_node(nk), pl)
-              raise ReplySizeError, "commands: #{pl._size}, replies: #{replies.size}" if pl._size != replies.size
-
-              Thread.current[:replies] = replies
-            rescue ::RedisClient::Cluster::Pipeline::RedirectionNeeded => e
-              Thread.current[:redirection_needed] = e
-            rescue StandardError => e
-              Thread.current[:error] = e
-            end
+        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
 
-          threads.each(&:join)
-          threads.each do |t|
-            if t.key?(:replies)
-              all_replies ||= Array.new(@size)
-              @pipelines[t[:node_key]]
-                .outer_indices
-                .each_with_index { |outer, inner| all_replies[outer] = t[:replies][inner] }
-            elsif t.key?(:redirection_needed)
-              all_replies ||= Array.new(@size)
-              pipeline = @pipelines[t[:node_key]]
-              err = t[:redirection_needed]
-              err.indices.each { |i| err.replies[i] = handle_redirection(err.replies[i], pipeline, i) }
-              pipeline.outer_indices.each_with_index { |outer, inner| all_replies[outer] = err.replies[inner] }
-            elsif t.key?(:error)
-              errors ||= {}
-              errors[t[:node_key]] = t[:error]
-            end
+        all_replies = errors = nil
+
+        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

data/lib/redis_client/cluster/pub_sub.rb

@@ -1,35 +1,143 @@
 # frozen_string_literal: true
 
+require 'redis_client'
+require 'redis_client/cluster/normalized_cmd_name'
+
 class RedisClient
   class Cluster
     class PubSub
+      class State
+        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
+
+        private
+
+        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
-        @pubsub = nil
+        @queue = SizedQueue.new(BUF_SIZE)
+        @state_dict = {}
       end
 
       def call(*args, **kwargs)
-        close
-        command = @command_builder.generate(args, kwargs)
-        @pubsub = @router.assign_node(command).pubsub
-        @pubsub.call_v(command)
+        _call(@command_builder.generate(args, kwargs))
+        nil
       end
 
       def call_v(command)
-        close
-        command = @command_builder.generate(command)
-        @pubsub = @router.assign_node(command).pubsub
-        @pubsub.call_v(command)
+        _call(@command_builder.generate(command))
+        nil
       end
 
       def close
-        @pubsub&.close
-        @pubsub = nil
+        @state_dict.each_value(&:close)
+        @state_dict.clear
+        @queue.clear
+        @queue.close
+        nil
       end
 
       def next_event(timeout = nil)
-        @pubsub&.next_event(timeout)
+        @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
+
+          case event = @queue.pop(true)
+          when StandardError then raise event
+          when Array then break event
+          end
+        rescue ThreadError
+          sleep 0.005
+        end
+      end
+
+      private
+
+      def _call(command)
+        case ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
+        when 'subscribe', 'psubscribe', 'ssubscribe' then call_to_single_state(command)
+        when 'unsubscribe', 'punsubscribe' then call_to_all_states(command)
+        when 'sunsubscribe' then call_for_sharded_states(command)
+        else call_to_single_state(command)
+        end
+      end
+
+      def call_to_single_state(command)
+        node_key = @router.find_node_key(command)
+        try_call(node_key, command)
+      end
+
+      def call_to_all_states(command)
+        @state_dict.each_value { |s| s.call(command) }
+      end
+
+      def call_for_sharded_states(command)
+        if command.size == 1
+          call_to_all_states(command)
+        else
+          call_to_single_state(command)
+        end
+      end
+
+      def try_call(node_key, command, retry_count: 1)
+        add_state(node_key).call(command)
+      rescue ::RedisClient::CommandError => e
+        raise if !e.message.start_with?('MOVED') || retry_count <= 0
+
+        # for sharded pub/sub
+        node_key = e.message.split[2]
+        retry_count -= 1
+        retry
+      end
+
+      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, @queue)
+        @state_dict[node_key] = state
+      end
+
+      def obtain_current_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+      end
+
+      def calc_max_duration(timeout)
+        timeout.nil? || timeout < 0 ? 0 : timeout * 1_000_000
       end
     end
   end

data/lib/redis_client/cluster/router.rb

@@ -16,14 +16,13 @@ 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)
-        @command = ::RedisClient::Cluster::Command.load(@node)
+        @node = fetch_cluster_info(@config, @concurrent_worker, pool: @pool, **@client_kwargs)
+        @command = ::RedisClient::Cluster::Command.load(@node.replica_clients.shuffle)
         @mutex = Mutex.new
         @command_builder = @config.command_builder
       end
@@ -180,6 +179,12 @@ class RedisClient
         end
       end
 
+      def find_primary_node_key(command)
+        key = @command.extract_first_key(command)
+        slot = key.empty? ? nil : ::RedisClient::Cluster::KeySlotConverter.convert(key)
+        @node.find_node_key_of_primary(slot)
+      end
+
       def find_node(node_key, retry_count: 3)
         @node.find_by(node_key)
       rescue ::RedisClient::Cluster::Node::ReloadNeeded
@@ -206,6 +211,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
@@ -275,21 +288,29 @@ class RedisClient
 
       def send_pubsub_command(method, command, args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         case ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_subcommand(command)
-        when 'channels' then @node.call_all(method, command, args).flatten.uniq.sort_by(&:to_s).then(&TSF.call(block))
+        when 'channels'
+          @node.call_all(method, command, args).flatten.uniq.sort_by(&:to_s).then(&TSF.call(block))
+        when 'shardchannels'
+          @node.call_replicas(method, command, args).flatten.uniq.sort_by(&:to_s).then(&TSF.call(block))
+        when 'numpat'
+          @node.call_all(method, command, args).select { |e| e.is_a?(Integer) }.sum.then(&TSF.call(block))
         when 'numsub'
           @node.call_all(method, command, args).reject(&:empty?).map { |e| Hash[*e] }
                .reduce({}) { |a, e| a.merge(e) { |_, v1, v2| v1 + v2 } }.then(&TSF.call(block))
-        when 'numpat' then @node.call_all(method, command, args).select { |e| e.is_a?(Integer) }.sum.then(&TSF.call(block))
+        when 'shardnumsub'
+          @node.call_replicas(method, command, args).reject(&:empty?).map { |e| Hash[*e] }
+               .reduce({}) { |a, e| a.merge(e) { |_, v1, v2| v1 + v2 } }.then(&TSF.call(block))
         else assign_node(command).public_send(method, *args, command, &block)
         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 +329,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/transaction.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'redis_client'
+
+class RedisClient
+  class Cluster
+    class Transaction
+      ConsistencyError = Class.new(::RedisClient::Error)
+
+      def initialize(router, command_builder)
+        @router = router
+        @command_builder = command_builder
+        @node_key = nil
+      end
+
+      def call(*command, **kwargs, &_)
+        command = @command_builder.generate(command, kwargs)
+        ensure_node_key(command)
+      end
+
+      def call_v(command, &_)
+        command = @command_builder.generate(command)
+        ensure_node_key(command)
+      end
+
+      def call_once(*command, **kwargs, &_)
+        command = @command_builder.generate(command, kwargs)
+        ensure_node_key(command)
+      end
+
+      def call_once_v(command, &_)
+        command = @command_builder.generate(command)
+        ensure_node_key(command)
+      end
+
+      def execute(watch: nil, &block)
+        yield self
+        raise ArgumentError, 'empty transaction' if @node_key.nil?
+
+        node = @router.find_node(@node_key)
+        @router.try_delegate(node, :multi, watch: watch, &block)
+      end
+
+      private
+
+      def ensure_node_key(command)
+        node_key = @router.find_primary_node_key(command)
+        raise ConsistencyError, "Client couldn't determine the node to be executed the transaction by: #{command}" if node_key.nil?
+
+        @node_key ||= node_key
+        raise ConsistencyError, "The transaction should be done for single node: #{@node_key}, #{node_key}" if node_key != @node_key
+
+        nil
+      end
+    end
+  end
+end

data/lib/redis_client/cluster.rb

@@ -1,8 +1,10 @@
 # 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'
+require 'redis_client/cluster/transaction'
 
 class RedisClient
   class Cluster
@@ -10,14 +12,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,19 +82,24 @@ 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?
 
       pipeline.execute
     end
 
+    def multi(watch: nil, &block)
+      ::RedisClient::Cluster::Transaction.new(@router, @command_builder).execute(watch: watch, &block)
+    end
+
     def pubsub
       ::RedisClient::Cluster::PubSub.new(@router, @command_builder)
     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.3
+  version: 0.7.4
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-08 00:00:00.000000000 Z
+date: 2023-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -34,18 +34,24 @@ 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
 - lib/redis_client/cluster/pipeline.rb
 - lib/redis_client/cluster/pub_sub.rb
 - lib/redis_client/cluster/router.rb
+- lib/redis_client/cluster/transaction.rb
 - lib/redis_client/cluster_config.rb
 - lib/redis_cluster_client.rb
 homepage: https://github.com/redis-rb/redis-cluster-client
@@ -69,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4
 summary: A Redis cluster client for Ruby