redis-cluster-client 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4339be83a679ef61e9d9a98e26cd2dd52b58b56eaa852a53c8f0f01ef1987396
-  data.tar.gz: ac7ea102f9d5a711ee495a36c844443027b39d2c64e0d9177d419d00e1fa0de0
+  metadata.gz: 374dde2480377552fd2178d4940d0f9f9b4473c4308c89fa210e2b0ac8f36d6d
+  data.tar.gz: 5b22559b68cd287904a17f853a4cfd6a0fc0bf53418eeca3988987a585a55b71
 SHA512:
-  metadata.gz: 268000fa3691afc08d969b35cf8ac90221e96ffb41db59c63d9737e9ebed3d978f84f36ba4ee91ceb4bb88c957c3d2ecead676bc7b6c7a4411598969213e269c
-  data.tar.gz: 1a44f77bdd4202f327025d3fa0d0a3b65b577332cd714f787159c8ba41f20f5b3c8b058b5c48aab74f5d0a7b3ec4638f227b5f205ed07c8e32dba4c71220695b
+  metadata.gz: da95dc7179899376c736d6e5b75a04b9f8d91d0b97095b2478c9b96879f0f4ff01d75ffe86bf3efdebb2af0e13b6397a3afd41a1e6857fc41097f53ac8cdacf2
+  data.tar.gz: 6759c62ea25c92e8160540b5edb354a03253d7d43199ccbf0479d1b19070b90cb17877b376012186ff063316f28f16157d8fbd1e0bb3b67c3168ed92d6afa31a

data/lib/redis_client/cluster/command.rb

@@ -8,8 +8,9 @@ class RedisClient
     class Command
       class << self
         def load(nodes)
-          errors = nodes.map do |node|
-            details = fetch_command_details(node)
+          errors = nodes&.map do |node|
+            reply = node.call('COMMAND')
+            details = parse_command_details(reply)
             return ::RedisClient::Cluster::Command.new(details)
           rescue ::RedisClient::ConnectionError, ::RedisClient::CommandError => e
             e
@@ -20,9 +21,9 @@ class RedisClient
 
         private
 
-        def fetch_command_details(node)
-          node.call('COMMAND').to_h do |reply|
-            [reply[0], { arity: reply[1], flags: reply[2], first: reply[3], last: reply[4], step: reply[5] }]
+        def parse_command_details(rows)
+          rows&.reject { |row| row[0].nil? }.to_h do |row|
+            [row[0].downcase, { arity: row[1], flags: row[2], first: row[3], last: row[4], step: row[5] }]
           end
         end
       end
@@ -35,7 +36,7 @@ class RedisClient
         i = determine_first_key_position(command)
         return '' if i == 0
 
-        key = command[i].to_s
+        key = (command[i].is_a?(Array) ? command[i].flatten.first : command[i]).to_s
         hash_tag = extract_hash_tag(key)
         hash_tag.empty? ? key : hash_tag
       end
@@ -51,7 +52,7 @@ class RedisClient
       private
 
       def pick_details(details)
-        details.transform_values do |detail|
+        (details || {}).transform_values do |detail|
           {
             first_key_position: detail[:first],
             write: detail[:flags].include?('write'),
@@ -61,14 +62,14 @@ class RedisClient
       end
 
       def dig_details(command, key)
-        name = command.first.to_s
-        return unless @details.key?(name)
+        name = command&.flatten&.first.to_s.downcase
+        return if name.empty? || !@details.key?(name)
 
         @details.fetch(name).fetch(key)
       end
 
-      def determine_first_key_position(command)
-        case command.first.to_s.downcase
+      def determine_first_key_position(command) # rubocop:disable Metrics/CyclomaticComplexity
+        case command&.flatten&.first.to_s.downcase
         when 'eval', 'evalsha', 'migrate', 'zinterstore', 'zunionstore' then 3
         when 'object' then 2
         when 'memory'
@@ -80,13 +81,14 @@ class RedisClient
         end
       end
 
-      def determine_optional_key_position(command, option_name)
-        idx = command.map(&:to_s).map(&:downcase).index(option_name)
+      def determine_optional_key_position(command, option_name) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        idx = command&.flatten&.map(&:to_s)&.map(&:downcase)&.index(option_name&.downcase)
         idx.nil? ? 0 : idx + 1
       end
 
       # @see https://redis.io/topics/cluster-spec#keys-hash-tags Keys hash tags
       def extract_hash_tag(key)
+        key = key.to_s
         s = key.index('{')
         e = key.index('}', s.to_i + 1)
 

data/lib/redis_client/cluster/errors.rb

@@ -4,22 +4,24 @@ require 'redis_client'
 
 class RedisClient
   class Cluster
+    ERR_ARG_NORMALIZATION = ->(arg) { Array[arg].flatten.reject { |e| e.nil? || (e.respond_to?(:empty?) && e.empty?) } }
+
     # Raised when client connected to redis as cluster mode
     # and failed to fetch cluster state information by commands.
     class InitialSetupError < ::RedisClient::Error
-      # @param errors [Array<Redis::BaseError>]
       def initialize(errors)
-        super("Redis client could not fetch cluster information: #{errors.map(&:message).uniq.join(',')}")
+        msg = ERR_ARG_NORMALIZATION.call(errors).map(&:message).uniq.join(',')
+        super("Redis client could not fetch cluster information: #{msg}")
       end
     end
 
     # Raised when client connected to redis as cluster mode
     # and some cluster subcommands were called.
     class OrchestrationCommandNotSupported < ::RedisClient::Error
-      def initialize(command, subcommand = '')
-        str = [command, subcommand].map(&:to_s).reject(&:empty?).join(' ').upcase
+      def initialize(command)
+        str = ERR_ARG_NORMALIZATION.call(command).map(&:to_s).join(' ').upcase
         msg = "#{str} command should be used with care "\
-              'only by applications orchestrating Redis Cluster, like redis-trib, '\
+              'only by applications orchestrating Redis Cluster, like redis-cli, '\
               'and the command if used out of the right context can leave the cluster '\
               'in a wrong state or cause data loss.'
         super(msg)
@@ -30,11 +32,16 @@ class RedisClient
     class CommandErrorCollection < ::RedisClient::Error
       attr_reader :errors
 
-      # @param errors [Hash{String => Redis::CommandError}]
-      # @param error_message [String]
-      def initialize(errors, error_message = 'Command errors were replied on any node')
+      def initialize(errors)
+        @errors = {}
+        if !errors.is_a?(Hash) || errors.empty?
+          super('')
+          return
+        end
+
         @errors = errors
-        super(error_message)
+        messages = @errors.map { |node_key, error| "#{node_key}: #{error.message}" }
+        super("Command errors were replied on any node: #{messages.join(', ')}")
       end
     end
 
@@ -44,13 +51,5 @@ class RedisClient
         super("Cluster client doesn't know which node the #{command} command should be sent to.")
       end
     end
-
-    # Raised when commands in pipelining include cross slot keys.
-    class CrossSlotPipeliningError < ::RedisClient::Error
-      def initialize(keys)
-        super("Cluster client couldn't send pipelining to single node. "\
-              "The commands include cross slot keys. #{keys}")
-      end
-    end
   end
 end

data/lib/redis_client/cluster/node.rb

@@ -10,6 +10,8 @@ class RedisClient
       include Enumerable
 
       SLOT_SIZE = 16_384
+      MIN_SLOT = 0
+      MAX_SLOT = SLOT_SIZE - 1
       ReloadNeeded = Class.new(::RedisClient::Error)
 
       class Config < ::RedisClient::Config
@@ -18,6 +20,8 @@ class RedisClient
           super(**kwargs)
         end
 
+        private
+
         def build_connection_prelude
           prelude = super.dup
           prelude << ['READONLY'] if @scale_read
@@ -27,10 +31,10 @@ class RedisClient
 
       class << self
         def load_info(options, **kwargs)
-          tmp_nodes = ::RedisClient::Cluster::Node.new(options, **kwargs)
+          startup_nodes = ::RedisClient::Cluster::Node.new(options, **kwargs)
 
-          errors = tmp_nodes.map do |tmp_node|
-            reply = tmp_node.call('CLUSTER', 'NODES')
+          errors = startup_nodes.map do |n|
+            reply = n.call('CLUSTER', 'NODES')
             return parse_node_info(reply)
           rescue ::RedisClient::ConnectionError, ::RedisClient::CommandError => e
             e
@@ -38,12 +42,13 @@ class RedisClient
 
           raise ::RedisClient::Cluster::InitialSetupError, errors
         ensure
-          tmp_nodes&.each(&:close)
+          startup_nodes&.each(&:close)
         end
 
         private
 
         # @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
           rows = info.split("\n").map(&:split)
           rows.each { |arr| arr[2] = arr[2].split(',') }
@@ -51,7 +56,13 @@ class RedisClient
           rows.each do |arr|
             arr[1] = arr[1].split('@').first
             arr[2] = (arr[2] & %w[master slave]).first
-            arr[8] = arr[8].nil? ? [] : arr[8].split(',').map { |r| r.split('-').map { |s| Integer(s) } }
+            if arr[8].nil?
+              arr[8] = []
+              next
+            end
+
+            arr[8] = arr[8].split(',').map { |r| r.split('-').map { |s| Integer(s) } }
+            arr[8] = arr[8].map { |a| a.size == 1 ? a << a.first : a }.map(&:sort)
           end
 
           rows.map do |arr|
@@ -61,15 +72,15 @@ class RedisClient
         end
       end
 
-      def initialize(options, node_info = [], pool = nil, with_replica: false, **kwargs)
+      def initialize(options, node_info: [], pool: nil, with_replica: false, **kwargs)
         @with_replica = with_replica
         @slots = build_slot_node_mappings(node_info)
         @replications = build_replication_mappings(node_info)
-        @clients = build_clients(options, pool, **kwargs)
+        @clients = build_clients(options, pool: pool, **kwargs)
       end
 
       def inspect
-        @clients.keys.sort.to_s
+        "#<#{self.class.name} #{node_keys.join(', ')}>"
       end
 
       def each(&block)
@@ -80,6 +91,14 @@ class RedisClient
         @clients.values.sample
       end
 
+      def node_keys
+        @clients.keys.sort
+      end
+
+      def primary_node_keys
+        @clients.filter_map { |k, _| primary?(k) ? k : nil }.sort
+      end
+
       def find_by(node_key)
         @clients.fetch(node_key)
       rescue KeyError
@@ -114,26 +133,33 @@ class RedisClient
       end
 
       def scale_reading_clients
-        reading_clients = []
-
-        @clients.each do |node_key, client|
-          next unless replica_disabled? ? primary?(node_key) : replica?(node_key)
-
-          reading_clients << client
+        clients = @clients.select do |node_key, _|
+          replica_disabled? ? primary?(node_key) : replica?(node_key)
         end
 
-        reading_clients
+        clients.values.sort_by do |client|
+          ::RedisClient::Cluster::NodeKey.build_from_host_port(client.config.host, client.config.port)
+        end
       end
 
       def slot_exists?(slot)
+        slot = Integer(slot)
+        return false if slot < MIN_SLOT || slot > MAX_SLOT
+
         !@slots[slot].nil?
       end
 
       def find_node_key_of_primary(slot)
+        slot = Integer(slot)
+        return if slot < MIN_SLOT || slot > MAX_SLOT
+
         @slots[slot]
       end
 
       def find_node_key_of_replica(slot)
+        slot = Integer(slot)
+        return if slot < MIN_SLOT || slot > MAX_SLOT
+
         return @slots[slot] if replica_disabled? || @replications[@slots[slot]].size.zero?
 
         @replications[@slots[slot]].sample
@@ -177,12 +203,12 @@ class RedisClient
         end
       end
 
-      def build_clients(options, pool, **kwargs)
+      def build_clients(options, pool: nil, **kwargs)
         options.filter_map do |node_key, option|
           next if replica_disabled? && replica?(node_key)
 
-          config = ::RedisClient::Cluster::Node::Config.new(scale_read: replica?(node_key), **option)
-          client = pool.nil? ? config.new_client(**kwargs) : config.new_pool(**pool, **kwargs)
+          config = ::RedisClient::Cluster::Node::Config.new(scale_read: replica?(node_key), **option.merge(kwargs))
+          client = pool.nil? ? config.new_client : config.new_pool(**pool)
 
           [node_key, client]
         end.to_h

data/lib/redis_client/cluster/node_key.rb

@@ -16,10 +16,15 @@ class RedisClient
       end
 
       def split(node_key)
-        node_key.split(DELIMITER)
+        pos = node_key&.rindex(DELIMITER, -1)
+        return [node_key, nil] if pos.nil?
+
+        [node_key[0, pos], node_key[pos + 1, node_key.size - pos - 1]]
       end
 
       def build_from_uri(uri)
+        return '' if uri.nil?
+
         "#{uri.host}#{DELIMITER}#{uri.port}"
       end
 

data/lib/redis_client/cluster.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'redis_client'
 require 'redis_client/cluster/command'
 require 'redis_client/cluster/errors'
 require 'redis_client/cluster/key_slot_converter'
@@ -8,33 +9,98 @@ require 'redis_client/cluster/node_key'
 
 class RedisClient
   class Cluster
+    class Pipeline
+      ReplySizeError = Class.new(::RedisClient::Error)
+
+      def initialize(client)
+        @client = client
+        @grouped = Hash.new([].freeze)
+        @replies = []
+        @size = 0
+      end
+
+      def call(*command, **kwargs)
+        node_key = @client.send(:find_node_key, command, primary_only: true)
+        @grouped[node_key] += [[@size, :call, command, kwargs]]
+        @size += 1
+      end
+
+      def call_once(*command, **kwargs)
+        node_key = @client.send(:find_node_key, command, primary_only: true)
+        @grouped[node_key] += [[@size, :call_once, command, kwargs]]
+        @size += 1
+      end
+
+      def blocking_call(timeout, *command, **kwargs)
+        node_key = @client.send(:find_node_key, command, primary_only: true)
+        @grouped[node_key] += [[@size, :blocking_call, timeout, command, kwargs]]
+        @size += 1
+      end
+
+      def empty?
+        @size.zero?
+      end
+
+      # TODO: use concurrency
+      def execute # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+        @grouped.each do |node_key, rows|
+          node_key = node_key.nil? ? @client.instance_variable_get(:@node).primary_node_keys.sample : node_key
+          replies = @client.send(:find_node, node_key).pipelined do |pipeline|
+            rows.each do |row|
+              case row[1]
+              when :call then pipeline.call(*row[2], **row[3])
+              when :call_once then pipeline.call_once(*row[2], **row[3])
+              when :blocking_call then pipeline.blocking_call(row[2], *row[3], **row[4])
+              else raise NotImplementedError, row[1]
+              end
+            end
+          end
+
+          raise ReplySizeError, "commands: #{rows.size}, replies: #{replies.size}" if rows.size != replies.size
+
+          rows.each_with_index { |row, idx| @replies[row.first] = replies[idx] }
+        end
+
+        @replies
+      end
+    end
+
+    ZERO_CURSOR_FOR_SCAN = '0'
+
     def initialize(config, pool: nil, **kwargs)
       @config = config.dup
       @pool = pool
       @client_kwargs = kwargs
-      @node = fetch_cluster_info!(@config, @pool, **@client_kwargs)
+      @node = fetch_cluster_info!(@config, pool: @pool, **@client_kwargs)
       @command = ::RedisClient::Cluster::Command.load(@node)
     end
 
     def inspect
-      @node.inspect
+      "#<#{self.class.name} #{@node.node_keys.join(', ')}>"
     end
 
-    def call(*command, **kwargs, &block)
-      send_command(:call, *command, **kwargs, &block)
+    def call(*command, **kwargs)
+      send_command(:call, *command, **kwargs)
     end
 
-    def call_once(*command, **kwargs, &block)
-      send_command(:call_once, *command, **kwargs, &block)
+    def call_once(*command, **kwargs)
+      send_command(:call_once, *command, **kwargs)
     end
 
-    def blocking_call(timeout, *command, **kwargs, &block)
+    def blocking_call(timeout, *command, **kwargs)
       node = assign_node(*command)
-      try_send(node, :blocking_call, timeout, *command, **kwargs, &block)
+      try_send(node, :blocking_call, timeout, *command, **kwargs)
     end
 
     def scan(*args, **kwargs, &block)
-      _scan(:scan, *args, **kwargs, &block)
+      raise ArgumentError, 'block required' unless block
+
+      cursor = ZERO_CURSOR_FOR_SCAN
+      loop do
+        cursor, keys = _scan('SCAN', cursor, *args, **kwargs)
+        keys.each(&block)
+        break if cursor == ZERO_CURSOR_FOR_SCAN
+      end
     end
 
     def sscan(key, *args, **kwargs, &block)
@@ -52,14 +118,22 @@ class RedisClient
       try_send(node, :zscan, key, *args, **kwargs, &block)
     end
 
-    def pipelined
+    def mset
       # TODO: impl
     end
 
-    def multi
+    def mget
       # TODO: impl
     end
 
+    def pipelined
+      pipeline = ::RedisClient::Cluster::Pipeline.new(self)
+      yield pipeline
+      return [] if pipeline.empty? == 0
+
+      pipeline.execute
+    end
+
     def pubsub
       # TODO: impl
     end
@@ -73,51 +147,19 @@ class RedisClient
     end
     alias then with
 
-    def id
-      @node.flat_map(&:id).sort.join(' ')
-    end
-
-    def connected?
-      @node.any?(&:connected?)
-    end
-
     def close
       @node.each(&:close)
-      true
-    end
-
-    # TODO: remove
-    def call_pipeline(pipeline)
-      node_keys = pipeline.commands.filter_map { |cmd| find_node_key(cmd, primary_only: true) }.uniq
-      if node_keys.size > 1
-        raise(CrossSlotPipeliningError,
-              pipeline.commands.map { |cmd| @command.extract_first_key(cmd) }.reject(&:empty?).uniq)
-      end
-
-      try_send(find_node(node_keys.first), :call_pipeline, pipeline)
-    end
-
-    # TODO: remove
-    def process(commands, &block)
-      if commands.size == 1 &&
-         %w[unsubscribe punsubscribe].include?(commands.first.first.to_s.downcase) &&
-         commands.first.size == 1
-
-        # Node is indeterminate. We do just a best-effort try here.
-        @node.process_all(commands, &block)
-      else
-        node = assign_node(commands.first)
-        try_send(node, :process, commands, &block)
-      end
+      nil
     end
 
     private
 
-    def fetch_cluster_info!(config, pool, **kwargs)
+    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)
-      ::RedisClient::Cluster::Node.new(config.per_node_key, node_info, pool, with_replica: config.use_replica?, **kwargs)
+      ::RedisClient::Cluster::Node.new(config.per_node_key,
+                                       node_info: node_info, pool: pool, with_replica: config.use_replica?, **kwargs)
     end
 
     def send_command(method, *command, **kwargs, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
@@ -130,7 +172,7 @@ class RedisClient
       when 'wait'     then @node.call_primary(method, *command, **kwargs, &block).sum
       when 'keys'     then @node.call_replica(method, *command, **kwargs, &block).flatten.sort
       when 'dbsize'   then @node.call_replica(method, *command, **kwargs, &block).sum
-      when 'scan'     then _scan(method, *command, **kwargs, &block)
+      when 'scan'     then _scan(*command, **kwargs)
       when 'lastsave' then @node.call_all(method, *command, **kwargs, &block).sort
       when 'role'     then @node.call_all(method, *command, **kwargs, &block)
       when 'config'   then send_config_command(method, *command, **kwargs, &block)
@@ -179,7 +221,7 @@ class RedisClient
       case subcommand
       when 'addslots', 'delslots', 'failover', 'forget', 'meet', 'replicate',
            'reset', 'set-config-epoch', 'setslot'
-        raise ::RedisClient::Cluster::OrchestrationCommandNotSupported, 'cluster', subcommand
+        raise ::RedisClient::Cluster::OrchestrationCommandNotSupported, ['cluster', subcommand]
       when 'saveconfig' then @node.call_all(method, *command, **kwargs, &block).first
       else assign_node(*command).send(method, *command, **kwargs, &block)
       end
@@ -195,7 +237,7 @@ class RedisClient
       end
     end
 
-    def send_pubsub_command(method, *command, **kwargs, &block) # rubocop:disable Metircs/AbcSize, Metrics/CyclomaticComplexity
+    def send_pubsub_command(method, *command, **kwargs, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
       case command[1].to_s.downcase
       when 'channels' then @node.call_all(method, *command, **kwargs, &block).flatten.uniq.sort
       when 'numsub'
@@ -232,7 +274,8 @@ class RedisClient
       raise
     end
 
-    def _scan(method, *command, **kwargs, &block) # rubocop:disable Metrics/MethodLength
+    def _scan(*command, **kwargs) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      command[1] = ZERO_CURSOR_FOR_SCAN if command.size == 1
       input_cursor = Integer(command[1])
 
       client_index = input_cursor % 256
@@ -241,11 +284,11 @@ class RedisClient
       clients = @node.scale_reading_clients
 
       client = clients[client_index]
-      return ['0', []] unless client
+      return [ZERO_CURSOR_FOR_SCAN, []] unless client
 
       command[1] = raw_cursor.to_s
 
-      result_cursor, result_keys = client.send(method, *command, **kwargs, &block)
+      result_cursor, result_keys = client.call(*command, **kwargs)
       result_cursor = Integer(result_cursor)
 
       client_index += 1 if result_cursor == 0
@@ -300,7 +343,7 @@ class RedisClient
       end
 
       @node.each(&:close)
-      @node = fetch_cluster_info!(@config, @pool, **@client_kwargs)
+      @node = fetch_cluster_info!(@config, pool: @pool, **@client_kwargs)
     end
   end
 end

data/lib/redis_client/cluster_config.rb

@@ -7,23 +7,26 @@ require 'redis_client/cluster/node_key'
 
 class RedisClient
   class ClusterConfig
+    DEFAULT_HOST = '127.0.0.1'
+    DEFAULT_PORT = 6379
     DEFAULT_SCHEME = 'redis'
     SECURE_SCHEME = 'rediss'
+    DEFAULT_NODES = ["#{DEFAULT_SCHEME}://#{DEFAULT_HOST}:#{DEFAULT_PORT}"].freeze
     VALID_SCHEMES = [DEFAULT_SCHEME, SECURE_SCHEME].freeze
+    VALID_NODES_KEYS = %i[ssl username password host port db].freeze
+    MERGE_CONFIG_KEYS = %i[ssl username password].freeze
+
     InvalidClientConfigError = Class.new(::RedisClient::Error)
 
-    def initialize(nodes:, replica: false, fixed_hostname: nil, **client_config)
-      @replica = replica
-      @fixed_hostname = fixed_hostname
-      @client_config = client_config.dup
+    def initialize(nodes: DEFAULT_NODES, replica: false, fixed_hostname: '', **client_config)
+      @replica = true & replica
+      @fixed_hostname = fixed_hostname.to_s
       @node_configs = build_node_configs(nodes.dup)
-      add_common_node_config_if_needed(@client_config, @node_configs, :ssl)
-      add_common_node_config_if_needed(@client_config, @node_configs, :username)
-      add_common_node_config_if_needed(@client_config, @node_configs, :password)
+      @client_config = merge_generic_config(client_config, @node_configs)
     end
 
     def inspect
-      per_node_key.to_s
+      "#<#{self.class.name} #{per_node_key.values}>"
     end
 
     def new_pool(size: 5, timeout: 5, **kwargs)
@@ -38,7 +41,7 @@ class RedisClient
       @node_configs.to_h do |config|
         node_key = ::RedisClient::Cluster::NodeKey.build_from_host_port(config[:host], config[:port])
         config = @client_config.merge(config)
-        config = config.merge(host: @fixed_hostname) if @fixed_hostname && !@fixed_hostname.empty?
+        config = config.merge(host: @fixed_hostname) unless @fixed_hostname.empty?
         [node_key, config]
       end
     end
@@ -62,9 +65,10 @@ class RedisClient
     private
 
     def build_node_configs(addrs)
-      raise InvalidClientConfigError, 'Redis option of `cluster` must be an Array' unless addrs.is_a?(Array)
+      configs = Array[addrs].flatten.filter_map { |addr| parse_node_addr(addr) }
+      raise InvalidClientConfigError, '`nodes` option is empty' if configs.size.zero?
 
-      addrs.map { |addr| parse_node_addr(addr) }
+      configs
     end
 
     def parse_node_addr(addr)
@@ -74,41 +78,51 @@ class RedisClient
       when Hash
         parse_node_option(addr)
       else
-        raise InvalidClientConfigError, 'Redis option of `cluster` must includes String or Hash'
+        raise InvalidClientConfigError, "`nodes` option includes invalid type values: #{addr}"
       end
     end
 
-    def parse_node_url(addr) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+    def parse_node_url(addr) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+      return if addr.empty?
+
       uri = URI(addr)
-      raise InvalidClientConfigError, "Invalid uri scheme #{addr}" unless VALID_SCHEMES.include?(uri.scheme)
+      scheme = uri.scheme || DEFAULT_SCHEME
+      raise InvalidClientConfigError, "`nodes` option includes a invalid uri scheme: #{addr}" unless VALID_SCHEMES.include?(scheme)
 
-      db = uri.path.split('/')[1]&.to_i
       username = uri.user ? URI.decode_www_form_component(uri.user) : nil
       password = uri.password ? URI.decode_www_form_component(uri.password) : nil
+      host = uri.host || DEFAULT_HOST
+      port = uri.port || DEFAULT_PORT
+      db = uri.path.index('/').nil? ? uri.path : uri.path.split('/')[1]
+      db = db.nil? || db.empty? ? db : ensure_integer(db)
 
-      {
-        host: uri.host,
-        port: uri.port,
-        username: username,
-        password: password,
-        db: db,
-        ssl: uri.scheme == SECURE_SCHEME
-      }.reject { |_, v| v.nil? || v == '' }
+      { ssl: scheme == SECURE_SCHEME, username: username, password: password, host: host, port: port, db: db }
+        .reject { |_, v| v.nil? || v == '' || v == false }
     rescue URI::InvalidURIError => e
-      raise InvalidClientConfigError, e.message
+      raise InvalidClientConfigError, "#{e.message}: #{addr}"
     end
 
     def parse_node_option(addr)
+      return if addr.empty?
+
       addr = addr.transform_keys(&:to_sym)
-      raise InvalidClientConfigError, 'Redis option of `cluster` must includes `:host` and `:port` keys' if addr.values_at(:host, :port).any?(&:nil?)
+      addr[:host] ||= DEFAULT_HOST
+      addr[:port] = ensure_integer(addr[:port] || DEFAULT_PORT)
+      addr.select { |k, _| VALID_NODES_KEYS.include?(k) }
+    end
 
-      addr
+    def ensure_integer(value)
+      Integer(value)
+    rescue ArgumentError => e
+      raise InvalidClientConfigError, e.message
     end
 
-    def add_common_node_config_if_needed(client_config, node_configs, key)
-      return client_config if client_config[key].nil? && node_configs.first[key].nil?
+    def merge_generic_config(client_config, node_configs)
+      return client_config if node_configs.size.zero?
 
-      client_config[key] ||= node_configs.first[key]
+      cfg = node_configs.first
+      MERGE_CONFIG_KEYS.each { |k| client_config[k] = cfg[k] if cfg.key?(k) }
+      client_config
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-12 00:00:00.000000000 Z
+date: 2022-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client