redis-cluster-client 0.4.2 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bd4bae00bd7df3abda8f68a53f08746abae7c818f22466e8ec3e52c3e978b5b
-  data.tar.gz: c78d5b8600d131655d8fcf63744928a9f62718d78aaa3ddb5fd73908b1716314
+  metadata.gz: 16cd5b517f21a96b53fcaa47eb44e28b0c8d12aef23e3d2d239b2568d5ba61cd
+  data.tar.gz: ec4a1ebf3e548fdd7bfb184a910511f98919eecda1987674bef8d135bfc8b9da
 SHA512:
-  metadata.gz: c78d564a0398b6adfc0217568fd22ff7227215db616f8052142ebf45999a70930ce0f4b76363d6f0ac1030bffa9673bc25566815d6eac8bacf84247fd9e162f2
-  data.tar.gz: c992c9a5faf59fc2929351e99d6e112cd0fd464397fad0d4952a5997abebdf0b2fdfd8d691c4a96aea0856639423c99519d538bc422ce66943d34292a242224d
+  metadata.gz: 92a61bcbb6964cb41ed791768d346f65b48d1943627fbea13b86cf995e921990dcc41651553f7c5200e60cebc7c5cc7e519795e02a9173e37dd1ef4da1201006
+  data.tar.gz: a27605d3438d40da8be910776db98fd6ede734c9ac8824c3bcedfc599d0d1f3f6f00187a7e785f96d0da8d1f480b0c6f012fa4670e31edf1c152f189a59bcf73

data/lib/redis_client/cluster/command.rb

@@ -10,6 +10,7 @@ class RedisClient
       EMPTY_STRING = ''
       LEFT_BRACKET = '{'
       RIGHT_BRACKET = '}'
+      EMPTY_HASH = {}.freeze
 
       Detail = Struct.new(
         'RedisCommand',
@@ -21,15 +22,15 @@ class RedisClient
 
       class << self
         def load(nodes)
-          errors = []
-          cmd = nil
-          nodes&.each do |node|
-            break unless cmd.nil?
+          cmd = errors = nil
 
+          nodes&.each do |node|
             reply = node.call('COMMAND')
             commands = parse_command_reply(reply)
             cmd = ::RedisClient::Cluster::Command.new(commands)
+            break
           rescue ::RedisClient::Error => e
+            errors ||= []
             errors << e
           end
 
@@ -41,21 +42,20 @@ class RedisClient
         private
 
         def parse_command_reply(rows)
-          rows&.reject { |row| row[0].nil? }.to_h do |row|
-            [
-              row[0].downcase,
-              ::RedisClient::Cluster::Command::Detail.new(
-                first_key_position: row[3],
-                write?: row[2].include?('write'),
-                readonly?: row[2].include?('readonly')
-              )
-            ]
-          end
+          rows&.each_with_object({}) do |row, acc|
+            next if row[0].nil?
+
+            acc[row[0].downcase] = ::RedisClient::Cluster::Command::Detail.new(
+              first_key_position: row[3],
+              write?: row[2].include?('write'),
+              readonly?: row[2].include?('readonly')
+            )
+          end.freeze || EMPTY_HASH
         end
       end
 
       def initialize(commands)
-        @commands = commands || {}
+        @commands = commands || EMPTY_HASH
       end
 
       def extract_first_key(command)

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

@@ -10,7 +10,7 @@ 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)
@@ -45,7 +45,7 @@ class RedisClient
               Thread.new(k, v) do |node_key, client|
                 Thread.current[:node_key] = node_key
 
-                min = DUMMY_LATENCY_NSEC
+                min = DUMMY_LATENCY_MSEC
                 MEASURE_ATTEMPT_COUNT.times do
                   starting = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
                   client.call_once('PING')
@@ -55,7 +55,7 @@ class RedisClient
 
                 Thread.current[:latency] = min
               rescue StandardError
-                Thread.current[:latency] = DUMMY_LATENCY_NSEC
+                Thread.current[:latency] = DUMMY_LATENCY_MSEC
               end
             end
 

data/lib/redis_client/cluster/node.rb

@@ -18,6 +18,9 @@ class RedisClient
       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
+      EMPTY_ARRAY = [].freeze
 
       ReloadNeeded = Class.new(::RedisClient::Error)
 
@@ -118,13 +121,13 @@ class RedisClient
           raise ::RedisClient::Cluster::InitialSetupError, errors if node_info_list.nil?
 
           grouped = node_info_list.compact.group_by do |info_list|
-            info_list
-              .sort_by(&:id)
-              .map { |i| "#{i.id}#{i.node_key}#{i.role}#{i.primary_id}#{i.config_epoch}" }
-              .join
+            info_list.sort_by!(&:id)
+            info_list.each_with_object(String.new(capacity: 128 * info_list.size)) do |e, a|
+              a << e.id << e.node_key << e.role << e.primary_id << e.config_epoch
+            end
           end
 
-          grouped.max_by { |_, v| v.size }[1].first
+          grouped.max_by { |_, v| v.size }[1].first.freeze
         end
 
         private
@@ -132,27 +135,47 @@ class RedisClient
         # @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
-          rows = reply.split("\n").map(&:split)
-          rows.each { |arr| arr[2] = arr[2].split(',') }
-          rows.select! { |arr| arr[7] == 'connected' && (arr[2] & %w[fail? fail handshake noaddr noflags]).empty? }
-          rows.each do |arr|
-            arr[1] = arr[1].split('@').first
-            arr[2] = (arr[2] & %w[master slave]).first
-            if arr[8].nil?
-              arr[8] = []
-              next
-            end
-            arr[8] = arr[8..].filter_map { |str| str.start_with?('[') ? nil : str.split('-').map { |s| Integer(s) } }
-                             .map { |a| a.size == 1 ? a << a.first : a }.map(&:sort)
-          end
+          reply.each_line("\n", chomp: true).filter_map do |line|
+            fields = line.split
+            flags = fields[2].split(',')
+            next unless fields[7] == 'connected' && (flags & DEAD_FLAGS).empty?
+
+            slots = if fields[8].nil?
+                      EMPTY_ARRAY
+                    else
+                      fields[8..].reject { |str| str.start_with?('[') }
+                                 .map { |str| str.split('-').map { |s| Integer(s) } }
+                                 .map { |a| a.size == 1 ? a << a.first : a }
+                                 .map(&:sort)
+                    end
 
-          rows.map do |arr|
             ::RedisClient::Cluster::Node::Info.new(
-              id: arr[0], node_key: arr[1], role: arr[2], primary_id: arr[3], ping_sent: arr[4],
-              pong_recv: arr[5], config_epoch: arr[6], link_state: arr[7], slots: arr[8]
+              id: fields[0],
+              node_key: parse_node_key(fields[1]),
+              role: (flags & ROLE_FLAGS).first,
+              primary_id: fields[3],
+              ping_sent: fields[4],
+              pong_recv: fields[5],
+              config_epoch: fields[6],
+              link_state: fields[7],
+              slots: slots
             )
           end
         end
+
+        # As redirection node_key is dependent on `cluster-preferred-endpoint-type` config,
+        # node_key should use hostname if present in CLUSTER NODES output.
+        #
+        # See https://redis.io/commands/cluster-nodes/ for details on the output format.
+        # node_address matches fhe format: <ip:port@cport[,hostname[,auxiliary_field=value]*]>
+        def parse_node_key(node_address)
+          ip_chunk, hostname, _auxiliaries = node_address.split(',')
+          ip_port_string = ip_chunk.split('@').first
+          return ip_port_string if hostname.nil? || hostname.empty?
+
+          port = ip_port_string.split(':')[1]
+          "#{hostname}:#{port}"
+        end
       end
 
       def initialize(

data/lib/redis_client/cluster/pub_sub.rb

@@ -3,33 +3,61 @@
 class RedisClient
   class Cluster
     class PubSub
+      MAX_THREADS = Integer(ENV.fetch('REDIS_CLIENT_MAX_THREADS', 5))
+
       def initialize(router, command_builder)
         @router = router
         @command_builder = command_builder
-        @pubsub = nil
+        @pubsub_states = {}
       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))
       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))
       end
 
       def close
-        @pubsub&.close
-        @pubsub = nil
+        @pubsub_states.each_value(&:close)
+        @pubsub_states.clear
       end
 
       def next_event(timeout = nil)
-        @pubsub&.next_event(timeout)
+        msgs = collect_messages(timeout).compact
+        return msgs.first if msgs.size == 1
+
+        msgs
+      end
+
+      private
+
+      def _call(command)
+        node_key = @router.find_node_key(command)
+        pubsub = if @pubsub_states.key?(node_key)
+                   @pubsub_states[node_key]
+                 else
+                   @pubsub_states[node_key] = @router.find_node(node_key).pubsub
+                 end
+        pubsub.call_v(command)
+      end
+
+      def collect_messages(timeout)
+        @pubsub_states.each_slice(MAX_THREADS).each_with_object([]) do |chuncked_pubsub_states, acc|
+          threads = chuncked_pubsub_states.map do |_, v|
+            Thread.new(v) do |pubsub|
+              Thread.current[:reply] = pubsub.next_event(timeout)
+            rescue StandardError => e
+              Thread.current[:reply] = e
+            end
+          end
+
+          threads.each do |t|
+            t.join
+            acc << t[:reply]
+          end
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.4
 platform: ruby
 authors:
 - Taishi Kasuga
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-03 00:00:00.000000000 Z
+date: 2023-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -24,7 +24,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.12'
-description:
+description: 
 email:
 - proxy0721@gmail.com
 executables: []
@@ -54,7 +54,7 @@ licenses:
 metadata:
   rubygems_mfa_required: 'true'
   allowed_push_host: https://rubygems.org
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -69,8 +69,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.23
-signing_key:
+rubygems_version: 3.4.13
+signing_key: 
 specification_version: 4
 summary: A Redis cluster client for Ruby
 test_files: []