redis-cluster-client 0.16.0 → 0.16.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fbdcc076f2a4980b7511a7e49a9b9d7ecc44379bb90c7a3ef38e2452da69d78
-  data.tar.gz: b4e5c3afa0d587aef4fc52af7f5365c44a57c9cb7d80fe31bc237b3f04d78992
+  metadata.gz: f8d639d8939c9fdf304fa0f61886c1274f6e1c08bcd9e213dae3c7e0d844be02
+  data.tar.gz: 6f540ce88572df689c8a3e3971e3e96054b09b9fee7ef53c9aa518566ec3dd75
 SHA512:
-  metadata.gz: 17b0a9668dfbccd0f407e86085937ca4604ff380d719fac340d2b4f9b30ea39322a701167482fdc696b22dd8f63f0836c9d94d35b1822049f5cb2f8f24ca609f
-  data.tar.gz: 9a062aac27d5b8e5d7c907e034706b7671c4262bb692d3a9a00787ecc9bec4b12744429f3ea73e5deaedcf69c412df3591a5f6423233d5adff35cc300ac606d8
+  metadata.gz: 7d9c164a6590fb0ab3fa43328b484f8919895f17d3a6d5a9114c0c7b1a7867864be6d8e12ae1af45cdc81d39b9aa590e8c088de878ab964c18d9ae6f3c58682d
+  data.tar.gz: 01c0503f5f75d2441bdd2ea71537114c380db552e00ed8b130b0330626440f58a0d94bf94974dc044f4aebca9e024c931635dd8cbe5c96e225c80a7e10120840

data/lib/redis_client/cluster/command.rb

@@ -30,13 +30,14 @@ class RedisClient
             regular_timeout = node.read_timeout
             node.read_timeout = slow_command_timeout > 0.0 ? slow_command_timeout : regular_timeout
             reply = node.call('command')
-            node.read_timeout = regular_timeout
             commands = parse_command_reply(reply)
             cmd = ::RedisClient::Cluster::Command.new(commands)
             break
           rescue ::RedisClient::Error => e
             errors ||= []
             errors << e
+          ensure
+            node.read_timeout = regular_timeout
           end
 
           return cmd unless cmd.nil?

data/lib/redis_client/cluster/node.rb

@@ -405,7 +405,10 @@ class RedisClient
 
       def parse_cluster_shards_reply(reply) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         reply.each_with_object([]) do |shard, acc|
+          resp2 = shard.is_a?(Array)
+          shard = shard.each_slice(2).to_h if resp2
           nodes = shard.fetch('nodes')
+          nodes = nodes.map { |n| n.each_slice(2).to_h } if resp2
           primary_id = nodes.find { |n| n.fetch('role') == 'master' }.fetch('id')
 
           nodes.each do |node|
@@ -476,9 +479,11 @@ class RedisClient
       def with_reload_jitter
         return unless @next_reload_time.nil? || obtain_current_time >= @next_reload_time
 
-        yield
-
-        @next_reload_time = obtain_current_time + @random.rand(JITTER_WINDOW)
+        begin
+          yield
+        ensure
+          @next_reload_time = obtain_current_time + @random.rand(JITTER_WINDOW)
+        end
       end
 
       def with_reload_lock

data/lib/redis_client/cluster/node_key.rb

@@ -18,12 +18,30 @@ class RedisClient
       end
 
       def split(node_key)
-        pos = node_key&.rindex(DELIMITER, -1)
+        return [node_key, nil] if node_key.nil? || node_key.empty?
+
+        bracketed = split_bracketed(node_key)
+        return bracketed unless bracketed.nil?
+
+        pos = node_key.rindex(DELIMITER, -1)
         return [node_key, nil] if pos.nil?
 
         [node_key[0, pos], node_key[(pos + 1)..]]
       end
 
+      def split_bracketed(node_key)
+        return nil unless node_key.start_with?('[')
+
+        end_bracket = node_key.index(']')
+        return nil if end_bracket.nil?
+
+        host = node_key[1, end_bracket - 1]
+        remainder = node_key[(end_bracket + 1)..]
+        port = remainder.start_with?(DELIMITER) ? remainder[1..] : nil
+        [host, port]
+      end
+      private_class_method :split_bracketed
+
       def build_from_uri(uri)
         return '' if uri.nil?
 

data/lib/redis_client/cluster/optimistic_locking.rb

@@ -54,7 +54,7 @@ class RedisClient
       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.
-        retry_count -= [times_block_executed, 1].min
+        retry_count -= times_block_executed == 0 ? 1 : [times_block_executed, 1].min
         raise if retry_count < 0
 
         retry

data/lib/redis_client/cluster/pub_sub.rb

@@ -61,7 +61,17 @@ class RedisClient
       end
 
       BUF_SIZE = Integer(ENV.fetch('REDIS_CLIENT_PUBSUB_BUF_SIZE', 1024))
-      private_constant :BUF_SIZE
+      RECOVERY_BASE_INTERVAL = Float(ENV.fetch('REDIS_CLIENT_PUBSUB_RECOVERY_INTERVAL_SEC', 1.0))
+      RECOVERY_MAX_INTERVAL = Float(ENV.fetch('REDIS_CLIENT_PUBSUB_RECOVERY_MAX_INTERVAL_SEC', 30.0))
+      RECOVERY_MAX_ATTEMPTS = Integer(ENV.fetch('REDIS_CLIENT_PUBSUB_RECOVERY_MAX_ATTEMPTS', 10))
+      SUBSCRIBE_COMMANDS = %w[subscribe psubscribe ssubscribe].freeze
+      UNSUBSCRIBE_TO_SUBSCRIBE = {
+        'unsubscribe' => 'subscribe',
+        'punsubscribe' => 'psubscribe',
+        'sunsubscribe' => 'ssubscribe'
+      }.freeze
+      private_constant :BUF_SIZE, :RECOVERY_BASE_INTERVAL, :RECOVERY_MAX_INTERVAL, :RECOVERY_MAX_ATTEMPTS,
+                       :SUBSCRIBE_COMMANDS, :UNSUBSCRIBE_TO_SUBSCRIBE
 
       def initialize(router, command_builder)
         @router = router
@@ -74,14 +84,14 @@ class RedisClient
       def call(*args, **kwargs)
         command = @command_builder.generate(args, kwargs)
         _call(command)
-        @commands << command
+        remember(command)
         nil
       end
 
       def call_v(command)
         command = @command_builder.generate(command)
         _call(command)
-        @commands << command
+        remember(command)
         nil
       end
 
@@ -118,6 +128,35 @@ class RedisClient
 
       private
 
+      def remember(command)
+        cmd = command.first.to_s.downcase
+        if SUBSCRIBE_COMMANDS.include?(cmd)
+          @commands << command
+        elsif (subscribe_cmd = UNSUBSCRIBE_TO_SUBSCRIBE[cmd])
+          forget_subscriptions(subscribe_cmd, command[1..])
+        else
+          @commands << command
+        end
+      end
+
+      def forget_subscriptions(subscribe_cmd, channels)
+        if channels.nil? || channels.empty?
+          @commands.reject! { |c| c.first.to_s.casecmp(subscribe_cmd).zero? }
+        else
+          @commands.reject! { |c| prune_entry(c, subscribe_cmd, channels) }
+        end
+      end
+
+      def prune_entry(entry, subscribe_cmd, channels)
+        return false unless entry.first.to_s.casecmp(subscribe_cmd).zero?
+
+        remaining = entry[1..] - channels
+        return true if remaining.empty?
+
+        entry.replace([entry.first, *remaining])
+        false
+      end
+
       def _call(command) # rubocop:disable Metrics/AbcSize
         if command.first.casecmp('subscribe').zero?
           call_to_single_state(command)
@@ -179,6 +218,7 @@ class RedisClient
       end
 
       def start_over
+        attempt = 0
         loop do
           @router.renew_cluster_state
           @state_dict.each_value(&:close)
@@ -186,9 +226,16 @@ class RedisClient
           @commands.each { |command| _call(command) }
           break
         rescue ::RedisClient::ConnectionError, ::RedisClient::Cluster::NodeMightBeDown
-          sleep 1.0
+          attempt += 1
+          raise if attempt >= RECOVERY_MAX_ATTEMPTS
+
+          sleep recovery_interval(attempt)
         end
       end
+
+      def recovery_interval(attempt)
+        [RECOVERY_BASE_INTERVAL * (2**(attempt - 1)), RECOVERY_MAX_INTERVAL].min
+      end
     end
   end
 end

data/lib/redis_client/cluster_config.rb

@@ -32,6 +32,12 @@ class RedisClient
 
     InvalidClientConfigError = Class.new(::RedisClient::Cluster::Error)
 
+    SENSITIVE_INSPECT_KEYS = %i[username password].freeze
+    INSPECT_REDACTED_KEYS = %i[command_builder].freeze
+    INSPECT_PLACEHOLDER = '[FILTERED]'
+
+    private_constant :SENSITIVE_INSPECT_KEYS, :INSPECT_REDACTED_KEYS, :INSPECT_PLACEHOLDER
+
     attr_reader :command_builder, :client_config, :replica_affinity, :slow_command_timeout,
                 :connect_with_original_config, :startup_nodes, :max_startup_sample, :id
 
@@ -65,7 +71,7 @@ class RedisClient
     end
 
     def inspect
-      "#<#{self.class.name} #{startup_nodes.values.map { |v| v.reject { |k| k == :command_builder } }}>"
+      "#<#{self.class.name} #{startup_nodes.values.map { |v| redact_for_inspect(v) }}>"
     end
 
     def connect_timeout
@@ -117,6 +123,14 @@ class RedisClient
 
     private
 
+    def redact_for_inspect(node_config)
+      node_config.each_with_object({}) do |(key, value), redacted|
+        next if INSPECT_REDACTED_KEYS.include?(key)
+
+        redacted[key] = SENSITIVE_INSPECT_KEYS.include?(key) ? INSPECT_PLACEHOLDER : value
+      end
+    end
+
     def merge_concurrency_option(option)
       opts = {}
 

metadata

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