redis-cluster-client 0.14.1 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0941b5506846f311cfce98389972b5fccca807384309821ea9df7b61148cc818'
-  data.tar.gz: ba7654bdd8d03059a7953ed1772e8281dc3dd9a06c4e0e9969dc127d0df21935
+  metadata.gz: 5fbdcc076f2a4980b7511a7e49a9b9d7ecc44379bb90c7a3ef38e2452da69d78
+  data.tar.gz: b4e5c3afa0d587aef4fc52af7f5365c44a57c9cb7d80fe31bc237b3f04d78992
 SHA512:
-  metadata.gz: 27fc5ca5d00b957b8494ea1e9bd72ba32287f0e1df4c4ab64106dfd7a183b95181156a6e6f4685a1b47ec571b7650614bda4d0331a4ed45b13f5b5c0fa894ae0
-  data.tar.gz: 61563e73385b147b1f0b3d5be4ac99287ddb476912bd7e5b7689df0ae7e875c4372f69a2bcf8964e90a9ce9e867f0b9a160decce2089318f78ab200334ff6bc3
+  metadata.gz: 17b0a9668dfbccd0f407e86085937ca4604ff380d719fac340d2b4f9b30ea39322a701167482fdc696b22dd8f63f0836c9d94d35b1822049f5cb2f8f24ca609f
+  data.tar.gz: 9a062aac27d5b8e5d7c907e034706b7671c4262bb692d3a9a00787ecc9bec4b12744429f3ea73e5deaedcf69c412df3591a5f6423233d5adff35cc300ac606d8

data/lib/redis_client/cluster/key_slot_converter.rb

@@ -70,7 +70,7 @@ class RedisClient
         e = key.index(RIGHT_BRACKET, s + 1)
         return EMPTY_STRING if e.nil?
 
-        key[s + 1..e - 1]
+        s + 1 < e ? key[s + 1, e - s - 1] : EMPTY_STRING
       end
 
       def hash_tag_included?(key)

data/lib/redis_client/cluster/node.rb

@@ -24,10 +24,12 @@ class RedisClient
       ROLE_FLAGS = %w[master slave].freeze
       EMPTY_ARRAY = [].freeze
       EMPTY_HASH = {}.freeze
-      STATE_REFRESH_INTERVAL = (3..10).freeze
+      EMPTY_STRING = ''
+      JITTER_WINDOW = (3_000_000...10_000_000).freeze # micro seconds
 
       private_constant :USE_CHAR_ARRAY_SLOT, :SLOT_SIZE, :MIN_SLOT, :MAX_SLOT,
-                       :DEAD_FLAGS, :ROLE_FLAGS, :EMPTY_ARRAY, :EMPTY_HASH
+                       :DEAD_FLAGS, :ROLE_FLAGS, :EMPTY_ARRAY, :EMPTY_HASH, :EMPTY_STRING,
+                       :JITTER_WINDOW
 
       ReloadNeeded = Class.new(::RedisClient::Cluster::Error)
 
@@ -46,7 +48,7 @@ class RedisClient
         end
 
         def serialize(str)
-          str << id << node_key << role << primary_id << config_epoch
+          str << id << node_key << role << primary_id
         end
       end
 
@@ -106,8 +108,7 @@ class RedisClient
         @topology = klass.new(pool, @concurrent_worker, **kwargs)
         @config = config
         @mutex = Mutex.new
-        @last_reloaded_at = nil
-        @reload_times = 0
+        @next_reload_time = nil
         @random = Random.new
       end
 
@@ -193,26 +194,22 @@ class RedisClient
       end
 
       def update_slot(slot, node_key)
-        return if @mutex.locked?
+        return unless @mutex.try_lock
 
-        @mutex.synchronize do
-          @slots[slot] = node_key
-        rescue RangeError
-          @slots = Array.new(SLOT_SIZE) { |i| @slots[i] }
-          @slots[slot] = node_key
-        end
+        @slots[slot] = node_key
+      rescue RangeError
+        @slots = Array.new(SLOT_SIZE) { |i| @slots[i] }
+        @slots[slot] = node_key
+      ensure
+        @mutex.unlock if @mutex.owned?
       end
 
-      def reload!
+      def try_reload!
         with_reload_lock do
-          with_startup_clients(@config.max_startup_sample) do |startup_clients|
-            @node_info = refetch_node_info_list(startup_clients)
-            @node_configs = @node_info.to_h do |node_info|
-              [node_info.node_key, @config.client_config_for_node(node_info.node_key)]
+          with_reload_jitter do
+            with_startup_clients(@config.max_startup_sample) do |clients|
+              reload!(clients)
             end
-            @slots = build_slot_node_mappings(@node_info)
-            @replications = build_replication_mappings(@node_info)
-            @topology.process_topology_update!(@replications, @node_configs)
           end
         end
       end
@@ -312,12 +309,11 @@ class RedisClient
           work_group.push(i, raw_client) do |client|
             regular_timeout = client.read_timeout
             client.read_timeout = @config.slow_command_timeout > 0.0 ? @config.slow_command_timeout : regular_timeout
-            reply = client.call_once('cluster', 'nodes')
-            client.read_timeout = regular_timeout
-            parse_cluster_node_reply(reply)
+            fetch_cluster_state(client)
           rescue StandardError => e
             e
           ensure
+            client.read_timeout = regular_timeout
             client&.close
           end
         end
@@ -347,6 +343,16 @@ class RedisClient
         grouped.max_by { |_, v| v.size }[1].first
       end
 
+      def fetch_cluster_state(client)
+        reply = client.call_once('cluster', 'shards')
+        parse_cluster_shards_reply(reply)
+      rescue ::RedisClient::CommandError => e
+        raise unless e.message.start_with?('ERR Unknown subcommand')
+
+        reply = client.call_once('cluster', 'nodes')
+        parse_cluster_node_reply(reply)
+      end
+
       def parse_cluster_node_reply(reply) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         reply.each_line("\n", chomp: true).filter_map do |line|
           fields = line.split
@@ -390,11 +396,11 @@ class RedisClient
               id: id,
               node_key: NodeKey.build_from_host_port(ip, arr[1]),
               role: role,
-              primary_id: role == 'master' ? nil : primary_id,
+              primary_id: role == 'master' ? EMPTY_STRING : primary_id,
               slots: role == 'master' ? slots : EMPTY_ARRAY
             )
           end
-        end.freeze
+        end
       end
 
       def parse_cluster_shards_reply(reply) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
@@ -411,18 +417,18 @@ class RedisClient
               id: node.fetch('id'),
               node_key: NodeKey.build_from_host_port(ip, node['port'] || node['tls-port']),
               role: role == 'master' ? role : 'slave',
-              primary_id: role == 'master' ? nil : primary_id,
+              primary_id: role == 'master' ? EMPTY_STRING : primary_id,
               slots: role == 'master' ? shard.fetch('slots').each_slice(2).to_a.freeze : EMPTY_ARRAY
             )
           end
-        end.freeze
+        end
       end
 
       # As redirection node_key is dependent on `cluster-preferred-endpoint-type` config,
       # node_key should use hostname if present in CLUSTER NODES output.
       #
       # See https://redis.io/commands/cluster-nodes/ for details on the output format.
-      # node_address matches fhe format: <ip:port@cport[,hostname[,auxiliary_field=value]*]>
+      # node_address matches the format: <ip:port@cport[,hostname[,auxiliary_field=value]*]>
       def parse_node_key(node_address)
         ip_chunk, hostname, _auxiliaries = node_address.split(',')
         ip_port_string = ip_chunk.split('@').first
@@ -432,6 +438,16 @@ class RedisClient
         "#{hostname}:#{port}"
       end
 
+      def reload!(clients)
+        @node_info = refetch_node_info_list(clients)
+        @node_configs = @node_info.to_h do |node_info|
+          [node_info.node_key, @config.client_config_for_node(node_info.node_key)]
+        end
+        @slots = build_slot_node_mappings(@node_info)
+        @replications = build_replication_mappings(@node_info)
+        @topology.process_topology_update!(@replications, @node_configs)
+      end
+
       def with_startup_clients(count) # rubocop:disable Metrics/AbcSize
         if @config.connect_with_original_config
           # If connect_with_original_config is set, that means we need to build actual client objects
@@ -457,35 +473,41 @@ class RedisClient
         end
       end
 
+      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)
+      end
+
       def with_reload_lock
-        # What should happen with concurrent calls #reload? This is a realistic possibility if the cluster goes into
+        # What should happen with concurrent calls #try_reload! This is a realistic possibility if the cluster goes into
         # a CLUSTERDOWN state, and we're using a pooled backend. Every thread will independently discover this, and
-        # call reload!.
-        # For now, if a reload is in progress, wait for that to complete, and consider that the same as us having
-        # performed the reload.
-        # Probably in the future we should add a circuit breaker to #reload itself, and stop trying if the cluster is
+        # call #try_reload!.
+        # For now, if a reload is in progress by a thread, the other threads do not wait for that to complete, and
+        # they throw an error.
+        # Probably in the future we should add a circuit breaker to #try_reload! itself, and stop trying if the cluster is
         # obviously not working.
-        wait_start = obtain_current_time
-        @mutex.synchronize do
-          return if @last_reloaded_at && @last_reloaded_at > wait_start
-
-          if @last_reloaded_at && @reload_times > 1
-            # Mitigate load of servers by naive logic. Don't sleep with exponential backoff.
-            now = obtain_current_time
-            elapsed = @last_reloaded_at + @random.rand(STATE_REFRESH_INTERVAL) * 1_000_000
-            return if now < elapsed
-          end
+        return unless @mutex.try_lock
 
-          r = yield
-          @last_reloaded_at = obtain_current_time
-          @reload_times += 1
-          r
-        end
+        yield
+      ensure
+        @mutex.unlock if @mutex.owned?
       end
 
       def obtain_current_time
         Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
       end
+
+      def bypass_reload!
+        # DO NOT USE THIS METHOD
+        with_reload_lock do
+          with_startup_clients(@config.max_startup_sample) do |clients|
+            reload!(clients)
+          end
+        end
+      end
     end
   end
 end

data/lib/redis_client/cluster/router.rb

@@ -84,7 +84,7 @@ class RedisClient
         @pool = pool
         @client_kwargs = kwargs
         @node = ::RedisClient::Cluster::Node.new(concurrent_worker, config: config, pool: pool, **kwargs)
-        @node.reload!
+        @node.try_reload!
         @command = ::RedisClient::Cluster::Command.load(@node.replica_clients.shuffle, slow_command_timeout: config.slow_command_timeout)
         @command_builder = @config.command_builder
       rescue ::RedisClient::Cluster::InitialSetupError => e
@@ -93,9 +93,8 @@ class RedisClient
       end
 
       def send_command(method, command, *args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        return assign_node_and_send_command(method, command, args, &block) unless DEDICATED_ACTIONS.key?(command.first)
-
         action = DEDICATED_ACTIONS[command.first]
+        return assign_node_and_send_command(method, command, args, &block) if action.nil?
         return send(action.method_name, method, command, args, &block) if action.reply_transformer.nil?
 
         reply = send(action.method_name, method, command, args)
@@ -167,8 +166,8 @@ class RedisClient
       rescue ::RedisClient::ConnectionError => e
         raise unless ::RedisClient::Cluster::ErrorIdentification.client_owns_error?(e, node)
 
-        retry_count -= 1
         renew_cluster_state
+        retry_count -= 1
 
         if retry_count >= 0
           # Find the node to use for this command - if this fails for some reason, though, re-use
@@ -180,7 +179,6 @@ class RedisClient
           retry
         end
 
-        retry if retry_count >= 0
         raise
       end
 
@@ -294,7 +292,7 @@ class RedisClient
       end
 
       def renew_cluster_state
-        @node.reload!
+        @node.try_reload!
       rescue ::RedisClient::Cluster::InitialSetupError
         # ignore
       end
@@ -340,8 +338,8 @@ class RedisClient
         raise if retry_count <= 0
         raise if e.errors.values.none? { |err| err.message.include?('WAIT cannot be used with replica instances') }
 
-        retry_count -= 1
         renew_cluster_state
+        retry_count -= 1
         retry
       end
 
@@ -452,7 +450,7 @@ class RedisClient
       end
 
       def send_multiple_keys_command(method, command, args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        # This implementation is prioritized performance rather than readability or so.
+        # This implementation prioritizes performance over readability.
         cmd = command.first
         if cmd.casecmp('mget').zero?
           single_key_cmd = 'get'
@@ -502,8 +500,8 @@ class RedisClient
       rescue ::RedisClient::Cluster::Node::ReloadNeeded
         raise ::RedisClient::Cluster::NodeMightBeDown.new.with_config(@config) if retry_count <= 0
 
-        retry_count -= 1
         renew_cluster_state
+        retry_count -= 1
         retry
       end
     end

data/lib/redis_client/cluster.rb

@@ -130,8 +130,26 @@ class RedisClient
       ::RedisClient::Cluster::PubSub.new(router, @command_builder)
     end
 
-    def with(...)
-      raise NotImplementedError, 'No way to use'
+    # Compatibility layer for RedisClient::Pooled
+    def with(_options = nil)
+      yield self
+    end
+    alias then with
+
+    # Compatibility layer for RedisClient::HashRing
+    def node_for(_key)
+      self
+    end
+
+    # Compatibility layer for RedisClient::HashRing
+    def nodes_for(*keys)
+      keys.flatten!
+      { self => keys }
+    end
+
+    # Compatibility layer for RedisClient::HashRing
+    def nodes
+      [self].freeze
     end
 
     def close

data/lib/redis_client/cluster_config.rb

@@ -21,9 +21,9 @@ class RedisClient
     MERGE_CONFIG_KEYS = %i[ssl username password db].freeze
     IGNORE_GENERIC_CONFIG_KEYS = %i[url host port path].freeze
     MAX_WORKERS = Integer(ENV.fetch('REDIS_CLIENT_MAX_THREADS', -1)) # for backward compatibility
-    # It's used with slow queries of fetching meta data like CLUSTER NODES, COMMAND and so on.
+    # Used for slow commands that fetch metadata, e.g. CLUSTER NODES, COMMAND.
     SLOW_COMMAND_TIMEOUT = Float(ENV.fetch('REDIS_CLIENT_SLOW_COMMAND_TIMEOUT', -1))
-    # It affects to strike a balance between load and stability in initialization or changed states.
+    # Controls the balance between startup load and stability during initialization or cluster state changes.
     MAX_STARTUP_SAMPLE = Integer(ENV.fetch('REDIS_CLIENT_MAX_STARTUP_SAMPLE', 3))
 
     private_constant :DEFAULT_HOST, :DEFAULT_PORT, :DEFAULT_SCHEME, :SECURE_SCHEME, :DEFAULT_NODES,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.16.0
 platform: ruby
 authors:
 - Taishi Kasuga
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.24'
+        version: '0.28'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.24'
+        version: '0.28'
 email:
 - proxy0721@gmail.com
 executables: []
@@ -74,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Redis cluster-aware client for Ruby
 test_files: []