redis-cluster-client 0.7.6 → 0.7.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 071a90a4437e12104fba1359e1a88fd64a0aa253f53ec1fdfd5c8b1fa62c63a5
-  data.tar.gz: 773243dc28547cc114730cbef7f0f971dd7bb178d4ea9a8cb2e8c4924f99bf40
+  metadata.gz: 41d87ce45a108ff8ec7d3c17805276d5ba7df11d577de3f7d6b1176bdd297ed0
+  data.tar.gz: 7118539907bb755225ba908cf160ad8af73aeb5204820682ca3fc3a67813f3cb
 SHA512:
-  metadata.gz: d345690443bc35cf19935ae9e886e0833bee49b772f21abdfb4752629b7c436100e6a367b730055fbd155d59924cfd4d76ad3df2ee1a0ed3aff65f097a82a208
-  data.tar.gz: d76e747b3eec56184f253f40f82599f492338fe86d4d3c3d30e9cda22df087e6817673b7bf9f02c07192b77322efd7d204ff60ced77be7fe2e8764cf9d104f63
+  metadata.gz: 96e3c0f9c2860002642e079b756065e32f04891cd793dce9efcb74bb87a13683b14fee13c039693d99599549fee7ace68d54561b8c730d5e9eb7bb937a82c57d
+  data.tar.gz: 2e512b774b5778e3f7a2a3557bb45d97971d209c787494a19d81e0d8146f5d51bbef7940f37fa38f7587e1037185e23fa27ca8d48a46225ced6640be8425198e

data/lib/redis_client/cluster/node_key.rb

@@ -31,6 +31,10 @@ class RedisClient
       def build_from_host_port(host, port)
         "#{host}#{DELIMITER}#{port}"
       end
+
+      def build_from_client(client)
+        "#{client.config.host}#{DELIMITER}#{client.config.port}"
+      end
     end
   end
 end

data/lib/redis_client/cluster/optimistic_locking.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'redis_client'
+require 'redis_client/cluster/key_slot_converter'
+require 'redis_client/cluster/transaction'
+
+class RedisClient
+  class Cluster
+    class OptimisticLocking
+      def initialize(router)
+        @router = router
+      end
+
+      def watch(keys)
+        ensure_safe_keys(keys)
+        node = find_node(keys)
+        cnt = 0 # We assume redirects occurred when incrementing it.
+
+        @router.handle_redirection(node, retry_count: 1) do |nd|
+          cnt += 1
+          nd.with do |c|
+            c.call('WATCH', *keys)
+            reply = yield(c, cnt > 1)
+            c.call('UNWATCH')
+            reply
+          end
+        end
+      end
+
+      private
+
+      def ensure_safe_keys(keys)
+        return if safe?(keys)
+
+        raise ::RedisClient::Cluster::Transaction::ConsistencyError, "unsafe watch: #{keys.join(' ')}"
+      end
+
+      def safe?(keys)
+        return false if keys.empty?
+
+        slots = keys.map do |k|
+          return false if k.nil? || k.empty?
+
+          ::RedisClient::Cluster::KeySlotConverter.convert(k)
+        end
+
+        slots.uniq.size == 1
+      end
+
+      def find_node(keys)
+        node_key = @router.find_primary_node_key(['WATCH', *keys])
+        return @router.find_node(node_key) unless node_key.nil?
+
+        raise ::RedisClient::Cluster::Transaction::ConsistencyError, "couldn't determine the node"
+      end
+    end
+  end
+end

data/lib/redis_client/cluster/transaction.rb

@@ -2,21 +2,23 @@
 
 require 'redis_client'
 require 'redis_client/cluster/pipeline'
-require 'redis_client/cluster/key_slot_converter'
+require 'redis_client/cluster/node_key'
 
 class RedisClient
   class Cluster
     class Transaction
       ConsistencyError = Class.new(::RedisClient::Error)
+      MAX_REDIRECTION = 2
 
-      def initialize(router, command_builder, watch)
+      def initialize(router, command_builder, node: nil, resharding: false)
         @router = router
         @command_builder = command_builder
-        @watch = watch
         @retryable = true
         @pipeline = ::RedisClient::Pipeline.new(@command_builder)
-        @buffer = []
-        @node = nil
+        @pending_commands = []
+        @node = node
+        prepare_tx unless @node.nil?
+        @resharding_state = resharding
       end
 
       def call(*command, **kwargs, &block)
@@ -24,7 +26,7 @@ class RedisClient
         if prepare(command)
           @pipeline.call_v(command, &block)
         else
-          @buffer << -> { @pipeline.call_v(command, &block) }
+          defer { @pipeline.call_v(command, &block) }
         end
       end
 
@@ -33,7 +35,7 @@ class RedisClient
         if prepare(command)
           @pipeline.call_v(command, &block)
         else
-          @buffer << -> { @pipeline.call_v(command, &block) }
+          defer { @pipeline.call_v(command, &block) }
         end
       end
 
@@ -43,7 +45,7 @@ class RedisClient
         if prepare(command)
           @pipeline.call_once_v(command, &block)
         else
-          @buffer << -> { @pipeline.call_once_v(command, &block) }
+          defer { @pipeline.call_once_v(command, &block) }
         end
       end
 
@@ -53,39 +55,24 @@ class RedisClient
         if prepare(command)
           @pipeline.call_once_v(command, &block)
         else
-          @buffer << -> { @pipeline.call_once_v(command, &block) }
+          defer { @pipeline.call_once_v(command, &block) }
         end
       end
 
       def execute
-        @buffer.each(&:call)
+        @pending_commands.each(&:call)
 
         raise ArgumentError, 'empty transaction' if @pipeline._empty?
         raise ConsistencyError, "couldn't determine the node: #{@pipeline._commands}" if @node.nil?
-        raise ConsistencyError, "unsafe watch: #{@watch.join(' ')}" unless safe_watch?
 
         settle
       end
 
       private
 
-      def watch?
-        !@watch.nil? && !@watch.empty?
-      end
-
-      def safe_watch?
-        return true unless watch?
-        return false if @node.nil?
-
-        slots = @watch.map do |k|
-          return false if k.nil? || k.empty?
-
-          ::RedisClient::Cluster::KeySlotConverter.convert(k)
-        end
-
-        return false if slots.uniq.size != 1
-
-        @router.find_primary_node_by_slot(slots.first) == @node
+      def defer(&block)
+        @pending_commands << block
+        nil
       end
 
       def prepare(command)
@@ -95,17 +82,19 @@ class RedisClient
         return false if node_key.nil?
 
         @node = @router.find_node(node_key)
-        @pipeline.call('WATCH', *@watch) if watch?
-        @pipeline.call('MULTI')
-        @buffer.each(&:call)
-        @buffer.clear
+        prepare_tx
         true
       end
 
+      def prepare_tx
+        @pipeline.call('MULTI')
+        @pending_commands.each(&:call)
+        @pending_commands.clear
+      end
+
       def settle
         @pipeline.call('EXEC')
-        @pipeline.call('UNWATCH') if watch?
-        send_transaction(@node, redirect: true)
+        send_transaction(@node, redirect: MAX_REDIRECTION)
       end
 
       def send_transaction(client, redirect:)
@@ -122,17 +111,18 @@ 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) if redirect
+            return handle_command_error!(client, commands, e, redirect: redirect) unless redirect.zero?
 
             raise
           end
         end
 
-        offset = watch? ? 2 : 1
-        coerce_results!(replies[-offset], offset)
+        return if replies.last.nil?
+
+        coerce_results!(replies.last)
       end
 
-      def coerce_results!(results, offset)
+      def coerce_results!(results, offset: 1)
         results.each_with_index do |result, index|
           if result.is_a?(::RedisClient::CommandError)
             result._set_command(@pipeline._commands[index + offset])
@@ -150,39 +140,30 @@ class RedisClient
         results
       end
 
-      def handle_command_error!(commands, err)
+      def handle_command_error!(client, commands, err, redirect:) # rubocop:disable Metrics/AbcSize
         if err.message.start_with?('CROSSSLOT')
           raise ConsistencyError, "#{err.message}: #{err.command}"
-        elsif err.message.start_with?('MOVED', 'ASK')
-          ensure_the_same_node!(commands)
-          handle_redirection(err)
+        elsif err.message.start_with?('MOVED')
+          ensure_the_same_node!(client, commands)
+          node = @router.assign_redirection_node(err.message)
+          send_transaction(node, redirect: redirect - 1)
+        elsif err.message.start_with?('ASK')
+          ensure_the_same_node!(client, commands)
+          node = @router.assign_asking_node(err.message)
+          try_asking(node) ? send_transaction(node, redirect: redirect - 1) : err
         else
           raise err
         end
       end
 
-      def ensure_the_same_node!(commands)
-        commands.each do |command|
-          node_key = @router.find_primary_node_key(command)
-          next if node_key.nil?
+      def ensure_the_same_node!(client, commands)
+        node_keys = commands.map { |command| @router.find_primary_node_key(command) }.compact.uniq
+        expected_node_key = ::RedisClient::Cluster::NodeKey.build_from_client(client)
 
-          node = @router.find_node(node_key)
-          next if @node == node
-
-          raise ConsistencyError, "the transaction should be executed to a slot in a node: #{commands}"
-        end
-      end
+        return if !@resharding_state && node_keys.size == 1 && node_keys.first == expected_node_key
+        return if @resharding_state && node_keys.size == 1
 
-      def handle_redirection(err)
-        if err.message.start_with?('MOVED')
-          node = @router.assign_redirection_node(err.message)
-          send_transaction(node, redirect: false)
-        elsif err.message.start_with?('ASK')
-          node = @router.assign_asking_node(err.message)
-          try_asking(node) ? send_transaction(node, redirect: false) : err
-        else
-          raise err
-        end
+        raise(ConsistencyError, "the transaction should be executed to a slot in a node: #{commands}")
       end
 
       def try_asking(node)

data/lib/redis_client/cluster.rb

@@ -6,6 +6,7 @@ require 'redis_client/cluster/pub_sub'
 require 'redis_client/cluster/router'
 require 'redis_client/cluster/transaction'
 require 'redis_client/cluster/pinning_node'
+require 'redis_client/cluster/optimistic_locking'
 
 class RedisClient
   class Cluster
@@ -91,9 +92,19 @@ class RedisClient
     end
 
     def multi(watch: nil)
-      transaction = ::RedisClient::Cluster::Transaction.new(@router, @command_builder, watch)
-      yield transaction
-      transaction.execute
+      if watch.nil? || watch.empty?
+        transaction = ::RedisClient::Cluster::Transaction.new(@router, @command_builder)
+        yield transaction
+        return transaction.execute
+      end
+
+      ::RedisClient::Cluster::OptimisticLocking.new(@router).watch(watch) do |c, resharding|
+        transaction = ::RedisClient::Cluster::Transaction.new(
+          @router, @command_builder, node: c, resharding: resharding
+        )
+        yield transaction
+        transaction.execute
+      end
     end
 
     def pubsub
@@ -102,12 +113,11 @@ class RedisClient
 
     # TODO: This isn't an official public interface yet. Don't use in your production environment.
     # @see https://github.com/redis-rb/redis-cluster-client/issues/299
-    def with(key: nil, hashtag: nil, write: true, _retry_count: 0, &_)
+    def with(key: nil, hashtag: nil, write: true)
       key = process_with_arguments(key, hashtag)
-
       node_key = @router.find_node_key_by_key(key, primary: write)
       node = @router.find_node(node_key)
-      yield ::RedisClient::Cluster::PinningNode.new(node)
+      node.with { |c| yield ::RedisClient::Cluster::PinningNode.new(c) }
     end
 
     def close

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.7.6
+  version: 0.7.8
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-17 00:00:00.000000000 Z
+date: 2024-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -49,6 +49,7 @@ files:
 - lib/redis_client/cluster/node/random_replica_or_primary.rb
 - lib/redis_client/cluster/node_key.rb
 - lib/redis_client/cluster/normalized_cmd_name.rb
+- lib/redis_client/cluster/optimistic_locking.rb
 - lib/redis_client/cluster/pinning_node.rb
 - lib/redis_client/cluster/pipeline.rb
 - lib/redis_client/cluster/pub_sub.rb