redis-cluster-client 0.11.5 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 175bb2bf9b82d2b1d0b95e8d7e3e74e3952165f2edea957303f8b16716a17273
-  data.tar.gz: 1e094b0d0ae859cb4d77cc872203c21f2f408b739a748d518fd60ca7c33e7451
+  metadata.gz: 2465b865cd79c78cca3a1e7e3950989cce94f6675b0497763e03e261d3fa9c6f
+  data.tar.gz: df607279a58171aca75835b767f3bf5965256db0fcb7b540bfcb3a8f302eb638
 SHA512:
-  metadata.gz: 8b8a13a4df4b5d96da3bcb618bada62d5882fb688b7fd7a9d618c6733a44913af24222c48d40f4db0a316d58b00aa608de99467114dac22711eb7b421f7e2e8a
-  data.tar.gz: 2c3ebd371f3a23388e6600192a6403c5f97a90f7a7c06bab747310fa729d8be8f9d7d793763a8e7829f2e4699893d76964a96bd0ea40e727d0bdb499e1ef9f67
+  metadata.gz: bfb9031660b642bb14768dc8edc66fb15073be9ca23ddc061d279a351c497a83ff8a3aad21903e2d0a37aa6824da35761188ba4dc1fe8ae0182b54584edaa5e5
+  data.tar.gz: 9fab63d0595bfb7dac85a07c255a41573ab8d44598605919fd4182e99cf3da585bf931abe63da9e2f470815c6ef0d34ab24a5b7f2de346ba29870fb894c556ee

data/lib/redis_client/cluster/command.rb

@@ -25,7 +25,7 @@ class RedisClient
       )
 
       class << self
-        def load(nodes, slow_command_timeout: -1)
+        def load(nodes, slow_command_timeout: -1) # rubocop:disable Metrics/AbcSize
           cmd = errors = nil
 
           nodes&.each do |node|
@@ -43,7 +43,7 @@ class RedisClient
 
           return cmd unless cmd.nil?
 
-          raise ::RedisClient::Cluster::InitialSetupError, errors
+          raise ::RedisClient::Cluster::InitialSetupError.from_errors(errors)
         end
 
         private

data/lib/redis_client/cluster/errors.rb

@@ -4,51 +4,60 @@ require 'redis_client'
 
 class RedisClient
   class Cluster
+    class Error < ::RedisClient::Error
+      def with_config(config)
+        @config = config
+        self
+      end
+    end
+
     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)
+    class InitialSetupError < Error
+      def self.from_errors(errors)
         msg = ERR_ARG_NORMALIZATION.call(errors).map(&:message).uniq.join(',')
-        super("Redis client could not fetch cluster information: #{msg}")
+        new("Redis client could not fetch cluster information: #{msg}")
       end
     end
 
-    class OrchestrationCommandNotSupported < ::RedisClient::Error
-      def initialize(command)
+    class OrchestrationCommandNotSupported < Error
+      def self.from_command(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-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)
+        new(msg)
       end
     end
 
-    class ErrorCollection < ::RedisClient::Error
+    class ErrorCollection < Error
       attr_reader :errors
 
-      def initialize(errors)
-        @errors = {}
+      def self.with_errors(errors)
         if !errors.is_a?(Hash) || errors.empty?
-          super(errors.to_s)
-          return
+          new(errors.to_s).with_errors({})
+        else
+          messages = errors.map { |node_key, error| "#{node_key}: (#{error.class}) #{error.message}" }
+          new(messages.join(', ')).with_errors(errors)
         end
+      end
 
-        @errors = errors
-        messages = @errors.map { |node_key, error| "#{node_key}: (#{error.class}) #{error.message}" }
-        super(messages.join(', '))
+      def with_errors(errors)
+        @errors = errors if @errors.nil?
+        self
       end
     end
 
-    class AmbiguousNodeError < ::RedisClient::Error
-      def initialize(command)
-        super("Cluster client doesn't know which node the #{command} command should be sent to.")
+    class AmbiguousNodeError < Error
+      def self.from_command(command)
+        new("Cluster client doesn't know which node the #{command} command should be sent to.")
       end
     end
 
-    class NodeMightBeDown < ::RedisClient::Error
+    class NodeMightBeDown < Error
       def initialize(_ = '')
         super(
           'The client is trying to fetch the latest cluster state ' \

data/lib/redis_client/cluster/node.rb

@@ -28,7 +28,7 @@ class RedisClient
       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)
+      ReloadNeeded = Class.new(::RedisClient::Cluster::Error)
 
       Info = Struct.new(
         'RedisClusterNode',
@@ -148,7 +148,7 @@ class RedisClient
 
         raise ReloadNeeded if errors.values.any?(::RedisClient::ConnectionError)
 
-        raise ::RedisClient::Cluster::ErrorCollection, errors
+        raise ::RedisClient::Cluster::ErrorCollection.with_errors(errors)
       end
 
       def clients_for_scanning(seed: nil)
@@ -267,7 +267,7 @@ class RedisClient
         result_values, errors = call_multiple_nodes(clients, method, command, args, &block)
         return result_values if errors.nil? || errors.empty?
 
-        raise ::RedisClient::Cluster::ErrorCollection, errors
+        raise ::RedisClient::Cluster::ErrorCollection.with_errors(errors)
       end
 
       def try_map(clients, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
@@ -334,7 +334,7 @@ class RedisClient
 
         work_group.close
 
-        raise ::RedisClient::Cluster::InitialSetupError, errors if node_info_list.nil?
+        raise ::RedisClient::Cluster::InitialSetupError.from_errors(errors) if node_info_list.nil?
 
         grouped = node_info_list.compact.group_by do |info_list|
           info_list.sort_by!(&:id)

data/lib/redis_client/cluster/optimistic_locking.rb

@@ -15,10 +15,7 @@ class RedisClient
         slot = find_slot(keys)
         raise ::RedisClient::Cluster::Transaction::ConsistencyError, "unsafe watch: #{keys.join(' ')}" if slot.nil?
 
-        # We have not yet selected a node for this transaction, initially, which means we can handle
-        # redirections freely initially (i.e. for the first WATCH call)
-        node = @router.find_primary_node_by_slot(slot)
-        handle_redirection(node, retry_count: 1) do |nd|
+        handle_redirection(slot, retry_count: 1) do |nd|
           nd.with do |c|
             c.ensure_connected_cluster_scoped(retryable: false) do
               c.call('ASKING') if @asking
@@ -45,10 +42,22 @@ class RedisClient
 
       private
 
-      def handle_redirection(node, retry_count: 1, &blk)
-        @router.handle_redirection(node, retry_count: retry_count) do |nd|
+      def handle_redirection(slot, retry_count: 1, &blk)
+        # We have not yet selected a node for this transaction, initially, which means we can handle
+        # redirections freely initially (i.e. for the first WATCH call)
+        node = @router.find_primary_node_by_slot(slot)
+        times_block_executed = 0
+        @router.handle_redirection(node, nil, retry_count: retry_count) do |nd|
+          times_block_executed += 1
           handle_asking_once(nd, &blk)
         end
+      rescue ::RedisClient::ConnectionError
+        # Deduct the number of retries that happened _inside_ router#handle_redirection from our remaining
+        # _external_ retries. Always deduct at least one in case handle_redirection raises without trying the block.
+        retry_count -= [times_block_executed, 1].min
+        raise if retry_count < 0
+
+        retry
       end
 
       def handle_asking_once(node)

data/lib/redis_client/cluster/pipeline.rb

@@ -108,13 +108,13 @@ class RedisClient
         end
       end
 
-      ReplySizeError = Class.new(::RedisClient::Error)
+      ReplySizeError = Class.new(::RedisClient::Cluster::Error)
 
-      class StaleClusterState < ::RedisClient::Error
+      class StaleClusterState < ::RedisClient::Cluster::Error
         attr_accessor :replies, :first_exception
       end
 
-      class RedirectionNeeded < ::RedisClient::Error
+      class RedirectionNeeded < ::RedisClient::Cluster::Error
         attr_accessor :replies, :indices, :first_exception
       end
 
@@ -204,7 +204,7 @@ class RedisClient
 
         work_group.close
         @router.renew_cluster_state if cluster_state_errors
-        raise ::RedisClient::Cluster::ErrorCollection, errors unless errors.nil?
+        raise ::RedisClient::Cluster::ErrorCollection.with_errors(errors).with_config(@router.config) unless errors.nil?
 
         required_redirections&.each do |node_key, v|
           raise v.first_exception if v.first_exception

data/lib/redis_client/cluster/router.rb

@@ -21,10 +21,10 @@ class RedisClient
 
       private_constant :ZERO_CURSOR_FOR_SCAN, :TSF
 
+      attr_reader :config
+
       def initialize(config, concurrent_worker, pool: nil, **kwargs)
-        @config = config.dup
-        @original_config = config.dup if config.connect_with_original_config
-        @connect_with_original_config = config.connect_with_original_config
+        @config = config
         @concurrent_worker = concurrent_worker
         @pool = pool
         @client_kwargs = kwargs
@@ -32,6 +32,9 @@ class RedisClient
         @node.reload!
         @command = ::RedisClient::Cluster::Command.load(@node.replica_clients.shuffle, slow_command_timeout: config.slow_command_timeout)
         @command_builder = @config.command_builder
+      rescue ::RedisClient::Cluster::InitialSetupError => e
+        e.with_config(config)
+        raise
       end
 
       def send_command(method, command, *args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
@@ -58,9 +61,9 @@ class RedisClient
         when 'flushall', 'flushdb'
           @node.call_primaries(method, command, args).first.then(&TSF.call(block))
         when 'readonly', 'readwrite', 'shutdown'
-          raise ::RedisClient::Cluster::OrchestrationCommandNotSupported, cmd
+          raise ::RedisClient::Cluster::OrchestrationCommandNotSupported.from_command(cmd).with_config(@config)
         when 'discard', 'exec', 'multi', 'unwatch'
-          raise ::RedisClient::Cluster::AmbiguousNodeError, cmd
+          raise ::RedisClient::Cluster::AmbiguousNodeError.from_command(cmd).with_config(@config)
         else
           node = assign_node(command)
           try_send(node, method, command, args, &block)
@@ -69,7 +72,7 @@ class RedisClient
         raise
       rescue ::RedisClient::Cluster::Node::ReloadNeeded
         renew_cluster_state
-        raise ::RedisClient::Cluster::NodeMightBeDown
+        raise ::RedisClient::Cluster::NodeMightBeDown.new.with_config(@config)
       rescue ::RedisClient::ConnectionError
         renew_cluster_state
         raise
@@ -77,6 +80,7 @@ class RedisClient
         renew_cluster_state if e.message.start_with?('CLUSTERDOWN')
         raise
       rescue ::RedisClient::Cluster::ErrorCollection => e
+        e.with_config(@config)
         raise if e.errors.any?(::RedisClient::CircuitBreaker::OpenCircuitError)
 
         renew_cluster_state if e.errors.values.any? do |err|
@@ -90,7 +94,7 @@ class RedisClient
 
       # @see https://redis.io/docs/reference/cluster-spec/#redirection-and-resharding Redirection and resharding
       def try_send(node, method, command, args, retry_count: 3, &block)
-        handle_redirection(node, retry_count: retry_count) do |on_node|
+        handle_redirection(node, command, retry_count: retry_count) do |on_node|
           if args.empty?
             # prevent memory allocation for variable-length args
             on_node.public_send(method, command, &block)
@@ -101,12 +105,12 @@ class RedisClient
       end
 
       def try_delegate(node, method, *args, retry_count: 3, **kwargs, &block)
-        handle_redirection(node, retry_count: retry_count) do |on_node|
+        handle_redirection(node, nil, retry_count: retry_count) do |on_node|
           on_node.public_send(method, *args, **kwargs, &block)
         end
       end
 
-      def handle_redirection(node, retry_count:) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def handle_redirection(node, command, retry_count:) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         yield node
       rescue ::RedisClient::CircuitBreaker::OpenCircuitError
         raise
@@ -134,6 +138,17 @@ class RedisClient
 
         retry_count -= 1
         renew_cluster_state
+
+        if retry_count >= 0
+          # Find the node to use for this command - if this fails for some reason, though, re-use
+          # the old node.
+          begin
+            node = find_node(find_node_key(command)) if command
+          rescue StandardError # rubocop:disable Lint/SuppressedException
+          end
+          retry
+        end
+
         retry if retry_count >= 0
         raise
       end
@@ -178,7 +193,7 @@ class RedisClient
           node_key = primary ? @node.find_node_key_of_primary(slot) : @node.find_node_key_of_replica(slot)
           if node_key.nil?
             renew_cluster_state
-            raise ::RedisClient::Cluster::NodeMightBeDown
+            raise ::RedisClient::Cluster::NodeMightBeDown.new.with_config(@config)
           end
           node_key
         else
@@ -292,7 +307,7 @@ class RedisClient
         case subcommand = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_subcommand(command)
         when 'addslots', 'delslots', 'failover', 'forget', 'meet', 'replicate',
              'reset', 'set-config-epoch', 'setslot'
-          raise ::RedisClient::Cluster::OrchestrationCommandNotSupported, ['cluster', subcommand]
+          raise ::RedisClient::Cluster::OrchestrationCommandNotSupported.from_command(['cluster', subcommand]).with_config(@config)
         when 'saveconfig' then @node.call_all(method, command, args).first.then(&TSF.call(block))
         when 'getkeysinslot'
           raise ArgumentError, command.join(' ') if command.size != 4
@@ -336,7 +351,10 @@ class RedisClient
       end
 
       def send_watch_command(command)
-        raise ::RedisClient::Cluster::Transaction::ConsistencyError, 'A block required. And you need to use the block argument as a client for the transaction.' unless block_given?
+        unless block_given?
+          msg = 'A block required. And you need to use the block argument as a client for the transaction.'
+          raise ::RedisClient::Cluster::Transaction::ConsistencyError.new(msg).with_config(@config)
+        end
 
         ::RedisClient::Cluster::OptimisticLocking.new(self).watch(command[1..]) do |c, slot, asking|
           transaction = ::RedisClient::Cluster::Transaction.new(
@@ -390,7 +408,7 @@ class RedisClient
       def handle_node_reload_error(retry_count: 1)
         yield
       rescue ::RedisClient::Cluster::Node::ReloadNeeded
-        raise ::RedisClient::Cluster::NodeMightBeDown if retry_count <= 0
+        raise ::RedisClient::Cluster::NodeMightBeDown.new.with_config(@config) if retry_count <= 0
 
         retry_count -= 1
         renew_cluster_state

data/lib/redis_client/cluster/transaction.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 require 'redis_client'
+require 'redis_client/cluster/errors'
 require 'redis_client/cluster/pipeline'
 
 class RedisClient
   class Cluster
     class Transaction
-      ConsistencyError = Class.new(::RedisClient::Error)
+      ConsistencyError = Class.new(::RedisClient::Cluster::Error)
 
       MAX_REDIRECTION = 2
       EMPTY_ARRAY = [].freeze
@@ -67,7 +68,7 @@ class RedisClient
         @pending_commands.each(&:call)
 
         return EMPTY_ARRAY if @pipeline._empty?
-        raise ConsistencyError, "couldn't determine the node: #{@pipeline._commands}" if @node.nil?
+        raise ConsistencyError.new("couldn't determine the node: #{@pipeline._commands}").with_config(@router.config) if @node.nil?
 
         commit
       end
@@ -163,7 +164,7 @@ class RedisClient
 
       def handle_command_error!(err, redirect:) # rubocop:disable Metrics/AbcSize
         if err.message.start_with?('CROSSSLOT')
-          raise ConsistencyError, "#{err.message}: #{err.command}"
+          raise ConsistencyError.new("#{err.message}: #{err.command}").with_config(@router.config)
         elsif err.message.start_with?('MOVED')
           node = @router.assign_redirection_node(err.message)
           send_transaction(node, redirect: redirect - 1)
@@ -183,7 +184,7 @@ class RedisClient
         return if slots.size == 1 && @watching_slot.nil?
         return if slots.size == 1 && @watching_slot == slots.first
 
-        raise(ConsistencyError, "the transaction should be executed to a slot in a node: #{commands}")
+        raise ConsistencyError.new("the transaction should be executed to a slot in a node: #{commands}").with_config(@router.config)
       end
 
       def try_asking(node)

data/lib/redis_client/cluster_config.rb

@@ -3,6 +3,7 @@
 require 'uri'
 require 'redis_client'
 require 'redis_client/cluster'
+require 'redis_client/cluster/errors'
 require 'redis_client/cluster/node_key'
 require 'redis_client/command_builder'
 
@@ -27,10 +28,10 @@ class RedisClient
                      :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)
+    InvalidClientConfigError = Class.new(::RedisClient::Cluster::Error)
 
     attr_reader :command_builder, :client_config, :replica_affinity, :slow_command_timeout,
-                :connect_with_original_config, :startup_nodes, :max_startup_sample
+                :connect_with_original_config, :startup_nodes, :max_startup_sample, :id
 
     def initialize( # rubocop:disable Metrics/ParameterLists
       nodes: DEFAULT_NODES,
@@ -59,6 +60,7 @@ class RedisClient
       @client_implementation = client_implementation
       @slow_command_timeout = slow_command_timeout
       @max_startup_sample = max_startup_sample
+      @id = client_config[:id]
     end
 
     def inspect
@@ -92,6 +94,18 @@ class RedisClient
       augment_client_config(config)
     end
 
+    def resolved?
+      true
+    end
+
+    def sentinel?
+      false
+    end
+
+    def server_url
+      nil
+    end
+
     private
 
     def merge_concurrency_option(option)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.11.5
+  version: 0.12.0
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-13 00:00:00.000000000 Z
+date: 2024-11-14 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.16
+rubygems_version: 3.5.22
 signing_key: 
 specification_version: 4
 summary: A Redis cluster client for Ruby