redis-cluster-client 0.7.7 → 0.7.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 158cfc3693b4057ae42249cbddcca2e5bd53bb19bb62416e44f1d1358b55c711
-  data.tar.gz: 59917a893698b9d0fec7235821e4f9680b9e3ab4ebfd74554c48c50455a87186
+  metadata.gz: 5aa02a0e3934e8246e948260f2a4457b324de2377e7ec2e00fe9bf03a52f5ee4
+  data.tar.gz: 9f97a22af58eb64c64a6b73a79c2947bad06318e17bca235a5aa59fae35aad1d
 SHA512:
-  metadata.gz: 116c7f397e557fc0b6a336e3481cc3e5458bac590afe454ecbfbfcafddc67ea3641f9cd020ab7b9f2cb41f3fe54188a13d4324b9496e43a27b1f58f97163363d
-  data.tar.gz: e7ada90bdb11f0d113093792b627853a429d182c1e531d6c968fff530bbd34ed8df76655fd40223b91bc3c5d6524316302fa435438e731a8de1dcb0bc5c4ad24
+  metadata.gz: 2e8fcf1be08ba5c2582ad112455b02815410a81834b55bfc0035e0971556ff7b443e60a48a4cc2f5c94fdd81d09a5d03d3c261b4e0afb13ac9f38da5d4f0ab64
+  data.tar.gz: 77f17d9e003384f34e5719f0e84f70c8a04f7de196974fc5af830e4825827b01d7df94b4eb887d4a1a4a77f43caa989cfdcbb1e874d807503bf9ef254ea95a0d

data/lib/redis_client/cluster/optimistic_locking.rb

@@ -1,47 +1,40 @@
 # 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(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)
+        slot = find_slot(keys)
+        raise ::RedisClient::Cluster::Transaction::ConsistencyError, "unsafe watch: #{keys.join(' ')}" if slot.nil?
+
+        node = @router.find_primary_node_by_slot(slot)
+        @router.handle_redirection(node, retry_count: 1) do |nd|
+          nd.with do |c|
+            c.call('WATCH', *keys)
+            reply = yield(c, slot)
+            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 find_slot(keys)
+        return if keys.empty?
+        return if keys.any? { |k| k.nil? || k.empty? }
 
-        node_key = router.find_primary_node_key(['WATCH', *keys])
-        raise ::RedisClient::Cluster::Transaction::ConsistencyError, "couldn't determine the node" if node_key.nil?
+        slots = keys.map { |k| @router.find_slot_by_key(k) }
+        return if slots.uniq.size != 1
 
-        router.find_node(node_key)
-      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
+        slots.first
       end
     end
   end

data/lib/redis_client/cluster/router.rb

@@ -179,6 +179,16 @@ class RedisClient
         find_node_key_by_key(key, primary: true)
       end
 
+      def find_slot(command)
+        find_slot_by_key(@command.extract_first_key(command))
+      end
+
+      def find_slot_by_key(key)
+        return if key.empty?
+
+        ::RedisClient::Cluster::KeySlotConverter.convert(key)
+      end
+
       def find_node(node_key, retry_count: 3)
         @node.find_by(node_key)
       rescue ::RedisClient::Cluster::Node::ReloadNeeded

data/lib/redis_client/cluster/transaction.rb

@@ -2,14 +2,14 @@
 
 require 'redis_client'
 require 'redis_client/cluster/pipeline'
-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, node = nil)
+      def initialize(router, command_builder, node: nil, slot: nil)
         @router = router
         @command_builder = command_builder
         @retryable = true
@@ -17,6 +17,7 @@ class RedisClient
         @pending_commands = []
         @node = node
         prepare_tx unless @node.nil?
+        @watching_slot = slot
       end
 
       def call(*command, **kwargs, &block)
@@ -92,7 +93,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 +110,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!(commands, e, redirect: redirect) unless redirect.zero?
 
             raise
           end
@@ -138,41 +139,30 @@ class RedisClient
         results
       end
 
-      def handle_command_error!(commands, err)
+      def handle_command_error!(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)
-        else
-          raise err
-        end
-      end
-
-      def ensure_the_same_node!(commands)
-        expected_node_key = NodeKey.build_from_client(@node)
-
-        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
-
-      def handle_redirection(err)
-        if err.message.start_with?('MOVED')
+        elsif err.message.start_with?('MOVED')
+          ensure_the_same_slot!(commands)
           node = @router.assign_redirection_node(err.message)
-          send_transaction(node, redirect: false)
+          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: false) : err
+          try_asking(node) ? send_transaction(node, redirect: redirect - 1) : err
         else
           raise err
         end
       end
 
+      def ensure_the_same_slot!(commands)
+        slots = commands.map { |command| @router.find_slot(command) }.compact.uniq
+        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}")
+      end
+
       def try_asking(node)
         node.call('ASKING') == 'OK'
       rescue StandardError

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, slot|
+        transaction = ::RedisClient::Cluster::Transaction.new(
+          @router, @command_builder, node: c, slot: slot
+        )
+        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.9
 platform: ruby
 authors:
 - Taishi Kasuga