redis-cluster-client 0.7.10 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b591c92886bf877147317dd04695d2d22354958443f83e386b061b45b0407b28
-  data.tar.gz: 40a46369e32c60a3c165aff646d3dbd53c3ef427fef6220d4bacc17fc6a97232
+  metadata.gz: b27b124d30b25712726c2d6471fffe4fd879de2dabb2002d0654e40b1e24b90e
+  data.tar.gz: eae0cd4ff3d6ab6317f7fff7493df1da9fb4386b4fbd187619d41e0bdf891d56
 SHA512:
-  metadata.gz: 0e8eda475d22314feb84d16c2d5d75dfe714abecf2c6482a7600c012d02705110c40a0ed7717029a7e8ad154040c6cd44978ffd6b9a2c0350ec33e45d1e1b81e
-  data.tar.gz: a8fc2bb1febdac9e44c23aaab93ddce567d9ea1fe4ff09f74aa3ebac7eba56efceff44b5f13fea0284d4bec8b2677bd58dfee0eedfebe9cdc4ed9e7d4f6cb6df
+  metadata.gz: a353a42631431794e3d1d9616810ef5378930765683013cb96c8e49c010434e2f3f08995b0e48601492791b577612a9bf688dd0b186b72b0bba54e0330f24e8f
+  data.tar.gz: f87fed71fda0b9cf9ab3dde1b402f8c4b0c921c85efe8d794ef9fee7a48d143f43b829e6f2cd6ca01532f0c8c6ca8f682195ea3673aefc9ba5d342a9871a6c75

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

@@ -313,9 +313,11 @@ class RedisClient
 
       # for redis-rb
       def send_watch_command(command)
-        ::RedisClient::Cluster::OptimisticLocking.new(self).watch(command[1..]) do |c, slot|
+        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, 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.10
+  version: 0.8.0
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-20 00:00:00.000000000 Z
+date: 2024-04-12 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