redis-cluster-client 0.7.11 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84e0a41582397ffdb79a5bad130f849ef3980dd00e602908c76006224e0663ed
-  data.tar.gz: e987165bfcbbdda0ef5c122a88d36c21ebf7ade0ea6f8009203b7bb8a87a2736
+  metadata.gz: 53d1591b89859ddc92dc6ca349ff211d0a6ac14c68ad72e920cc9725d82587b4
+  data.tar.gz: fcfeceffddc9201f8b8c5d6999d3e7aa8581c9f24f0d823b029a5561ef82887d
 SHA512:
-  metadata.gz: 2bd0e3de07bad00ea4ade79f397c75ee4e9b244655bd3f5bb6ecfec9a25ca0c3893fb9fa135eb16d01b0c1b7747375c4e5d37c3683befe47fcc34bbd0c34d619
-  data.tar.gz: 5f84cd60815f57769ba3750f6f4e644ed4cdd933b5318ea4aa5ae725711c8ed87ea14e2ef252c92c66589645131e7a0a6381b2b8411fa56475768d2326cc69e6
+  metadata.gz: d51aefc48e64ef0cdbded8b5c8e4b005dcfd103d9fa4ecfa0dff1d9aa4fed5d6f6aefd4dca4ac53e89867b5276812bc6c7f8cf3cb41c1184bd9d8f19ea601471
+  data.tar.gz: 548da631726b4881f0a7712186f656733cb6941aef9ca3415498a6f048f59170fb74a59c30da68d655cee5e5773732d9d781c489f6cda2f0c92a341f1b28b892

data/lib/redis_client/cluster/error_identification.rb

@@ -4,7 +4,13 @@ class RedisClient
   class Cluster
     module ErrorIdentification
       def self.client_owns_error?(err, client)
-        err.is_a?(TaggedError) && err.from?(client)
+        return true unless identifiable?(err)
+
+        err.from?(client)
+      end
+
+      def self.identifiable?(err)
+        err.is_a?(TaggedError)
       end
 
       module TaggedError

data/lib/redis_client/cluster/node.rb

@@ -2,7 +2,6 @@
 
 require 'redis_client'
 require 'redis_client/config'
-require 'redis_client/cluster/error_identification'
 require 'redis_client/cluster/errors'
 require 'redis_client/cluster/node/primary_only'
 require 'redis_client/cluster/node/random_replica'
@@ -79,11 +78,9 @@ class RedisClient
       end
 
       class Config < ::RedisClient::Config
-        def initialize(scale_read: false, middlewares: nil, **kwargs)
+        def initialize(scale_read: false, **kwargs)
           @scale_read = scale_read
-          middlewares ||= []
-          middlewares.unshift ErrorIdentification::Middleware
-          super(middlewares: middlewares, **kwargs)
+          super(**kwargs)
         end
 
         private
@@ -217,10 +214,6 @@ class RedisClient
         end
       end
 
-      def owns_error?(err)
-        any? { |c| ErrorIdentification.client_owns_error?(err, c) }
-      end
-
       private
 
       def make_topology_class(with_replica, replica_affinity)

data/lib/redis_client/cluster/optimistic_locking.rb

@@ -8,26 +8,56 @@ class RedisClient
     class OptimisticLocking
       def initialize(router)
         @router = router
+        @asking = false
       end
 
       def watch(keys)
         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)
-        @router.handle_redirection(node, retry_count: 1) do |nd|
+        handle_redirection(node, retry_count: 1) do |nd|
           nd.with do |c|
-            c.call('WATCH', *keys)
-            yield(c, slot)
-          rescue StandardError
-            c.call('UNWATCH')
-            raise
+            c.ensure_connected_cluster_scoped(retryable: false) do
+              c.call('ASKING') if @asking
+              c.call('WATCH', *keys)
+              begin
+                yield(c, slot, @asking)
+              rescue ::RedisClient::ConnectionError
+                # No need to unwatch on a connection error.
+                raise
+              rescue StandardError
+                c.call('UNWATCH')
+                raise
+              end
+            end
           end
         end
       end
 
       private
 
+      def handle_redirection(node, retry_count: 1, &blk)
+        @router.handle_redirection(node, retry_count: retry_count) do |nd|
+          handle_asking_once(nd, &blk)
+        end
+      end
+
+      def handle_asking_once(node)
+        yield node
+      rescue ::RedisClient::CommandError => e
+        raise unless ErrorIdentification.client_owns_error?(e, node)
+        raise unless e.message.start_with?('ASK')
+
+        node = @router.assign_asking_node(e.message)
+        @asking = true
+        yield node
+      ensure
+        @asking = false
+      end
+
       def find_slot(keys)
         return if keys.empty?
         return if keys.any? { |k| k.nil? || k.empty? }

data/lib/redis_client/cluster/pipeline.rb

@@ -12,7 +12,7 @@ class RedisClient
       class Extended < ::RedisClient::Pipeline
         attr_reader :outer_indices
 
-        def initialize(command_builder)
+        def initialize(...)
           super
           @outer_indices = nil
         end
@@ -50,14 +50,14 @@ class RedisClient
       end
 
       ::RedisClient::ConnectionMixin.module_eval do
-        def call_pipelined_aware_of_redirection(commands, timeouts) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def call_pipelined_aware_of_redirection(commands, timeouts, exception:) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           size = commands.size
           results = Array.new(commands.size)
           @pending_reads += size
           write_multi(commands)
 
           redirection_indices = nil
-          exception = nil
+          first_exception = nil
           size.times do |index|
             timeout = timeouts && timeouts[index]
             result = read(timeout)
@@ -67,14 +67,14 @@ class RedisClient
               if result.is_a?(::RedisClient::CommandError) && result.message.start_with?('MOVED', 'ASK')
                 redirection_indices ||= []
                 redirection_indices << index
-              else
-                exception ||= result
+              elsif exception
+                first_exception ||= result
               end
             end
             results[index] = result
           end
 
-          raise exception if exception
+          raise first_exception if exception && first_exception
           return results if redirection_indices.nil?
 
           err = ::RedisClient::Cluster::Pipeline::RedirectionNeeded.new
@@ -98,10 +98,11 @@ class RedisClient
         attr_accessor :replies, :indices
       end
 
-      def initialize(router, command_builder, concurrent_worker, seed: Random.new_seed)
+      def initialize(router, command_builder, concurrent_worker, exception:, seed: Random.new_seed)
         @router = router
         @command_builder = command_builder
         @concurrent_worker = concurrent_worker
+        @exception = exception
         @seed = seed
         @pipelines = nil
         @size = 0
@@ -212,7 +213,7 @@ class RedisClient
         results = client.ensure_connected_cluster_scoped(retryable: pipeline._retryable?) do |connection|
           commands = pipeline._commands
           client.middlewares.call_pipelined(commands, client.config) do
-            connection.call_pipelined_aware_of_redirection(commands, pipeline._timeouts)
+            connection.call_pipelined_aware_of_redirection(commands, pipeline._timeouts, exception: @exception)
           end
         end
 
@@ -224,15 +225,21 @@ class RedisClient
 
         if err.message.start_with?('MOVED')
           node = @router.assign_redirection_node(err.message)
-          redirect_command(node, pipeline, inner_index)
+          try_redirection(node, pipeline, inner_index)
         elsif err.message.start_with?('ASK')
           node = @router.assign_asking_node(err.message)
-          try_asking(node) ? redirect_command(node, pipeline, inner_index) : err
+          try_asking(node) ? try_redirection(node, pipeline, inner_index) : err
         else
           err
         end
       end
 
+      def try_redirection(node, pipeline, inner_index)
+        redirect_command(node, pipeline, inner_index)
+      rescue StandardError => e
+        @exception ? raise : e
+      end
+
       def redirect_command(node, pipeline, inner_index)
         method = pipeline.get_callee_method(inner_index)
         command = pipeline.get_command(inner_index)

data/lib/redis_client/cluster/router.rb

@@ -10,6 +10,7 @@ require 'redis_client/cluster/node_key'
 require 'redis_client/cluster/normalized_cmd_name'
 require 'redis_client/cluster/transaction'
 require 'redis_client/cluster/optimistic_locking'
+require 'redis_client/cluster/error_identification'
 
 class RedisClient
   class Cluster
@@ -68,7 +69,9 @@ class RedisClient
         raise if e.errors.any?(::RedisClient::CircuitBreaker::OpenCircuitError)
 
         update_cluster_info! if e.errors.values.any? do |err|
-          @node.owns_error?(err) && err.message.start_with?('CLUSTERDOWN Hash slot not served')
+          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')
         end
 
         raise
@@ -97,7 +100,7 @@ class RedisClient
       rescue ::RedisClient::CircuitBreaker::OpenCircuitError
         raise
       rescue ::RedisClient::CommandError => e
-        raise unless ErrorIdentification.client_owns_error?(e, node)
+        raise unless ::RedisClient::Cluster::ErrorIdentification.client_owns_error?(e, node)
 
         if e.message.start_with?('MOVED')
           node = assign_redirection_node(e.message)
@@ -117,7 +120,7 @@ class RedisClient
         end
         raise
       rescue ::RedisClient::ConnectionError => e
-        raise unless ErrorIdentification.client_owns_error?(e, node)
+        raise unless ::RedisClient::Cluster::ErrorIdentification.client_owns_error?(e, node)
 
         update_cluster_info!
 
@@ -315,9 +318,9 @@ class RedisClient
       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?
 
-        ::RedisClient::Cluster::OptimisticLocking.new(self).watch(command[1..]) do |c, slot|
+        ::RedisClient::Cluster::OptimisticLocking.new(self).watch(command[1..]) do |c, slot, asking|
           transaction = ::RedisClient::Cluster::Transaction.new(
-            self, @command_builder, node: c, slot: slot
+            self, @command_builder, node: c, slot: slot, asking: asking
           )
           yield transaction
           transaction.execute

data/lib/redis_client/cluster/transaction.rb

@@ -9,7 +9,7 @@ class RedisClient
       ConsistencyError = Class.new(::RedisClient::Error)
       MAX_REDIRECTION = 2
 
-      def initialize(router, command_builder, node: nil, slot: nil)
+      def initialize(router, command_builder, node: nil, slot: nil, asking: false)
         @router = router
         @command_builder = command_builder
         @retryable = true
@@ -18,6 +18,7 @@ class RedisClient
         @node = node
         prepare_tx unless @node.nil?
         @watching_slot = slot
+        @asking = asking
       end
 
       def call(*command, **kwargs, &block)
@@ -93,7 +94,11 @@ class RedisClient
 
       def settle
         @pipeline.call('EXEC')
-        send_transaction(@node, redirect: MAX_REDIRECTION)
+        # If we needed ASKING on the watch, we need ASKING on the multi as well.
+        @node.call('ASKING') if @asking
+        # Don't handle redirections at this level if we're in a watch (the watcher handles redirections
+        # at the whole-transaction level.)
+        send_transaction(@node, redirect: !!@watching_slot ? 0 : MAX_REDIRECTION)
       end
 
       def send_transaction(client, redirect:)
@@ -110,7 +115,8 @@ class RedisClient
           client.middlewares.call_pipelined(commands, client.config) do
             connection.call_pipelined(commands, nil)
           rescue ::RedisClient::CommandError => e
-            return handle_command_error!(commands, e, redirect: redirect) unless redirect.zero?
+            ensure_the_same_slot!(commands)
+            return handle_command_error!(e, redirect: redirect) unless redirect.zero?
 
             raise
           end
@@ -139,15 +145,13 @@ class RedisClient
         results
       end
 
-      def handle_command_error!(commands, err, redirect:) # rubocop:disable Metrics/AbcSize
+      def handle_command_error!(err, redirect:) # rubocop:disable Metrics/AbcSize
         if err.message.start_with?('CROSSSLOT')
           raise ConsistencyError, "#{err.message}: #{err.command}"
         elsif err.message.start_with?('MOVED')
-          ensure_the_same_slot!(commands)
           node = @router.assign_redirection_node(err.message)
           send_transaction(node, redirect: redirect - 1)
         elsif err.message.start_with?('ASK')
-          ensure_the_same_slot!(commands)
           node = @router.assign_asking_node(err.message)
           try_asking(node) ? send_transaction(node, redirect: redirect - 1) : err
         else

data/lib/redis_client/cluster.rb

@@ -82,9 +82,16 @@ class RedisClient
       @router.try_delegate(node, :zscan, key, *args, **kwargs, &block)
     end
 
-    def pipelined
+    def pipelined(exception: true)
       seed = @config.use_replica? && @config.replica_affinity == :random ? nil : Random.new_seed
-      pipeline = ::RedisClient::Cluster::Pipeline.new(@router, @command_builder, @concurrent_worker, seed: seed)
+      pipeline = ::RedisClient::Cluster::Pipeline.new(
+        @router,
+        @command_builder,
+        @concurrent_worker,
+        exception: exception,
+        seed: seed
+      )
+
       yield pipeline
       return [] if pipeline.empty?
 
@@ -98,9 +105,9 @@ class RedisClient
         return transaction.execute
       end
 
-      ::RedisClient::Cluster::OptimisticLocking.new(@router).watch(watch) do |c, slot|
+      ::RedisClient::Cluster::OptimisticLocking.new(@router).watch(watch) do |c, slot, asking|
         transaction = ::RedisClient::Cluster::Transaction.new(
-          @router, @command_builder, node: c, slot: slot
+          @router, @command_builder, node: c, slot: slot, asking: asking
         )
         yield transaction
         transaction.execute

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.7.11
+  version: 0.8.1
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-20 00:00:00.000000000 Z
+date: 2024-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: '0.22'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: '0.22'
 description: 
 email:
 - proxy0721@gmail.com