redis-cluster-client 0.7.7 → 0.7.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 158cfc3693b4057ae42249cbddcca2e5bd53bb19bb62416e44f1d1358b55c711
-  data.tar.gz: 59917a893698b9d0fec7235821e4f9680b9e3ab4ebfd74554c48c50455a87186
+  metadata.gz: 41d87ce45a108ff8ec7d3c17805276d5ba7df11d577de3f7d6b1176bdd297ed0
+  data.tar.gz: 7118539907bb755225ba908cf160ad8af73aeb5204820682ca3fc3a67813f3cb
 SHA512:
-  metadata.gz: 116c7f397e557fc0b6a336e3481cc3e5458bac590afe454ecbfbfcafddc67ea3641f9cd020ab7b9f2cb41f3fe54188a13d4324b9496e43a27b1f58f97163363d
-  data.tar.gz: e7ada90bdb11f0d113093792b627853a429d182c1e531d6c968fff530bbd34ed8df76655fd40223b91bc3c5d6524316302fa435438e731a8de1dcb0bc5c4ad24
+  metadata.gz: 96e3c0f9c2860002642e079b756065e32f04891cd793dce9efcb74bb87a13683b14fee13c039693d99599549fee7ace68d54561b8c730d5e9eb7bb937a82c57d
+  data.tar.gz: 2e512b774b5778e3f7a2a3557bb45d97971d209c787494a19d81e0d8146f5d51bbef7940f37fa38f7587e1037185e23fa27ca8d48a46225ced6640be8425198e

data/lib/redis_client/cluster/optimistic_locking.rb

@@ -7,29 +7,32 @@ require 'redis_client/cluster/transaction'
 class RedisClient
   class Cluster
     class OptimisticLocking
-      def initialize(keys, router)
-        @node = find_node!(keys, router)
-        @keys = keys
+      def initialize(router)
+        @router = router
       end
 
-      def watch
-        @node.with do |c|
-          c.call('WATCH', *@keys)
-          reply = yield(c)
-          c.call('UNWATCH')
-          reply
+      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 find_node!(keys, router)
-        raise ::RedisClient::Cluster::Transaction::ConsistencyError, "unsafe watch: #{keys.join(' ')}" unless safe?(keys)
+      def ensure_safe_keys(keys)
+        return if safe?(keys)
 
-        node_key = router.find_primary_node_key(['WATCH', *keys])
-        raise ::RedisClient::Cluster::Transaction::ConsistencyError, "couldn't determine the node" if node_key.nil?
-
-        router.find_node(node_key)
+        raise ::RedisClient::Cluster::Transaction::ConsistencyError, "unsafe watch: #{keys.join(' ')}"
       end
 
       def safe?(keys)
@@ -43,6 +46,13 @@ class RedisClient
 
         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

@@ -8,8 +8,9 @@ class RedisClient
   class Cluster
     class Transaction
       ConsistencyError = Class.new(::RedisClient::Error)
+      MAX_REDIRECTION = 2
 
-      def initialize(router, command_builder, node = nil)
+      def initialize(router, command_builder, node: nil, resharding: false)
         @router = router
         @command_builder = command_builder
         @retryable = true
@@ -17,6 +18,7 @@ class RedisClient
         @pending_commands = []
         @node = node
         prepare_tx unless @node.nil?
+        @resharding_state = resharding
       end
 
       def call(*command, **kwargs, &block)
@@ -92,7 +94,7 @@ class RedisClient
 
       def settle
         @pipeline.call('EXEC')
-        send_transaction(@node, redirect: true)
+        send_transaction(@node, redirect: MAX_REDIRECTION)
       end
 
       def send_transaction(client, redirect:)
@@ -109,7 +111,7 @@ 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
@@ -138,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)
-        expected_node_key = NodeKey.build_from_client(@node)
+      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)
 
-        commands.each do |command|
-          node_key = @router.find_primary_node_key(command)
-          next if node_key.nil?
-          next if node_key == expected_node_key
-
-          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

@@ -95,14 +95,15 @@ class RedisClient
       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
-      else
-        locking = ::RedisClient::Cluster::OptimisticLocking.new(watch, @router)
-        locking.watch do |c|
-          transaction = ::RedisClient::Cluster::Transaction.new(@router, @command_builder, c)
-          yield transaction
-          transaction.execute
-        end
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.7.7
+  version: 0.7.8
 platform: ruby
 authors:
 - Taishi Kasuga