redis-cluster-client 0.4.16 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0718a12555e9116b8fe96bc0dba71151288f824ce878c0d17d6d70b653f4a61
-  data.tar.gz: 99decc7aaef7dedf30a16ab35bd652be4114d31e6f52ba03637c99c28c9c7e86
+  metadata.gz: ac7d6ca1474a42ad2d4027de72dbd087f6d248b3678ad2e360ed55b56dc60790
+  data.tar.gz: ce4de83f3f601772df8c95381a65172245967bd9568ff7959aec5858e55fb7af
 SHA512:
-  metadata.gz: 23b095c4d5ca638ab8de8fbaf51b97e845ac2e0f778bb70139cbe79dc62bd93fdf75f1d5701f5e6b85d639099df9a9ad5707560094cd977b591df5d997a80964
-  data.tar.gz: 2cb340116191ed21f4b048ee3bad5a473755e498278d4bff76a991e0b18d9b3b359ba207c3c1ec039d211a1b2cdc672d001aaf83a5079b2a2e6350c52cc6a6ae
+  metadata.gz: 3cb2167fb97c6ab7ccba66e888521a1a119e2f17a0c373829bce0abb41518ead4005c0a7c176373c45942e9cd9fca71355b9898e7cc2b67db22d6291a76b324e
+  data.tar.gz: 1da6192fcb6f33359b508ff4e3445ec029373ff9606f78170051a682a29371524d6f08864f4a0887b3cbc298e462d13fe8cc9080eb29bd9cf8d965c7a766409e

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

@@ -39,30 +39,27 @@ class RedisClient
 
         private
 
-        def measure_latencies(clients) # rubocop:disable Metrics/AbcSize
+        def measure_latencies(clients)
           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_MSEC
-                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_MSEC
-              end
-            end
+            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
 
-            threads.each do |t|
-              t.join
-              acc[t[:node_key]] = t[:latency]
+        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
+
+            min
+          rescue StandardError
+            DUMMY_LATENCY_MSEC
           end
         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

@@ -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
@@ -94,28 +95,19 @@ class RedisClient
           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
+            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
-            end
-
-            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
-            end
           end
 
           raise ::RedisClient::Cluster::InitialSetupError, errors if node_info_list.nil?
@@ -132,6 +124,17 @@ 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
@@ -282,6 +285,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
@@ -331,33 +336,33 @@ class RedisClient
         raise ::RedisClient::Cluster::ErrorCollection, errors
       end
 
-      def try_map(clients) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def try_map(clients, &block)
         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
-          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]
+          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
-          end
         end
 
         [results, errors]
       end
+
+      def build_thread_for_command(node_key, client)
+        Thread.new(node_key, client) do |nk, cli|
+          yield(nk, cli)
+        rescue StandardError => e
+          e
+        end
+      end
     end
   end
 end

data/lib/redis_client/cluster/pipeline.rb

@@ -148,38 +148,23 @@ class RedisClient
       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
-          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]
+          chuncked_pipelines
+            .map { |node_key, pipeline| [node_key, build_thread_for_pipeline(@router.find_node(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
-          end
         end
 
         raise ::RedisClient::Cluster::ErrorCollection, errors unless errors.nil?
@@ -197,6 +182,17 @@ class RedisClient
         @pipelines[node_key]
       end
 
+      def build_thread_for_pipeline(client, pipeline)
+        Thread.new(client, pipeline) do |cli, pl|
+          replies = do_pipelining(cli, 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,44 @@ 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[:reply]
-          @worker = nil
-          message
-        end
-
         private
 
-        def subscribe(client, timeout)
-          Thread.new(client, timeout) do |pubsub, to|
-            Thread.current[:reply] = pubsub.next_event(to)
-          rescue StandardError => e
-            Thread.current[:reply] = e
+        def spawn_worker(client, queue)
+          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 +56,25 @@ class RedisClient
       end
 
       def close
-        @state_list.each(&:close)
-        @state_list.clear
+        @state_dict.each_value(&:close)
         @state_dict.clear
+        @queue.clear
       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 +99,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
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.4.16
+  version: 0.5.0
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-21 00:00:00.000000000 Z
+date: 2023-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -40,6 +40,7 @@ files:
 - 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
@@ -69,7 +70,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.13
+rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4
 summary: A Redis cluster client for Ruby