redis-cluster-client 0.17.4 → 0.17.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d99c93a4972ec806a5152ec5f550c5bb6c6e40a42932359ca0093e03cd6f6404
-  data.tar.gz: 72b055252677077791916fa85bd3c12bc566c0acba36afcd218f8e4691efeaee
+  metadata.gz: 675e3b7c851ac7deebc2f261d0aaa7fa6ef4c1865b3382014c41404ca314f5cc
+  data.tar.gz: 6a25062f50524661e566a1223752822711cf10246bedec98e52d1bdac3205fcc
 SHA512:
-  metadata.gz: 1e9d299dff3df85e3181d8a949e348985307d09d4ec2fa4d3de2795e11425ac2b988df0fecd1681af70974d6c315df3541d97aed53e449cc9839df252ce0a85d
-  data.tar.gz: 1f565bcc5c5e299b721309a1ba9273bc56016f4a62cf0a153cc4ecec4b7e355c4fc54488329537e1fe8733d09969ad34866d5998cfa6043667051dafc8d1884b
+  metadata.gz: 98cd5427026578e9a175cdcd21def056ca24997213f1c70385c193ce5fa2991a5f60edadb34e557d5c4a75ba4ff985d2c9a8b0c2f7e3e76f22cd9ce529846961
+  data.tar.gz: 1f8e2a9cc8576fee87fdfb91485fbb13a5609381ef8f186ae287915f8f51cd4c3611e627e65d82d9c0767d9345a1d62e14a24b0b0a41dd70624558fe3b50e2c5

data/lib/redis_client/cluster/node/base_topology.rb

@@ -42,6 +42,14 @@ class RedisClient
           @replica_clients.freeze
         end
 
+        def connect_to_node(node_key, option)
+          return @clients[node_key] if @clients.key?(node_key)
+
+          client = build_client(node_key, option)
+          @clients = @clients.merge(node_key => client)
+          client
+        end
+
         private
 
         def disconnect_from_unwanted_nodes(options)
@@ -52,13 +60,15 @@ class RedisClient
 
         def connect_to_new_nodes(options)
           (options.keys - @clients.keys).each do |node_key|
-            option = options[node_key].merge(@client_options)
-            config = ::RedisClient::Cluster::Node::Config.new(scale_read: @replica_node_keys.include?(node_key), **option)
-            client = @pool.nil? ? config.new_client : config.new_pool(**@pool)
-            @clients[node_key] = client
+            @clients[node_key] = build_client(node_key, options[node_key])
           end
         end
 
+        def build_client(node_key, option)
+          config = ::RedisClient::Cluster::Node::Config.new(scale_read: @replica_node_keys.include?(node_key), **option.merge(@client_options))
+          @pool.nil? ? config.new_client : config.new_pool(**@pool)
+        end
+
         def make_random(seed)
           # OPTIMIZE: Figure out the most elegant way to pin a node during a pipeline or scan.
           seed.nil? ? Random : Random.new(seed)

data/lib/redis_client/cluster/node.rb

@@ -129,6 +129,22 @@ class RedisClient
         @topology.clients.fetch(node_key)
       end
 
+      def find_or_connect(node_key)
+        client = @topology.clients[node_key]
+        return client unless client.nil?
+        raise ReloadNeeded if node_key.nil? || !@mutex.try_lock
+
+        begin
+          @topology.connect_to_node(node_key, @config.client_config_for_node(node_key))
+        ensure
+          @mutex.unlock
+        end
+      end
+
+      def primary_node_key?(node_key)
+        @replications.key?(node_key)
+      end
+
       def call_all(method, command, args, &block)
         call_multiple_nodes!(@topology.clients, method, command, args, &block)
       end
@@ -155,7 +171,9 @@ class RedisClient
         result_values, errors = call_multiple_nodes(@topology.clients, method, command, args, &block)
         return result_values if errors.nil? || errors.empty?
 
-        raise ReloadNeeded if errors.values.any?(::RedisClient::ConnectionError)
+        raise ReloadNeeded if errors.values.any? do |err|
+          err.is_a?(::RedisClient::ConnectionError) && !err.is_a?(::RedisClient::CheckoutTimeoutError)
+        end
 
         raise ::RedisClient::Cluster::ErrorCollection.with_errors(errors)
       end

data/lib/redis_client/cluster/optimistic_locking.rb

@@ -34,6 +34,8 @@ class RedisClient
               @router.renew_cluster_state if e.message.start_with?('CLUSTERDOWN')
               raise
             end
+          rescue ::RedisClient::CheckoutTimeoutError
+            raise
           rescue ::RedisClient::ConnectionError
             @router.renew_cluster_state
             raise
@@ -52,6 +54,8 @@ class RedisClient
           times_block_executed += 1
           handle_asking_once(nd, &blk)
         end
+      rescue ::RedisClient::CheckoutTimeoutError
+        raise
       rescue ::RedisClient::ConnectionError
         # Deduct the number of retries that happened _inside_ router#handle_redirection from our remaining
         # _external_ retries. Always deduct at least one in case handle_redirection raises without trying the block.

data/lib/redis_client/cluster/pipeline.rb

@@ -205,7 +205,7 @@ class RedisClient
             cluster_state_errors ||= {}
             cluster_state_errors[node_key] = v
           when StandardError
-            cluster_state_errors ||= {} if v.is_a?(::RedisClient::ConnectionError)
+            cluster_state_errors ||= {} if v.is_a?(::RedisClient::ConnectionError) && !v.is_a?(::RedisClient::CheckoutTimeoutError)
             errors ||= {}
             errors[node_key] = v
           else
@@ -277,10 +277,16 @@ class RedisClient
           try_redirection(node, pipeline, inner_index)
         elsif err.message.start_with?('ASK')
           node = @router.assign_asking_node(err.message)
-          try_asking(node) ? try_redirection(node, pipeline, inner_index) : err
+          node.with do |client|
+            try_asking(client) ? try_redirection(client, pipeline, inner_index) : err
+          end
         else
           err
         end
+      rescue ::RedisClient::CheckoutTimeoutError
+        raise if @exception
+
+        err
       end
 
       def try_redirection(node, pipeline, inner_index)
@@ -305,6 +311,8 @@ class RedisClient
 
       def try_asking(node)
         node.call('asking') == 'OK'
+      rescue ::RedisClient::CheckoutTimeoutError
+        raise
       rescue StandardError
         false
       end

data/lib/redis_client/cluster/pub_sub.rb

@@ -171,6 +171,8 @@ class RedisClient
 
       def handle_connection_error(node_key, ignore: false)
         yield
+      rescue ::RedisClient::CheckoutTimeoutError
+        raise
       rescue ::RedisClient::ConnectionError
         @state_dict[node_key]&.close
         @state_dict.delete(node_key)
@@ -186,6 +188,8 @@ class RedisClient
           @state_dict.clear
           @commands.each { |command| _call(command) }
           break
+        rescue ::RedisClient::CheckoutTimeoutError
+          raise
         rescue ::RedisClient::ConnectionError, ::RedisClient::Cluster::NodeMightBeDown
           attempt += 1
           raise if attempt >= 10

data/lib/redis_client/cluster/router.rb

@@ -42,7 +42,7 @@ class RedisClient
         return send_command_by_spec(method, command, args, &block) if action.nil?
 
         send_command_by_action(action, method, command, args, &block)
-      rescue ::RedisClient::CircuitBreaker::OpenCircuitError
+      rescue ::RedisClient::CircuitBreaker::OpenCircuitError, ::RedisClient::CheckoutTimeoutError
         raise
       rescue ::RedisClient::Cluster::Node::ReloadNeeded
         renew_cluster_state
@@ -58,6 +58,7 @@ class RedisClient
         raise if e.errors.any?(::RedisClient::CircuitBreaker::OpenCircuitError)
 
         renew_cluster_state if e.errors.values.any? do |err|
+          next false if err.is_a?(::RedisClient::CheckoutTimeoutError)
           next false if ::RedisClient::Cluster::ErrorIdentification.identifiable?(err) && @node.none? { |c| ::RedisClient::Cluster::ErrorIdentification.client_owns_error?(err, c) }
 
           err.message.start_with?('CLUSTERDOWN') || err.is_a?(::RedisClient::ConnectionError)
@@ -84,46 +85,56 @@ class RedisClient
       end
 
       def handle_redirection(node, command, retry_count:) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        yield node
-      rescue ::RedisClient::CircuitBreaker::OpenCircuitError
-        raise
-      rescue ::RedisClient::CommandError => e
-        raise unless ::RedisClient::Cluster::ErrorIdentification.client_owns_error?(e, node)
-
-        retry_count -= 1
-        if e.message.start_with?('MOVED')
-          node = assign_redirection_node(e.message)
-          retry if retry_count >= 0
-        elsif e.message.start_with?('ASK')
-          node = assign_asking_node(e.message)
-          if retry_count >= 0
-            node.call('asking')
-            retry
+        asking = false
+        begin
+          if asking
+            node.with do |client|
+              client.call('asking')
+              yield client
+            end
+          else
+            yield node
+          end
+        rescue ::RedisClient::CircuitBreaker::OpenCircuitError, ::RedisClient::CheckoutTimeoutError
+          raise
+        rescue ::RedisClient::CommandError => e
+          raise unless ::RedisClient::Cluster::ErrorIdentification.client_owns_error?(e, node)
+
+          retry_count -= 1
+          asking = false
+          if e.message.start_with?('MOVED')
+            node = assign_redirection_node(e.message)
+            retry if retry_count >= 0
+          elsif e.message.start_with?('ASK')
+            node = assign_asking_node(e.message)
+            asking = true
+            retry if retry_count >= 0
+          elsif e.message.start_with?('CLUSTERDOWN')
+            renew_cluster_state
+            retry if retry_count >= 0
           end
-        elsif e.message.start_with?('CLUSTERDOWN')
-          renew_cluster_state
-          retry if retry_count >= 0
-        end
 
-        raise
-      rescue ::RedisClient::ConnectionError => e
-        raise unless ::RedisClient::Cluster::ErrorIdentification.client_owns_error?(e, node)
+          raise
+        rescue ::RedisClient::ConnectionError => e
+          raise unless ::RedisClient::Cluster::ErrorIdentification.client_owns_error?(e, node)
 
-        renew_cluster_state
-        raise if command.nil? || command.empty?
+          renew_cluster_state
+          raise if command.nil? || command.empty?
 
-        retry_count -= 1
-        raise if retry_count < 0
+          retry_count -= 1
+          raise if retry_count < 0
 
-        # Find the node to use for this command - if this fails for some reason, though, re-use
-        # the old node.
-        begin
-          node = find_node(find_node_key(command))
-        rescue StandardError
-          raise e
-        end
+          # Find the node to use for this command - if this fails for some reason, though, re-use
+          # the old node.
+          begin
+            node = find_node(find_node_key(command))
+          rescue StandardError
+            raise e
+          end
 
-        retry
+          asking = false
+          retry
+        end
       end
 
       def scan(command, seed: nil, cursor_index: 1) # rubocop:disable Metrics/AbcSize
@@ -146,6 +157,8 @@ class RedisClient
         client_index += 1 if result_cursor == 0
 
         [((result_cursor << 8) + client_index).to_s, result_keys]
+      rescue ::RedisClient::CheckoutTimeoutError
+        raise
       rescue ::RedisClient::ConnectionError
         renew_cluster_state
         raise
@@ -225,14 +238,16 @@ class RedisClient
 
       def assign_redirection_node(err_msg)
         _, slot, node_key = err_msg.split
-        slot = slot.to_i
-        @node.update_slot(slot, node_key)
-        handle_node_reload_error { @node.find_by(node_key) }
+        # A MOVED to anything but a known primary means the map is behind; the reload is throttled by the jitter.
+        renew_cluster_state unless @node.primary_node_key?(node_key)
+        node = handle_node_reload_error { @node.find_or_connect(node_key) }
+        @node.update_slot(slot.to_i, node_key)
+        node
       end
 
       def assign_asking_node(err_msg)
         _, _, node_key = err_msg.split
-        handle_node_reload_error { @node.find_by(node_key) }
+        handle_node_reload_error { @node.find_or_connect(node_key) }
       end
 
       def node_keys

data/lib/redis_client/cluster/transaction.rb

@@ -124,22 +124,27 @@ class RedisClient
         end
       end
 
-      def send_pipeline(client, redirect:) # rubocop:disable Metrics/AbcSize
+      def send_pipeline(client, redirect:) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         replies = client.ensure_connected_cluster_scoped(retryable: @retryable) do |connection|
           commands = @pipeline._commands
           client.middlewares.call_pipelined(commands, client.config) do
             connection.call_pipelined(commands, nil)
           rescue ::RedisClient::CommandError => e
             ensure_the_same_slot!(commands)
-            return handle_command_error!(e, redirect: redirect) unless redirect.zero?
+            raise if redirect.zero?
+            # Follow the redirection after leaving this block, so that errors from the other node don't close or retry this connection.
+            break e if e.message.start_with?('MOVED', 'ASK')
 
-            raise
+            handle_command_error!(e, redirect: redirect)
           end
         end
 
+        return handle_command_error!(replies, redirect: redirect) if replies.is_a?(::RedisClient::CommandError)
         return if replies.last.nil?
 
         coerce_results!(replies.last)
+      rescue ::RedisClient::CheckoutTimeoutError
+        raise
       rescue ::RedisClient::ConnectionError
         @router.renew_cluster_state if @watching_slot.nil?
         raise
@@ -171,7 +176,9 @@ class RedisClient
           send_transaction(node, redirect: redirect - 1)
         elsif err.message.start_with?('ASK')
           node = @router.assign_asking_node(err.message)
-          try_asking(node) ? send_transaction(node, redirect: redirect - 1) : raise(err)
+          node.with do |client|
+            try_asking(client) ? send_transaction(client, redirect: redirect - 1) : raise(err)
+          end
         elsif err.message.start_with?('CLUSTERDOWN')
           @router.renew_cluster_state if @watching_slot.nil?
           raise err
@@ -190,6 +197,8 @@ class RedisClient
 
       def try_asking(node)
         node.call('asking') == 'OK'
+      rescue ::RedisClient::CheckoutTimeoutError
+        raise
       rescue StandardError
         false
       end

metadata

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