redis-cluster-client 0.3.4 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 458c3d9cc4d1f6595510663cede0403953b2555ace0d3cae814663b23f69f1cb
-  data.tar.gz: 01d2a34641e298ff7e99cc5f9edbad4ed152e5ca4f18e16181b9a4b84a2492c2
+  metadata.gz: 24e153973525e8cd3905e92e851194a5c1f4349cecd71ca4a71db34fa678d1d8
+  data.tar.gz: 963ac53058e861d50c55160f55f9b064e853c49b29811075ece80ce34fa7b0f8
 SHA512:
-  metadata.gz: 3680e6b8b1594001060eb2dea29eb60f0779bba6a43350246b1d5c7e47b1bb1e04a6e1188ac87c1228adac21e86347cb3820679d6c92b693d7f7fedabba88402
-  data.tar.gz: 21927b8a14e9ad075e3808e736789c4339af907f5d99e16806273f1553c505e7fc86faabfa067b98f2a3dd7d45a41fb0f89e780e08825aa9df4317531871da5d
+  metadata.gz: 841bdd5aa580dcd7c3169fe88f36b8ed888ffffd3cf50b9f75449365c430afb41d79d88f2265183119f0ed012ace418868679cad468bcf39b25aed30b6207da1
+  data.tar.gz: 5f36751289ba73d5471cfe44d9e3d10cb70fd517249ce48ad7ea4254de0595c869fb900fecd3b0abd690fe977a732650ebf8da80a5d95ed1464a3345b79243fa

data/lib/redis_client/cluster/command.rb

@@ -10,7 +10,7 @@ class RedisClient
       EMPTY_STRING = ''
 
       class << self
-        def load(nodes) # rubocop:disable Metrics/MethodLength
+        def load(nodes)
           errors = []
           cmd = nil
           nodes&.each do |node|
@@ -32,10 +32,7 @@ class RedisClient
 
         def parse_command_details(rows)
           rows&.reject { |row| row[0].nil? }.to_h do |row|
-            [
-              ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_name(row[0]),
-              { arity: row[1], flags: row[2], first: row[3], last: row[4], step: row[5] }
-            ]
+            [row[0].downcase, { arity: row[1], flags: row[2], first: row[3], last: row[4], step: row[5] }]
           end
         end
       end
@@ -85,7 +82,7 @@ class RedisClient
         @details.fetch(name).fetch(key)
       end
 
-      def determine_first_key_position(command) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def determine_first_key_position(command) # rubocop:disable Metrics/CyclomaticComplexity
         case ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
         when 'eval', 'evalsha', 'zinterstore', 'zunionstore' then 3
         when 'object' then 2

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

@@ -34,18 +34,17 @@ class RedisClient
 
         def any_replica_node_key(seed: nil)
           random = seed.nil? ? Random : Random.new(seed)
-          @existed_replicas.sample(random: random).first
+          @existed_replicas.sample(random: random)&.first
         end
 
         private
 
-        def measure_latencies(clients) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-          latencies = {}
-
-          clients.each_slice(::RedisClient::Cluster::Node::MAX_THREADS) do |chuncked_clients|
+        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.pass
+                Thread.current.thread_variable_set(:node_key, node_key)
 
                 min = DUMMY_LATENCY_NSEC
                 MEASURE_ATTEMPT_COUNT.times do
@@ -55,16 +54,17 @@ class RedisClient
                   min = duration if duration < min
                 end
 
-                latencies[node_key] = min
+                Thread.current.thread_variable_set(:latency, min)
               rescue StandardError
-                latencies[node_key] = DUMMY_LATENCY_NSEC
+                Thread.current.thread_variable_set(:latency, DUMMY_LATENCY_NSEC)
               end
             end
 
-            threads.each(&:join)
+            threads.each do |t|
+              t.join
+              acc[t.thread_variable_get(:node_key)] = t.thread_variable_get(:latency)
+            end
           end
-
-          latencies
         end
 
         def select_replica_clients(replications, clients)

data/lib/redis_client/cluster/node.rb

@@ -37,29 +37,38 @@ class RedisClient
       end
 
       class << self
-        def load_info(options, **kwargs) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        def load_info(options, **kwargs) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           startup_size = options.size > MAX_STARTUP_SAMPLE ? MAX_STARTUP_SAMPLE : options.size
-          node_info_list = Array.new(startup_size)
-          errors = Array.new(startup_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.pass
+                Thread.current.thread_variable_set(:index, i)
                 reply = cli.call('CLUSTER', 'NODES')
-                node_info_list[i] = parse_node_info(reply)
+                Thread.current.thread_variable_set(:info, parse_node_info(reply))
               rescue StandardError => e
-                errors[i] = e
+                Thread.current.thread_variable_set(:error, e)
               ensure
                 cli&.close
               end
             end
 
-            threads.each(&:join)
+            threads.each do |t|
+              t.join
+              if t.thread_variable?(:info)
+                node_info_list ||= Array.new(startup_size)
+                node_info_list[t.thread_variable_get(:index)] = t.thread_variable_get(:info)
+              elsif t.thread_variable?(:error)
+                errors ||= Array.new(startup_size)
+                errors[t.thread_variable_get(:index)] = t.thread_variable_get(:error)
+              end
+            end
           end
 
-          raise ::RedisClient::Cluster::InitialSetupError, errors if node_info_list.all?(&:nil?)
+          raise ::RedisClient::Cluster::InitialSetupError, errors if node_info_list.nil?
 
           grouped = node_info_list.compact.group_by do |rows|
             rows.sort_by { |row| row[:id] }
@@ -74,7 +83,7 @@ class RedisClient
 
         # @see https://redis.io/commands/cluster-nodes/
         # @see https://github.com/redis/redis/blob/78960ad57b8a5e6af743d789ed8fd767e37d42b8/src/cluster.c#L4660-L4683
-        def parse_node_info(info) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+        def parse_node_info(info) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           rows = info.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? }
@@ -147,7 +156,7 @@ class RedisClient
 
       def send_ping(method, command, args, &block)
         result_values, errors = call_multiple_nodes(@topology.clients, method, command, args, &block)
-        return result_values if errors.empty?
+        return result_values if errors.nil? || errors.empty?
 
         raise ReloadNeeded if errors.values.any?(::RedisClient::ConnectionError)
 
@@ -228,26 +237,35 @@ class RedisClient
 
       def call_multiple_nodes!(clients, method, command, args, &block)
         result_values, errors = call_multiple_nodes(clients, method, command, args, &block)
-        return result_values if errors.empty?
+        return result_values if errors.nil? || errors.empty?
 
         raise ::RedisClient::Cluster::ErrorCollection, errors
       end
 
-      def try_map(clients) # rubocop:disable Metrics/MethodLength
-        results = {}
-        errors = {}
+      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.pass
+              Thread.current.thread_variable_set(:node_key, node_key)
               reply = yield(node_key, client)
-              results[node_key] = reply unless reply.nil?
+              Thread.current.thread_variable_set(:result, reply)
             rescue StandardError => e
-              errors[node_key] = e
+              Thread.current.thread_variable_set(:error, e)
             end
           end
 
-          threads.each(&:join)
+          threads.each do |t|
+            t.join
+            if t.thread_variable?(:result)
+              results ||= {}
+              results[t.thread_variable_get(:node_key)] = t.thread_variable_get(:result)
+            elsif t.thread_variable?(:error)
+              errors ||= {}
+              errors[t.thread_variable_get(:node_key)] = t.thread_variable_get(:error)
+            end
+          end
         end
 
         [results, errors]

data/lib/redis_client/cluster/normalized_cmd_name.rb

@@ -28,6 +28,7 @@ class RedisClient
 
       def clear
         @mutex.synchronize { @cache.clear }
+        true
       end
 
       private

data/lib/redis_client/cluster/pipeline.rb

@@ -2,100 +2,252 @@
 
 require 'redis_client'
 require 'redis_client/cluster/errors'
+require 'redis_client/connection_mixin'
+require 'redis_client/middlewares'
+require 'redis_client/pooled'
 
 class RedisClient
   class Cluster
     class Pipeline
+      class Extended < ::RedisClient::Pipeline
+        attr_reader :outer_indices
+
+        def initialize(command_builder)
+          super
+          @outer_indices = nil
+        end
+
+        def add_outer_index(index)
+          @outer_indices ||= []
+          @outer_indices << index
+        end
+
+        def get_inner_index(outer_index)
+          @outer_indices&.find_index(outer_index)
+        end
+
+        def get_callee_method(inner_index)
+          if @timeouts.is_a?(Array) && !@timeouts[inner_index].nil?
+            :blocking_call_v
+          elsif _retryable?
+            :call_once_v
+          else
+            :call_v
+          end
+        end
+
+        def get_command(inner_index)
+          @commands.is_a?(Array) ? @commands[inner_index] : nil
+        end
+
+        def get_timeout(inner_index)
+          @timeouts.is_a?(Array) ? @timeouts[inner_index] : nil
+        end
+
+        def get_block(inner_index)
+          @blocks.is_a?(Array) ? @blocks[inner_index] : nil
+        end
+      end
+
+      ::RedisClient::ConnectionMixin.module_eval do
+        def call_pipelined_aware_of_redirection(commands, timeouts) # rubocop:disable Metrics/AbcSize
+          size = commands.size
+          results = Array.new(commands.size)
+          @pending_reads += size
+          write_multi(commands)
+
+          redirection_indices = nil
+          size.times do |index|
+            timeout = timeouts && timeouts[index]
+            result = read(timeout)
+            @pending_reads -= 1
+            if result.is_a?(CommandError)
+              result._set_command(commands[index])
+              if result.message.start_with?('MOVED', 'ASK')
+                redirection_indices ||= []
+                redirection_indices << index
+              end
+            end
+
+            results[index] = result
+          end
+
+          return results if redirection_indices.nil?
+
+          err = ::RedisClient::Cluster::Pipeline::RedirectionNeeded.new
+          err.replies = results
+          err.indices = redirection_indices
+          raise err
+        end
+      end
+
       ReplySizeError = Class.new(::RedisClient::Error)
+
+      class RedirectionNeeded < ::RedisClient::Error
+        attr_accessor :replies, :indices
+      end
+
       MAX_THREADS = Integer(ENV.fetch('REDIS_CLIENT_MAX_THREADS', 5))
 
       def initialize(router, command_builder, seed: Random.new_seed)
         @router = router
         @command_builder = command_builder
-        @grouped = {}
-        @size = 0
         @seed = seed
+        @pipelines = nil
+        @size = 0
       end
 
       def call(*args, **kwargs, &block)
         command = @command_builder.generate(args, kwargs)
         node_key = @router.find_node_key(command, seed: @seed)
-        add_line(node_key, [@size, :call_v, command, block])
+        append_pipeline(node_key).call_v(command, &block)
       end
 
       def call_v(args, &block)
         command = @command_builder.generate(args)
         node_key = @router.find_node_key(command, seed: @seed)
-        add_line(node_key, [@size, :call_v, command, block])
+        append_pipeline(node_key).call_v(command, &block)
       end
 
       def call_once(*args, **kwargs, &block)
         command = @command_builder.generate(args, kwargs)
         node_key = @router.find_node_key(command, seed: @seed)
-        add_line(node_key, [@size, :call_once_v, command, block])
+        append_pipeline(node_key).call_once_v(command, &block)
       end
 
       def call_once_v(args, &block)
         command = @command_builder.generate(args)
         node_key = @router.find_node_key(command, seed: @seed)
-        add_line(node_key, [@size, :call_once_v, command, block])
+        append_pipeline(node_key).call_once_v(command, &block)
       end
 
       def blocking_call(timeout, *args, **kwargs, &block)
         command = @command_builder.generate(args, kwargs)
         node_key = @router.find_node_key(command, seed: @seed)
-        add_line(node_key, [@size, :blocking_call_v, timeout, command, block])
+        append_pipeline(node_key).blocking_call_v(timeout, command, &block)
       end
 
       def blocking_call_v(timeout, args, &block)
         command = @command_builder.generate(args)
         node_key = @router.find_node_key(command, seed: @seed)
-        add_line(node_key, [@size, :blocking_call_v, timeout, command, block])
+        append_pipeline(node_key).blocking_call_v(timeout, command, &block)
       end
 
       def empty?
         @size.zero?
       end
 
-      # TODO: https://github.com/redis-rb/redis-cluster-client/issues/37 handle redirections
-      def execute # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-        all_replies = Array.new(@size)
-        errors = {}
-        @grouped.each_slice(MAX_THREADS) do |chuncked_grouped|
-          threads = chuncked_grouped.map do |k, v|
-            Thread.new(@router, k, v) do |router, node_key, rows|
+      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.pass
-              replies = router.find_node(node_key).pipelined do |pipeline|
-                rows.each do |row|
-                  case row.size
-                  when 4 then pipeline.send(row[1], row[2], &row[3])
-                  when 5 then pipeline.send(row[1], row[2], row[3], &row[4])
-                  end
-                end
-              end
-
-              raise ReplySizeError, "commands: #{rows.size}, replies: #{replies.size}" if rows.size != replies.size
+              Thread.current.thread_variable_set(:node_key, nk)
+              replies = do_pipelining(@router.find_node(nk), pl)
+              raise ReplySizeError, "commands: #{pl._size}, replies: #{replies.size}" if pl._size != replies.size
 
-              rows.each_with_index { |row, idx| all_replies[row.first] = replies[idx] }
+              Thread.current.thread_variable_set(:replies, replies)
+            rescue ::RedisClient::Cluster::Pipeline::RedirectionNeeded => e
+              Thread.current.thread_variable_set(:redirection_needed, e)
             rescue StandardError => e
-              errors[node_key] = e
+              Thread.current.thread_variable_set(:error, e)
             end
           end
 
-          threads.each(&:join)
+          threads.each do |t|
+            t.join
+
+            if t.thread_variable?(:replies)
+              all_replies ||= Array.new(@size)
+              @pipelines[t.thread_variable_get(:node_key)]
+                .outer_indices
+                .each_with_index { |outer, inner| all_replies[outer] = t.thread_variable_get(:replies)[inner] }
+            elsif t.thread_variable?(:redirection_needed)
+              all_replies ||= Array.new(@size)
+              pipeline = @pipelines[t.thread_variable_get(:node_key)]
+              err = t.thread_variable_get(: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.thread_variable?(:error)
+              errors ||= {}
+              errors[t.thread_variable_get(:node_key)] = t.thread_variable_get(:error)
+            end
+          end
         end
 
-        return all_replies if errors.empty?
+        raise ::RedisClient::Cluster::ErrorCollection, errors unless errors.nil?
 
-        raise ::RedisClient::Cluster::ErrorCollection, errors
+        all_replies
       end
 
       private
 
-      def add_line(node_key, line)
-        @grouped[node_key] = [] unless @grouped.key?(node_key)
-        @grouped[node_key] << line
+      def append_pipeline(node_key)
+        @pipelines ||= {}
+        @pipelines[node_key] ||= ::RedisClient::Cluster::Pipeline::Extended.new(@command_builder)
+        @pipelines[node_key].add_outer_index(@size)
         @size += 1
+        @pipelines[node_key]
+      end
+
+      def do_pipelining(client, pipeline)
+        case client
+        when ::RedisClient then send_pipeline(client, pipeline)
+        when ::RedisClient::Pooled then client.with { |cli| send_pipeline(cli, pipeline) }
+        else raise NotImplementedError, "#{client.class.name}#pipelined for cluster client"
+        end
+      end
+
+      def send_pipeline(client, pipeline)
+        results = client.send(:ensure_connected, retryable: pipeline._retryable?) do |connection|
+          commands = pipeline._commands
+          ::RedisClient::Middlewares.call_pipelined(commands, client.config) do
+            connection.call_pipelined_aware_of_redirection(commands, pipeline._timeouts)
+          end
+        end
+
+        pipeline._coerce!(results)
+      end
+
+      def handle_redirection(err, pipeline, inner_index)
+        return err unless err.is_a?(::RedisClient::CommandError)
+
+        if err.message.start_with?('MOVED')
+          node = @router.assign_redirection_node(err.message)
+          try_redirection(node, pipeline, inner_index)
+        elsif err.message.start_with?('ASK')
+          node = @router.assign_asking_node(err.message)
+          try_asking(node) ? try_redirection(node, pipeline, inner_index) : err
+        else
+          err
+        end
+      end
+
+      def try_redirection(node, pipeline, inner_index)
+        redirect_command(node, pipeline, inner_index)
+      rescue StandardError => e
+        e
+      end
+
+      def redirect_command(node, pipeline, inner_index)
+        method = pipeline.get_callee_method(inner_index)
+        command = pipeline.get_command(inner_index)
+        timeout = pipeline.get_timeout(inner_index)
+        block = pipeline.get_block(inner_index)
+        args = timeout.nil? ? [] : [timeout]
+
+        if block.nil?
+          @router.try_send(node, method, command, args)
+        else
+          @router.try_send(node, method, command, args, &block)
+        end
+      end
+
+      def try_asking(node)
+        node.call('ASKING') == 'OK'
+      rescue StandardError
+        false
       end
     end
   end

data/lib/redis_client/cluster/router.rb

@@ -25,7 +25,7 @@ class RedisClient
         @command_builder = @config.command_builder
       end
 
-      def send_command(method, command, *args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def send_command(method, command, *args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         cmd = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
         case cmd
         when 'acl', 'auth', 'bgrewriteaof', 'bgsave', 'quit', 'save'
@@ -65,7 +65,7 @@ class RedisClient
 
       # @see https://redis.io/topics/cluster-spec#redirection-and-resharding
       #   Redirection and resharding
-      def try_send(node, method, command, args, retry_count: 3, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def try_send(node, method, command, args, retry_count: 3, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         if args.empty?
           # prevent memory allocation for variable-length args
           node.send(method, command, &block)
@@ -100,7 +100,7 @@ class RedisClient
         retry
       end
 
-      def try_delegate(node, method, *args, retry_count: 3, **kwargs, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def try_delegate(node, method, *args, retry_count: 3, **kwargs, &block) # rubocop:disable Metrics/AbcSize
         node.send(method, *args, **kwargs, &block)
       rescue ::RedisClient::CommandError => e
         raise if retry_count <= 0
@@ -129,7 +129,7 @@ class RedisClient
         retry
       end
 
-      def scan(*command, seed: nil, **kwargs) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def scan(*command, seed: nil, **kwargs) # rubocop:disable Metrics/AbcSize
         command = @command_builder.generate(command, kwargs)
 
         command[1] = ZERO_CURSOR_FOR_SCAN if command.size == 1
@@ -172,7 +172,7 @@ class RedisClient
       def find_node(node_key, retry_count: 3)
         @node.find_by(node_key)
       rescue ::RedisClient::Cluster::Node::ReloadNeeded
-        raise ::RedieClient::Cluster::NodeMightBeDown if retry_count <= 0
+        raise ::RedisClient::Cluster::NodeMightBeDown if retry_count <= 0
 
         update_cluster_info!
         retry_count -= 1
@@ -183,6 +183,18 @@ class RedisClient
         @command.exists?(name)
       end
 
+      def assign_redirection_node(err_msg)
+        _, slot, node_key = err_msg.split
+        slot = slot.to_i
+        @node.update_slot(slot, node_key)
+        find_node(node_key)
+      end
+
+      def assign_asking_node(err_msg)
+        _, _, node_key = err_msg.split
+        find_node(node_key)
+      end
+
       private
 
       def send_wait_command(method, command, args, retry_count: 3, &block)
@@ -258,19 +270,7 @@ class RedisClient
         end
       end
 
-      def assign_redirection_node(err_msg)
-        _, slot, node_key = err_msg.split
-        slot = slot.to_i
-        @node.update_slot(slot, node_key)
-        find_node(node_key)
-      end
-
-      def assign_asking_node(err_msg)
-        _, _, node_key = err_msg.split
-        find_node(node_key)
-      end
-
-      def fetch_cluster_info(config, pool: nil, **kwargs) # rubocop:disable Metrics/MethodLength
+      def fetch_cluster_info(config, pool: nil, **kwargs)
         node_info = ::RedisClient::Cluster::Node.load_info(config.per_node_key, **kwargs)
         node_addrs = node_info.map { |info| ::RedisClient::Cluster::NodeKey.hashify(info[:node_key]) }
         config.update_node(node_addrs)

data/lib/redis_client/cluster.rb

@@ -81,7 +81,7 @@ class RedisClient
       seed = @config.use_replica? && @config.replica_affinity == :random ? nil : Random.new_seed
       pipeline = ::RedisClient::Cluster::Pipeline.new(@router, @command_builder, seed: seed)
       yield pipeline
-      return [] if pipeline.empty? == 0
+      return [] if pipeline.empty?
 
       pipeline.execute
     end

data/lib/redis_client/cluster_config.rb

@@ -114,7 +114,7 @@ class RedisClient
       end
     end
 
-    def parse_node_url(addr) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+    def parse_node_url(addr) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       return if addr.empty?
 
       uri = URI(addr)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.6
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-19 00:00:00.000000000 Z
+date: 2022-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client