redis-cluster-client 0.10.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f88b4bd96fd24566377d49a45a06eaa5fc8029749462995e746074979ba25e70
-  data.tar.gz: a5ecd1339399ba2dda3c004c1cf1bbb2e2510c2f963f0f69afcf71544a8b530c
+  metadata.gz: cd66efdf343224572aeffdbfdd4cb96c8189bd45183c0a3934e6dd1964a35655
+  data.tar.gz: 66805c538066aabab413b767f0b9e8756c1eff8920f410a665939f18d69c0621
 SHA512:
-  metadata.gz: 81b1776f48d1b84866c21e0f00ee644df2f077e06536a6af2b305e50104296b7dabeb9732cce51e0aaca6ce5111a406b21b14db8c114d56e2b3f8f4b7701f2f7
-  data.tar.gz: b2ecb424e00825a115d15808814ee58a7afc06205cf5ca1e4732ca7189a6b9d42d13597974fa8674ca6f1102aa13641d8b7b25883bcea9ede743e2df3dba4814
+  metadata.gz: d325c2955718451c15084b58b0231d521065ebe1b8b549f79106f26132b50eb77ac90e6b0dcfb11868eb80b2d37a742f741b21d963c6ff92faacf4d88bc64830
+  data.tar.gz: 7e6c92442c2852b0533c19b4e60ff8e8e6532d55cbeebc9424e1b62081c6eb21af6a5717ae04fbb683083c271d3008934d0e17becc4b7abf232c005304c2b713

data/lib/redis_client/cluster/command.rb

@@ -12,6 +12,8 @@ class RedisClient
       EMPTY_HASH = {}.freeze
       EMPTY_ARRAY = [].freeze
 
+      private_constant :EMPTY_STRING, :EMPTY_HASH, :EMPTY_ARRAY
+
       Detail = Struct.new(
         'RedisCommand',
         :first_key_position,

data/lib/redis_client/cluster/errors.rb

@@ -6,6 +6,8 @@ class RedisClient
   class Cluster
     ERR_ARG_NORMALIZATION = ->(arg) { Array[arg].flatten.reject { |e| e.nil? || (e.respond_to?(:empty?) && e.empty?) } }
 
+    private_constant :ERR_ARG_NORMALIZATION
+
     class InitialSetupError < ::RedisClient::Error
       def initialize(errors)
         msg = ERR_ARG_NORMALIZATION.call(errors).map(&:message).uniq.join(',')
@@ -30,7 +32,7 @@ class RedisClient
       def initialize(errors)
         @errors = {}
         if !errors.is_a?(Hash) || errors.empty?
-          super('')
+          super(errors.to_s)
           return
         end
 

data/lib/redis_client/cluster/key_slot_converter.rb

@@ -3,6 +3,7 @@
 class RedisClient
   class Cluster
     module KeySlotConverter
+      HASH_SLOTS = 16_384
       EMPTY_STRING = ''
       LEFT_BRACKET = '{'
       RIGHT_BRACKET = '}'
@@ -41,7 +42,8 @@ class RedisClient
         0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
       ].freeze
 
-      HASH_SLOTS = 16_384
+      private_constant :HASH_SLOTS, :EMPTY_STRING,
+                       :LEFT_BRACKET, :RIGHT_BRACKET, :XMODEM_CRC16_LOOKUP
 
       module_function
 

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

@@ -8,6 +8,8 @@ class RedisClient
         EMPTY_HASH = {}.freeze
         EMPTY_ARRAY = [].freeze
 
+        private_constant :IGNORE_GENERIC_CONFIG_KEYS, :EMPTY_HASH, :EMPTY_ARRAY
+
         attr_reader :clients, :primary_clients, :replica_clients
 
         def initialize(pool, concurrent_worker, **kwargs)

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

@@ -9,6 +9,8 @@ class RedisClient
         DUMMY_LATENCY_MSEC = 100 * 1000 * 1000
         MEASURE_ATTEMPT_COUNT = 10
 
+        private_constant :DUMMY_LATENCY_MSEC, :MEASURE_ATTEMPT_COUNT
+
         def clients_for_scanning(seed: nil) # rubocop:disable Lint/UnusedMethodArgument
           @clients_for_scanning
         end

data/lib/redis_client/cluster/node.rb

@@ -13,9 +13,6 @@ class RedisClient
     class Node
       include Enumerable
 
-      # It affects to strike a balance between load and stability in initialization or changed states.
-      MAX_STARTUP_SAMPLE = Integer(ENV.fetch('REDIS_CLIENT_MAX_STARTUP_SAMPLE', 3))
-
       # less memory consumption, but slow
       USE_CHAR_ARRAY_SLOT = Integer(ENV.fetch('REDIS_CLIENT_USE_CHAR_ARRAY_SLOT', 1)) == 1
 
@@ -26,6 +23,10 @@ class RedisClient
       ROLE_FLAGS = %w[master slave].freeze
       EMPTY_ARRAY = [].freeze
       EMPTY_HASH = {}.freeze
+      STATE_REFRESH_INTERVAL = (3..10).freeze
+
+      private_constant :USE_CHAR_ARRAY_SLOT, :SLOT_SIZE, :MIN_SLOT, :MAX_SLOT,
+                       :DEAD_FLAGS, :ROLE_FLAGS, :EMPTY_ARRAY, :EMPTY_HASH
 
       ReloadNeeded = Class.new(::RedisClient::Error)
 
@@ -48,6 +49,8 @@ class RedisClient
         BASE = ''
         PADDING = '0'
 
+        private_constant :BASE, :PADDING
+
         def initialize(size, elements)
           @elements = elements
           @string = String.new(BASE, encoding: Encoding::BINARY, capacity: size)
@@ -101,6 +104,8 @@ class RedisClient
         @config = config
         @mutex = Mutex.new
         @last_reloaded_at = nil
+        @reload_times = 0
+        @random = Random.new
       end
 
       def inspect
@@ -197,7 +202,7 @@ class RedisClient
 
       def reload!
         with_reload_lock do
-          with_startup_clients(MAX_STARTUP_SAMPLE) do |startup_clients|
+          with_startup_clients(@config.max_startup_sample) do |startup_clients|
             @node_info = refetch_node_info_list(startup_clients)
             @node_configs = @node_info.to_h do |node_info|
               [node_info.node_key, @config.client_config_for_node(node_info.node_key)]
@@ -417,15 +422,27 @@ class RedisClient
         # performed the reload.
         # Probably in the future we should add a circuit breaker to #reload itself, and stop trying if the cluster is
         # obviously not working.
-        wait_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        wait_start = obtain_current_time
         @mutex.synchronize do
           return if @last_reloaded_at && @last_reloaded_at > wait_start
 
+          if @last_reloaded_at && @reload_times > 1
+            # Mitigate load of servers by naive logic. Don't sleep with exponential backoff.
+            now = obtain_current_time
+            elapsed = @last_reloaded_at + @random.rand(STATE_REFRESH_INTERVAL) * 1_000_000
+            return if now < elapsed
+          end
+
           r = yield
-          @last_reloaded_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          @last_reloaded_at = obtain_current_time
+          @reload_times += 1
           r
         end
       end
+
+      def obtain_current_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+      end
     end
   end
 end

data/lib/redis_client/cluster/node_key.rb

@@ -8,6 +8,8 @@ class RedisClient
     module NodeKey
       DELIMITER = ':'
 
+      private_constant :DELIMITER
+
       module_function
 
       def hashify(node_key)

data/lib/redis_client/cluster/normalized_cmd_name.rb

@@ -9,6 +9,8 @@ class RedisClient
 
       EMPTY_STRING = ''
 
+      private_constant :EMPTY_STRING
+
       def initialize
         @cache = {}
         @mutex = Mutex.new

data/lib/redis_client/cluster/optimistic_locking.rb

@@ -11,7 +11,7 @@ class RedisClient
         @asking = false
       end
 
-      def watch(keys)
+      def watch(keys) # rubocop:disable Metrics/AbcSize
         slot = find_slot(keys)
         raise ::RedisClient::Cluster::Transaction::ConsistencyError, "unsafe watch: #{keys.join(' ')}" if slot.nil?
 
@@ -32,7 +32,13 @@ class RedisClient
                 c.call('UNWATCH')
                 raise
               end
+            rescue ::RedisClient::CommandError => e
+              @router.renew_cluster_state if e.message.start_with?('CLUSTERDOWN Hash slot not served')
+              raise
             end
+          rescue ::RedisClient::ConnectionError
+            @router.renew_cluster_state
+            raise
           end
         end
       end

data/lib/redis_client/cluster/pipeline.rb

@@ -55,32 +55,48 @@ class RedisClient
           results = Array.new(commands.size)
           @pending_reads += size
           write_multi(commands)
+          redirection_indices = stale_cluster_state = first_exception = nil
 
-          redirection_indices = nil
-          first_exception = nil
           size.times do |index|
             timeout = timeouts && timeouts[index]
-            result = read(timeout)
+            result = read(connection_timeout(timeout))
             @pending_reads -= 1
+
             if result.is_a?(::RedisClient::Error)
               result._set_command(commands[index])
+              result._set_config(config)
+
               if result.is_a?(::RedisClient::CommandError) && result.message.start_with?('MOVED', 'ASK')
                 redirection_indices ||= []
                 redirection_indices << index
               elsif exception
                 first_exception ||= result
               end
+
+              stale_cluster_state = true if result.message.start_with?('CLUSTERDOWN Hash slot not served')
             end
+
             results[index] = result
           end
 
-          raise first_exception if exception && first_exception
-          return results if redirection_indices.nil?
+          if redirection_indices
+            err = ::RedisClient::Cluster::Pipeline::RedirectionNeeded.new
+            err.replies = results
+            err.indices = redirection_indices
+            err.first_exception = first_exception
+            raise err
+          end
+
+          if stale_cluster_state
+            err = ::RedisClient::Cluster::Pipeline::StaleClusterState.new
+            err.replies = results
+            err.first_exception = first_exception
+            raise err
+          end
+
+          raise first_exception if first_exception
 
-          err = ::RedisClient::Cluster::Pipeline::RedirectionNeeded.new
-          err.replies = results
-          err.indices = redirection_indices
-          raise err
+          results
         end
       end
 
@@ -94,8 +110,12 @@ class RedisClient
 
       ReplySizeError = Class.new(::RedisClient::Error)
 
+      class StaleClusterState < ::RedisClient::Error
+        attr_accessor :replies, :first_exception
+      end
+
       class RedirectionNeeded < ::RedisClient::Error
-        attr_accessor :replies, :indices
+        attr_accessor :replies, :indices, :first_exception
       end
 
       def initialize(router, command_builder, concurrent_worker, exception:, seed: Random.new_seed)
@@ -162,14 +182,18 @@ class RedisClient
           end
         end
 
-        all_replies = errors = required_redirections = nil
+        all_replies = errors = required_redirections = cluster_state_errors = nil
 
         work_group.each do |node_key, v|
           case v
           when ::RedisClient::Cluster::Pipeline::RedirectionNeeded
             required_redirections ||= {}
             required_redirections[node_key] = v
+          when ::RedisClient::Cluster::Pipeline::StaleClusterState
+            cluster_state_errors ||= {}
+            cluster_state_errors[node_key] = v
           when StandardError
+            cluster_state_errors ||= {} if v.is_a?(::RedisClient::ConnectionError)
             errors ||= {}
             errors[node_key] = v
           else
@@ -179,15 +203,25 @@ class RedisClient
         end
 
         work_group.close
+        @router.renew_cluster_state if cluster_state_errors
         raise ::RedisClient::Cluster::ErrorCollection, errors unless errors.nil?
 
         required_redirections&.each do |node_key, v|
+          raise v.first_exception if v.first_exception
+
           all_replies ||= Array.new(@size)
           pipeline = @pipelines[node_key]
           v.indices.each { |i| v.replies[i] = handle_redirection(v.replies[i], pipeline, i) }
           pipeline.outer_indices.each_with_index { |outer, inner| all_replies[outer] = v.replies[inner] }
         end
 
+        cluster_state_errors&.each do |node_key, v|
+          raise v.first_exception if v.first_exception
+
+          all_replies ||= Array.new(@size)
+          @pipelines[node_key].outer_indices.each_with_index { |outer, inner| all_replies[outer] = v.replies[inner] }
+        end
+
         all_replies
       end
 

data/lib/redis_client/cluster/pub_sub.rb

@@ -24,6 +24,8 @@ class RedisClient
         def close
           @worker.exit if @worker&.alive?
           @client.close
+        rescue ::RedisClient::ConnectionError
+          # ignore
         end
 
         private
@@ -44,32 +46,40 @@ class RedisClient
 
       BUF_SIZE = Integer(ENV.fetch('REDIS_CLIENT_PUBSUB_BUF_SIZE', 1024))
 
+      private_constant :BUF_SIZE
+
       def initialize(router, command_builder)
         @router = router
         @command_builder = command_builder
         @queue = SizedQueue.new(BUF_SIZE)
         @state_dict = {}
+        @commands = []
       end
 
       def call(*args, **kwargs)
-        _call(@command_builder.generate(args, kwargs))
+        command = @command_builder.generate(args, kwargs)
+        _call(command)
+        @commands << command
         nil
       end
 
       def call_v(command)
-        _call(@command_builder.generate(command))
+        command = @command_builder.generate(command)
+        _call(command)
+        @commands << command
         nil
       end
 
       def close
         @state_dict.each_value(&:close)
         @state_dict.clear
+        @commands.clear
         @queue.clear
         @queue.close
         nil
       end
 
-      def next_event(timeout = nil)
+      def next_event(timeout = nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         @state_dict.each_value(&:ensure_worker)
         max_duration = calc_max_duration(timeout)
         starting = obtain_current_time
@@ -78,6 +88,13 @@ class RedisClient
           break if max_duration > 0 && obtain_current_time - starting > max_duration
 
           case event = @queue.pop(true)
+          when ::RedisClient::CommandError
+            if event.message.start_with?('MOVED', 'CLUSTERDOWN Hash slot not served')
+              @router.renew_cluster_state
+              break start_over
+            end
+
+            raise event
           when StandardError then raise event
           when Array then break event
           end
@@ -97,13 +114,26 @@ class RedisClient
         end
       end
 
-      def call_to_single_state(command)
+      def call_to_single_state(command, retry_count: 1)
         node_key = @router.find_node_key(command)
-        try_call(node_key, command)
+        @state_dict[node_key] ||= State.new(@router.find_node(node_key).pubsub, @queue)
+        @state_dict[node_key].call(command)
+      rescue ::RedisClient::ConnectionError
+        @state_dict[node_key].close
+        @state_dict.delete(node_key)
+        @router.renew_cluster_state
+        retry_count -= 1
+        retry_count >= 0 ? retry : raise
       end
 
       def call_to_all_states(command)
-        @state_dict.each_value { |s| s.call(command) }
+        @state_dict.each do |node_key, state|
+          state.call(command)
+        rescue ::RedisClient::ConnectionError
+          @state_dict[node_key].close
+          @state_dict.delete(node_key)
+          @router.renew_cluster_state
+        end
       end
 
       def call_for_sharded_states(command)
@@ -114,24 +144,6 @@ class RedisClient
         end
       end
 
-      def try_call(node_key, command, retry_count: 1)
-        add_state(node_key).call(command)
-      rescue ::RedisClient::CommandError => e
-        raise if !e.message.start_with?('MOVED') || retry_count <= 0
-
-        # for sharded pub/sub
-        node_key = e.message.split[2]
-        retry_count -= 1
-        retry
-      end
-
-      def add_state(node_key)
-        return @state_dict[node_key] if @state_dict.key?(node_key)
-
-        state = State.new(@router.find_node(node_key).pubsub, @queue)
-        @state_dict[node_key] = state
-      end
-
       def obtain_current_time
         Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
       end
@@ -139,6 +151,13 @@ class RedisClient
       def calc_max_duration(timeout)
         timeout.nil? || timeout < 0 ? 0 : timeout * 1_000_000
       end
+
+      def start_over
+        @state_dict.each_value(&:close)
+        @state_dict.clear
+        @commands.each { |command| _call(command) }
+        nil
+      end
     end
   end
 end

data/lib/redis_client/cluster/router.rb

@@ -19,6 +19,8 @@ class RedisClient
       ZERO_CURSOR_FOR_SCAN = '0'
       TSF = ->(f, x) { f.nil? ? x : f.call(x) }.curry
 
+      private_constant :ZERO_CURSOR_FOR_SCAN, :TSF
+
       def initialize(config, concurrent_worker, pool: nil, **kwargs)
         @config = config.dup
         @original_config = config.dup if config.connect_with_original_config
@@ -27,7 +29,7 @@ class RedisClient
         @pool = pool
         @client_kwargs = kwargs
         @node = ::RedisClient::Cluster::Node.new(concurrent_worker, config: config, pool: pool, **kwargs)
-        update_cluster_info!
+        renew_cluster_state
         @command = ::RedisClient::Cluster::Command.load(@node.replica_clients.shuffle, slow_command_timeout: config.slow_command_timeout)
         @command_builder = @config.command_builder
       end
@@ -66,15 +68,21 @@ class RedisClient
       rescue ::RedisClient::CircuitBreaker::OpenCircuitError
         raise
       rescue ::RedisClient::Cluster::Node::ReloadNeeded
-        update_cluster_info!
+        renew_cluster_state
         raise ::RedisClient::Cluster::NodeMightBeDown
+      rescue ::RedisClient::ConnectionError
+        renew_cluster_state
+        raise
+      rescue ::RedisClient::CommandError => e
+        renew_cluster_state if e.message.start_with?('CLUSTERDOWN Hash slot not served')
+        raise
       rescue ::RedisClient::Cluster::ErrorCollection => e
         raise if e.errors.any?(::RedisClient::CircuitBreaker::OpenCircuitError)
 
-        update_cluster_info! if e.errors.values.any? do |err|
+        renew_cluster_state if e.errors.values.any? do |err|
           next false if ::RedisClient::Cluster::ErrorIdentification.identifiable?(err) && @node.none? { |c| ::RedisClient::Cluster::ErrorIdentification.client_owns_error?(err, c) }
 
-          err.message.start_with?('CLUSTERDOWN Hash slot not served')
+          err.message.start_with?('CLUSTERDOWN Hash slot not served') || err.is_a?(::RedisClient::ConnectionError)
         end
 
         raise
@@ -105,32 +113,29 @@ class RedisClient
       rescue ::RedisClient::CommandError => e
         raise unless ::RedisClient::Cluster::ErrorIdentification.client_owns_error?(e, node)
 
+        retry_count -= 1
         if e.message.start_with?('MOVED')
           node = assign_redirection_node(e.message)
-          retry_count -= 1
           retry if retry_count >= 0
         elsif e.message.start_with?('ASK')
           node = assign_asking_node(e.message)
-          retry_count -= 1
           if retry_count >= 0
             node.call('ASKING')
             retry
           end
         elsif e.message.start_with?('CLUSTERDOWN Hash slot not served')
-          update_cluster_info!
-          retry_count -= 1
+          renew_cluster_state
           retry if retry_count >= 0
         end
+
         raise
       rescue ::RedisClient::ConnectionError => e
         raise unless ::RedisClient::Cluster::ErrorIdentification.client_owns_error?(e, node)
 
-        update_cluster_info!
-
-        raise if retry_count <= 0
-
         retry_count -= 1
-        retry
+        renew_cluster_state
+        retry if retry_count >= 0
+        raise
       end
 
       def scan(*command, seed: nil, **kwargs) # rubocop:disable Metrics/AbcSize
@@ -155,11 +160,16 @@ class RedisClient
         client_index += 1 if result_cursor == 0
 
         [((result_cursor << 8) + client_index).to_s, result_keys]
+      rescue ::RedisClient::ConnectionError
+        renew_cluster_state
+        raise
       end
 
       def assign_node(command)
-        node_key = find_node_key(command)
-        find_node(node_key)
+        handle_node_reload_error do
+          node_key = find_node_key(command)
+          @node.find_by(node_key)
+        end
       end
 
       def find_node_key_by_key(key, seed: nil, primary: false)
@@ -172,8 +182,10 @@ class RedisClient
       end
 
       def find_primary_node_by_slot(slot)
-        node_key = @node.find_node_key_of_primary(slot)
-        find_node(node_key)
+        handle_node_reload_error do
+          node_key = @node.find_node_key_of_primary(slot)
+          @node.find_by(node_key)
+        end
       end
 
       def find_node_key(command, seed: nil)
@@ -198,14 +210,8 @@ class RedisClient
         ::RedisClient::Cluster::KeySlotConverter.convert(key)
       end
 
-      def find_node(node_key, retry_count: 3)
-        @node.find_by(node_key)
-      rescue ::RedisClient::Cluster::Node::ReloadNeeded
-        raise ::RedisClient::Cluster::NodeMightBeDown if retry_count <= 0
-
-        update_cluster_info!
-        retry_count -= 1
-        retry
+      def find_node(node_key)
+        handle_node_reload_error { @node.find_by(node_key) }
       end
 
       def command_exists?(name)
@@ -216,35 +222,37 @@ class RedisClient
         _, slot, node_key = err_msg.split
         slot = slot.to_i
         @node.update_slot(slot, node_key)
-        find_node(node_key)
+        handle_node_reload_error { @node.find_by(node_key) }
       end
 
       def assign_asking_node(err_msg)
         _, _, node_key = err_msg.split
-        find_node(node_key)
+        handle_node_reload_error { @node.find_by(node_key) }
       end
 
       def node_keys
         @node.node_keys
       end
 
+      def renew_cluster_state
+        @node.reload!
+      end
+
       def close
         @node.each(&:close)
       end
 
       private
 
-      def send_wait_command(method, command, args, retry_count: 3, &block) # rubocop:disable Metrics/AbcSize
+      def send_wait_command(method, command, args, retry_count: 1, &block) # rubocop:disable Metrics/AbcSize
         @node.call_primaries(method, command, args).select { |r| r.is_a?(Integer) }.sum.then(&TSF.call(block))
       rescue ::RedisClient::Cluster::ErrorCollection => e
         raise if e.errors.any?(::RedisClient::CircuitBreaker::OpenCircuitError)
         raise if retry_count <= 0
-        raise if e.errors.values.none? do |err|
-          err.message.include?('WAIT cannot be used with replica instances')
-        end
+        raise if e.errors.values.none? { |err| err.message.include?('WAIT cannot be used with replica instances') }
 
-        update_cluster_info!
         retry_count -= 1
+        renew_cluster_state
         retry
       end
 
@@ -273,7 +281,7 @@ class RedisClient
         end
       end
 
-      def send_cluster_command(method, command, args, &block)
+      def send_cluster_command(method, command, args, &block) # rubocop:disable Metrics/AbcSize
         case subcommand = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_subcommand(command)
         when 'addslots', 'delslots', 'failover', 'forget', 'meet', 'replicate',
              'reset', 'set-config-epoch', 'setslot'
@@ -282,7 +290,10 @@ class RedisClient
         when 'getkeysinslot'
           raise ArgumentError, command.join(' ') if command.size != 4
 
-          find_node(@node.find_node_key_of_replica(command[2])).public_send(method, *args, command, &block)
+          handle_node_reload_error do
+            node_key = @node.find_node_key_of_replica(command[2])
+            @node.find_by(node_key).public_send(method, *args, command, &block)
+          end
         else assign_node(command).public_send(method, *args, command, &block)
         end
       end
@@ -335,6 +346,8 @@ class RedisClient
         'del' => ['del', 1].freeze
       }.freeze
 
+      private_constant :MULTIPLE_KEYS_COMMAND_TO_SINGLE
+
       def send_multiple_keys_command(cmd, method, command, args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         # This implementation is prioritized performance rather than readability or so.
         single_key_cmd, keys_step = MULTIPLE_KEYS_COMMAND_TO_SINGLE.fetch(cmd)
@@ -367,8 +380,14 @@ class RedisClient
         block_given? ? yield(result) : result
       end
 
-      def update_cluster_info!
-        @node.reload!
+      def handle_node_reload_error(retry_count: 1)
+        yield
+      rescue ::RedisClient::Cluster::Node::ReloadNeeded
+        raise ::RedisClient::Cluster::NodeMightBeDown if retry_count <= 0
+
+        retry_count -= 1
+        renew_cluster_state
+        retry
       end
     end
   end

data/lib/redis_client/cluster/transaction.rb

@@ -7,9 +7,12 @@ class RedisClient
   class Cluster
     class Transaction
       ConsistencyError = Class.new(::RedisClient::Error)
+
       MAX_REDIRECTION = 2
       EMPTY_ARRAY = [].freeze
 
+      private_constant :MAX_REDIRECTION, :EMPTY_ARRAY
+
       def initialize(router, command_builder, node: nil, slot: nil, asking: false)
         @router = router
         @command_builder = command_builder
@@ -119,7 +122,7 @@ class RedisClient
         end
       end
 
-      def send_pipeline(client, redirect:)
+      def send_pipeline(client, redirect:) # rubocop:disable Metrics/AbcSize
         replies = client.ensure_connected_cluster_scoped(retryable: @retryable) do |connection|
           commands = @pipeline._commands
           client.middlewares.call_pipelined(commands, client.config) do
@@ -135,6 +138,9 @@ class RedisClient
         return if replies.last.nil?
 
         coerce_results!(replies.last)
+      rescue ::RedisClient::ConnectionError
+        @router.renew_cluster_state if @watching_slot.nil?
+        raise
       end
 
       def coerce_results!(results, offset: 1)
@@ -164,6 +170,9 @@ class RedisClient
         elsif err.message.start_with?('ASK')
           node = @router.assign_asking_node(err.message)
           try_asking(node) ? send_transaction(node, redirect: redirect - 1) : err
+        elsif err.message.start_with?('CLUSTERDOWN Hash slot not served')
+          @router.renew_cluster_state if @watching_slot.nil?
+          raise err
         else
           raise err
         end

data/lib/redis_client/cluster.rb

@@ -11,6 +11,8 @@ class RedisClient
   class Cluster
     ZERO_CURSOR_FOR_SCAN = '0'
 
+    private_constant :ZERO_CURSOR_FOR_SCAN
+
     attr_reader :config
 
     def initialize(config, pool: nil, concurrency: nil, **kwargs)

data/lib/redis_client/cluster_config.rb

@@ -20,13 +20,19 @@ class RedisClient
     MAX_WORKERS = Integer(ENV.fetch('REDIS_CLIENT_MAX_THREADS', 5))
     # It's used with slow queries of fetching meta data like CLUSTER NODES, COMMAND and so on.
     SLOW_COMMAND_TIMEOUT = Float(ENV.fetch('REDIS_CLIENT_SLOW_COMMAND_TIMEOUT', -1))
+    # It affects to strike a balance between load and stability in initialization or changed states.
+    MAX_STARTUP_SAMPLE = Integer(ENV.fetch('REDIS_CLIENT_MAX_STARTUP_SAMPLE', 3))
+
+    private_constant :DEFAULT_HOST, :DEFAULT_PORT, :DEFAULT_SCHEME, :SECURE_SCHEME, :DEFAULT_NODES,
+                     :VALID_SCHEMES, :VALID_NODES_KEYS, :MERGE_CONFIG_KEYS, :IGNORE_GENERIC_CONFIG_KEYS,
+                     :MAX_WORKERS, :SLOW_COMMAND_TIMEOUT, :MAX_STARTUP_SAMPLE
 
     InvalidClientConfigError = Class.new(::RedisClient::Error)
 
     attr_reader :command_builder, :client_config, :replica_affinity, :slow_command_timeout,
-                :connect_with_original_config, :startup_nodes
+                :connect_with_original_config, :startup_nodes, :max_startup_sample
 
-    def initialize(
+    def initialize( # rubocop:disable Metrics/ParameterLists
       nodes: DEFAULT_NODES,
       replica: false,
       replica_affinity: :random,
@@ -36,6 +42,7 @@ class RedisClient
       client_implementation: ::RedisClient::Cluster, # for redis gem
       slow_command_timeout: SLOW_COMMAND_TIMEOUT,
       command_builder: ::RedisClient::CommandBuilder,
+      max_startup_sample: MAX_STARTUP_SAMPLE,
       **client_config
     )
 
@@ -51,6 +58,7 @@ class RedisClient
       @connect_with_original_config = connect_with_original_config
       @client_implementation = client_implementation
       @slow_command_timeout = slow_command_timeout
+      @max_startup_sample = max_startup_sample
     end
 
     def inspect

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-05-13 00:00:00.000000000 Z
+date: 2024-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -77,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.16
 signing_key: 
 specification_version: 4
 summary: A Redis cluster client for Ruby