redis-cluster-client 0.4.15 → 0.4.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be213593746d1aceb880d03bf002812ca650fa0f76aa6e906f52f2650a0fb758
-  data.tar.gz: e5e9d541f024c595a2dac84db7f5a60a9df3b318ebcc20dfc60cbfa91b30cc8a
+  metadata.gz: bc35dc957459313cb97b78fae42fadb612788e8e65eb49449db24b66294057fa
+  data.tar.gz: 03cf3604892eb1a881123bdfeabaeac30816ed940a827c5390b2320b3e9e26f0
 SHA512:
-  metadata.gz: 6d2bbd083b59645a96e3b97096f80cbe22c0788213b9f1b69a21d661fdf88d9f20abf1fdd785ef5e26ee083f5ce42d232da73863bc7015cdc17f836f01440c20
-  data.tar.gz: c792f23f43397ff380f277e1c7b7d9cc54090f9cd6eb302c7aff8bacaacd31da98ba9a810991a566b1081cf7d96b889e608e9ad77239157b7c92ed1461fe2ebe
+  metadata.gz: 7f8de53c53938381fb88c53ac2f13e8b7a78a3ee5653493fe0496acebaf0da57b568fb8c4436f8d19a7ba84d55018d9e4786c3726af2586581d0e7daee7b383f
+  data.tar.gz: 7b65b9e12fd251ca8a6c278c4fb245fc08b114c9cbfac58f88e5aca81d8b9ac9aa4939ef9dbf2ee042f313764b3205a9490453b7a2310915338e50c2871e4c47

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/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

@@ -94,28 +94,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 +123,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
@@ -331,33 +333,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, 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(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

@@ -24,7 +24,7 @@ class RedisClient
           @worker = subscribe(@client, timeout) if @worker.nil?
           return if @worker.alive?
 
-          message = @worker[:reply]
+          message = @worker.value
           @worker = nil
           message
         end
@@ -33,9 +33,9 @@ class RedisClient
 
         def subscribe(client, timeout)
           Thread.new(client, timeout) do |pubsub, to|
-            Thread.current[:reply] = pubsub.next_event(to)
+            pubsub.next_event(to)
           rescue StandardError => e
-            Thread.current[:reply] = e
+            e
           end
         end
       end
@@ -64,12 +64,12 @@ class RedisClient
       def next_event(timeout = nil)
         return if @state_list.empty?
 
+        @state_list.shuffle!
         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.shuffle!
           @state_list.each do |pubsub|
             message = pubsub.take_message(timeout)
             return message if message

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.4.15
+  version: 0.4.17
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-14 00:00:00.000000000 Z
+date: 2023-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -69,7 +69,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