redis-cluster-client 0.0.1 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4339be83a679ef61e9d9a98e26cd2dd52b58b56eaa852a53c8f0f01ef1987396
-  data.tar.gz: ac7ea102f9d5a711ee495a36c844443027b39d2c64e0d9177d419d00e1fa0de0
+  metadata.gz: 0561fdd5885f8c6c5c5c100af032b867224eff3ed91b546b6885f8bf3bd76663
+  data.tar.gz: 1ebe59416fb043af9da7a926cd338ac260ce1a46e5220b46f7a6744c8f1b8c2b
 SHA512:
-  metadata.gz: 268000fa3691afc08d969b35cf8ac90221e96ffb41db59c63d9737e9ebed3d978f84f36ba4ee91ceb4bb88c957c3d2ecead676bc7b6c7a4411598969213e269c
-  data.tar.gz: 1a44f77bdd4202f327025d3fa0d0a3b65b577332cd714f787159c8ba41f20f5b3c8b058b5c48aab74f5d0a7b3ec4638f227b5f205ed07c8e32dba4c71220695b
+  metadata.gz: 86661400532550e005beb98e740e4939ffcf93c1b66fb47930bc2a5819f5dbba60e940c8e0183d312a6ce7cb55d1cc0634081029eb8e5c1b8f68ea2862d9e0df
+  data.tar.gz: 3629f63ed379946bc8951c57ada535573130e8db504a2f5b7644ef9091408ac3223c5b0a260b13d6b84ab889b3e47c4571bbc10f5b21ceaf6758dc60c28a00b3

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,10 @@ class RedisClient
       include Enumerable
 
       SLOT_SIZE = 16_384
+      MIN_SLOT = 0
+      MAX_SLOT = SLOT_SIZE - 1
+      IGNORE_GENERIC_CONFIG_KEYS = %i[url host port path].freeze
+
       ReloadNeeded = Class.new(::RedisClient::Error)
 
       class Config < ::RedisClient::Config
@@ -18,6 +22,8 @@ class RedisClient
           super(**kwargs)
         end
 
+        private
+
         def build_connection_prelude
           prelude = super.dup
           prelude << ['READONLY'] if @scale_read
@@ -27,10 +33,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 +44,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 +58,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 +74,16 @@ 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)
+        @mutex = Mutex.new
       end
 
       def inspect
-        @clients.keys.sort.to_s
+        "#<#{self.class.name} #{node_keys.join(', ')}>"
       end
 
       def each(&block)
@@ -80,6 +94,20 @@ 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 replica_node_keys
+        return primary_node_keys if replica_disabled?
+
+        @clients.filter_map { |k, _| replica?(k) ? k : nil }.sort
+      end
+
       def find_by(node_key)
         @clients.fetch(node_key)
       rescue KeyError
@@ -108,39 +136,41 @@ class RedisClient
         end.values
       end
 
-      # TODO: impl
-      def process_all(commands, &block)
-        try_map { |_, client| client.process(commands, &block) }.values
-      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
       end
 
       def update_slot(slot, node_key)
-        @slots[slot] = node_key
+        @mutex.synchronize { @slots[slot] = node_key }
       end
 
       private
@@ -177,12 +207,15 @@ 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.reject { |k, _| IGNORE_GENERIC_CONFIG_KEYS.include?(k) })
+          )
+          client = pool.nil? ? config.new_client : config.new_pool(**pool)
 
           [node_key, client]
         end.to_h
@@ -191,15 +224,17 @@ class RedisClient
       def try_map # rubocop:disable Metrics/MethodLength
         errors = {}
         results = {}
-
-        @clients.each do |node_key, client|
-          reply = yield(node_key, client)
-          results[node_key] = reply unless reply.nil?
-        rescue ::RedisClient::CommandError => e
-          errors[node_key] = e
-          next
+        threads = @clients.map do |k, v|
+          Thread.new(k, v) do |node_key, client|
+            Thread.pass
+            reply = yield(node_key, client)
+            results[node_key] = reply unless reply.nil?
+          rescue ::RedisClient::CommandError => e
+            errors[node_key] = e
+          end
         end
 
+        threads.each(&:join)
         return results if errors.empty?
 
         raise ::RedisClient::Cluster::CommandErrorCollection, errors

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)..]]
       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,116 +9,175 @@ 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)
+        @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
+
+      def execute # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        all_replies = []
+        threads = @grouped.map do |k, v|
+          Thread.new(@client, k, v) do |client, node_key, rows|
+            Thread.pass
+
+            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| all_replies[row.first] = replies[idx] }
+          end
+        end
+
+        threads.each(&:join)
+        all_replies
+      end
+    end
+
+    class PubSub
+      def initialize(client)
+        @client = client
+        @pubsub = nil
+      end
+
+      def call(*command, **kwargs)
+        close
+        @pubsub = @client.send(:assign_node, *command).pubsub
+        @pubsub.call(*command, **kwargs)
+      end
+
+      def close
+        @pubsub&.close
+        @pubsub = nil
+      end
+
+      def next_event(timeout = nil)
+        @pubsub&.next_event(timeout)
+      end
+    end
+
+    ZERO_CURSOR_FOR_SCAN = '0'
+    CMD_SCAN = 'SCAN'
+    CMD_SSCAN = 'SSCAN'
+    CMD_HSCAN = 'HSCAN'
+    CMD_ZSCAN = 'ZSCAN'
+    CMD_ASKING = 'ASKING'
+    REPLY_OK = 'OK'
+    REPLY_MOVED = 'MOVED'
+    REPLY_ASK = 'ASK'
+
     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)
+      @mutex = Mutex.new
     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(CMD_SCAN, cursor, *args, **kwargs)
+        keys.each(&block)
+        break if cursor == ZERO_CURSOR_FOR_SCAN
+      end
     end
 
     def sscan(key, *args, **kwargs, &block)
-      node = assign_node('SSCAN', key)
+      node = assign_node(CMD_SSCAN, key)
       try_send(node, :sscan, key, *args, **kwargs, &block)
     end
 
     def hscan(key, *args, **kwargs, &block)
-      node = assign_node('HSCAN', key)
+      node = assign_node(CMD_HSCAN, key)
       try_send(node, :hscan, key, *args, **kwargs, &block)
     end
 
     def zscan(key, *args, **kwargs, &block)
-      node = assign_node('ZSCAN', key)
+      node = assign_node(CMD_ZSCAN, key)
       try_send(node, :zscan, key, *args, **kwargs, &block)
     end
 
     def pipelined
-      # TODO: impl
-    end
+      pipeline = ::RedisClient::Cluster::Pipeline.new(self)
+      yield pipeline
+      return [] if pipeline.empty? == 0
 
-    def multi
-      # TODO: impl
+      pipeline.execute
     end
 
     def pubsub
-      # TODO: impl
-    end
-
-    def size
-      # TODO: impl
-    end
-
-    def with(options = {})
-      # TODO: impl
-    end
-    alias then with
-
-    def id
-      @node.flat_map(&:id).sort.join(' ')
-    end
-
-    def connected?
-      @node.any?(&:connected?)
+      ::RedisClient::Cluster::PubSub.new(self)
     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 +190,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 +239,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 +255,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'
@@ -211,17 +271,17 @@ class RedisClient
     def try_send(node, method, *args, retry_count: 3, **kwargs, &block) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       node.send(method, *args, **kwargs, &block)
     rescue ::RedisClient::CommandError => e
-      if e.message.start_with?('MOVED')
+      if e.message.start_with?(REPLY_MOVED)
         raise if retry_count <= 0
 
         node = assign_redirection_node(e.message)
         retry_count -= 1
         retry
-      elsif e.message.start_with?('ASK')
+      elsif e.message.start_with?(REPLY_ASK)
         raise if retry_count <= 0
 
         node = assign_asking_node(e.message)
-        node.call('ASKING')
+        node.call(CMD_ASKING)
         retry_count -= 1
         retry
       else
@@ -232,7 +292,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 +302,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
@@ -266,13 +327,17 @@ class RedisClient
     end
 
     def assign_node(*command)
-      node_key = find_node_key(command)
+      node_key = find_node_key(*command)
       find_node(node_key)
     end
 
-    def find_node_key(command, primary_only: false)
+    def find_node_key(*command, primary_only: false) # rubocop:disable Metrics/MethodLength
       key = @command.extract_first_key(command)
-      return if key.empty?
+      if key.empty?
+        return @node.primary_node_keys.sample if @command.should_send_to_primary?(command) || primary_only
+
+        return @node.replica_node_keys.sample
+      end
 
       slot = ::RedisClient::Cluster::KeySlotConverter.convert(key)
       return unless @node.slot_exists?(slot)
@@ -294,13 +359,15 @@ class RedisClient
     end
 
     def update_cluster_info!(node_key = nil)
-      unless node_key.nil?
-        host, port = ::RedisClient::Cluster::NodeKey.split(node_key)
-        @config.add_node(host, port)
+      @mutex.synchronize do
+        unless node_key.nil?
+          host, port = ::RedisClient::Cluster::NodeKey.split(node_key)
+          @config.add_node(host, port)
+        end
+
+        @node.each(&:close)
+        @node = fetch_cluster_info!(@config, pool: @pool, **@client_kwargs)
       end
-
-      @node.each(&:close)
-      @node = fetch_cluster_info!(@config, @pool, **@client_kwargs)
     end
   end
 end

data/lib/redis_client/cluster_config.rb

@@ -7,23 +7,29 @@ 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
+    IGNORE_GENERIC_CONFIG_KEYS = %i[url host port path].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 = client_config.reject { |k, _| IGNORE_GENERIC_CONFIG_KEYS.include?(k) }
+      @client_config = merge_generic_config(client_config, @node_configs)
+      @mutex = Mutex.new
     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 +44,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
@@ -48,11 +54,11 @@ class RedisClient
     end
 
     def update_node(addrs)
-      @node_configs = build_node_configs(addrs)
+      @mutex.synchronize { @node_configs = build_node_configs(addrs) }
     end
 
     def add_node(host, port)
-      @node_configs << { host: host, port: port }
+      @mutex.synchronize { @node_configs << { host: host, port: port } }
     end
 
     def dup
@@ -62,9 +68,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 +81,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.4
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-12 00:00:00.000000000 Z
+date: 2022-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client