redis-cluster-client 0.16.2 → 0.16.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8d639d8939c9fdf304fa0f61886c1274f6e1c08bcd9e213dae3c7e0d844be02
-  data.tar.gz: 6f540ce88572df689c8a3e3971e3e96054b09b9fee7ef53c9aa518566ec3dd75
+  metadata.gz: 80b5e1d6525a06ecf8747239269b110528bf9efc99ff3424108033c85cdc011a
+  data.tar.gz: 35b5aba54bc61e3731509c7ba3959289ddcfb30e40193f365fc26f62f4c7e60d
 SHA512:
-  metadata.gz: 7d9c164a6590fb0ab3fa43328b484f8919895f17d3a6d5a9114c0c7b1a7867864be6d8e12ae1af45cdc81d39b9aa590e8c088de878ab964c18d9ae6f3c58682d
-  data.tar.gz: 01c0503f5f75d2441bdd2ea71537114c380db552e00ed8b130b0330626440f58a0d94bf94974dc044f4aebca9e024c931635dd8cbe5c96e225c80a7e10120840
+  metadata.gz: ab546dc6dc75d1ec1733c5cd5f29a451881d71db8c21e587be92ab77c2f12f602100468626b742a1d87caa98aa27699906f9aefd7d9cff02512c3be1e355bdd4
+  data.tar.gz: 741326d16416834940e08c7084019080188d3e6b252c6dafdf3037bb9a40e2f9aafc0dc771fce7ac4edbb50af6d630067fb3646f4e7f1016ab72d7ceafb04940

data/lib/redis_client/cluster/command.rb

@@ -9,18 +9,57 @@ class RedisClient
     class Command
       EMPTY_STRING = ''
       EMPTY_HASH = {}.freeze
-      EMPTY_ARRAY = [].freeze
 
-      private_constant :EMPTY_STRING, :EMPTY_HASH, :EMPTY_ARRAY
+      private_constant :EMPTY_HASH
 
-      Detail = Struct.new(
-        'RedisCommand',
+      Spec = Struct.new(
+        'RedisCommandSpec',
         :first_key_position,
         :key_step,
         :write?,
         :readonly?,
         keyword_init: true
-      )
+      ) do
+        def extract_first_key(command)
+          i = first_key_position.to_i
+          return command[i] if i > 0
+
+          i = determine_first_key_position(command)
+          return ::RedisClient::Cluster::Command::EMPTY_STRING if i == 0
+
+          command[i]
+        end
+
+        def should_send_to_primary?
+          write?
+        end
+
+        def should_send_to_replica?
+          readonly?
+        end
+
+        private
+
+        def determine_first_key_position(command) # rubocop:disable Metrics/AbcSize
+          cmd_name = command.first
+          if cmd_name.casecmp('xread').zero?
+            determine_optional_key_position(command, 'streams')
+          elsif cmd_name.casecmp('xreadgroup').zero?
+            determine_optional_key_position(command, 'streams')
+          elsif cmd_name.casecmp('migrate').zero?
+            command[3].empty? ? determine_optional_key_position(command, 'keys') : 3
+          elsif cmd_name.casecmp('memory').zero?
+            command[1].to_s.casecmp('usage').zero? ? 2 : 0
+          else
+            0
+          end
+        end
+
+        def determine_optional_key_position(command, option_name)
+          i = command.index { |v| v.to_s.casecmp(option_name).zero? }
+          i.nil? ? 0 : i + 1
+        end
+      end
 
       class << self
         def load(nodes, slow_command_timeout: -1) # rubocop:disable Metrics/AbcSize
@@ -65,7 +104,7 @@ class RedisClient
                        else row[2].include?('write')
                        end
 
-            acc[row.first] = ::RedisClient::Cluster::Command::Detail.new(
+            acc[row.first] = ::RedisClient::Cluster::Command::Spec.new(
               first_key_position: pos,
               key_step: row[5],
               write?: writable,
@@ -79,53 +118,13 @@ class RedisClient
         @commands = commands || EMPTY_HASH
       end
 
-      def extract_first_key(command)
-        i = determine_first_key_position(command)
-        return EMPTY_STRING if i == 0
-
-        command[i]
-      end
-
-      def should_send_to_primary?(command)
-        find_command_info(command.first)&.write?
-      end
-
-      def should_send_to_replica?(command)
-        find_command_info(command.first)&.readonly?
+      def get_spec(name)
+        @commands[name] || @commands[name.to_s.downcase(:ascii)]
       end
 
       def exists?(name)
         @commands.key?(name) || @commands.key?(name.to_s.downcase(:ascii))
       end
-
-      private
-
-      def find_command_info(name)
-        @commands[name] || @commands[name.to_s.downcase(:ascii)]
-      end
-
-      def determine_first_key_position(command) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
-        i = find_command_info(command.first)&.first_key_position.to_i
-        return i if i > 0
-
-        cmd_name = command.first
-        if cmd_name.casecmp('xread').zero?
-          determine_optional_key_position(command, 'streams')
-        elsif cmd_name.casecmp('xreadgroup').zero?
-          determine_optional_key_position(command, 'streams')
-        elsif cmd_name.casecmp('migrate').zero?
-          command[3].empty? ? determine_optional_key_position(command, 'keys') : 3
-        elsif cmd_name.casecmp('memory').zero?
-          command[1].to_s.casecmp('usage').zero? ? 2 : 0
-        else
-          i
-        end
-      end
-
-      def determine_optional_key_position(command, option_name)
-        i = command.index { |v| v.to_s.casecmp(option_name).zero? }
-        i.nil? ? 0 : i + 1
-      end
     end
   end
 end

data/lib/redis_client/cluster/concurrent_worker/none.rb

@@ -3,17 +3,57 @@
 class RedisClient
   class Cluster
     module ConcurrentWorker
-      class None
-        def new_group(size:)
-          ::RedisClient::Cluster::ConcurrentWorker::Group.new(
-            worker: self,
-            queue: [],
-            size: size
+      module None
+        class Group
+          Task = Struct.new(
+            'RedisClusterClientSingleThreadTask',
+            :id, :result, keyword_init: true
           )
+
+          def initialize(size:)
+            @tasks = Array.new(size)
+            @idx = 0
+          end
+
+          def push(id, *args, **kwargs, &block)
+            raise InvalidNumberOfTasks, "max size reached: #{@idx}" if @idx == @tasks.size
+
+            result = exec(*args, **kwargs, &block)
+            @tasks[@idx] = Task.new(id: id, result: result)
+            @idx += 1
+            nil
+          end
+
+          def each
+            raise InvalidNumberOfTasks, "expected: #{@tasks.size}, actual: #{@idx}" if @idx != @tasks.size
+
+            @tasks.each { |task| yield(task.id, task.result) }
+            nil
+          end
+
+          def close
+            @idx = 0
+            @tasks.clear
+            nil
+          end
+
+          def inspect
+            "#<#{self.class.name} size: #{@idx}, max: #{@tasks.size}>"
+          end
+
+          private
+
+          def exec(*args, **kwargs)
+            yield(*args, **kwargs) if block_given?
+          rescue StandardError => e
+            e
+          end
         end
 
-        def push(task)
-          task.exec
+        module_function
+
+        def new_group(size:)
+          Group.new(size: size)
         end
 
         def close; end

data/lib/redis_client/cluster/concurrent_worker.rb

@@ -73,7 +73,7 @@ class RedisClient
 
       def create(model: :none, size: 5)
         case model
-        when :none then ::RedisClient::Cluster::ConcurrentWorker::None.new
+        when :none then ::RedisClient::Cluster::ConcurrentWorker::None
         when :on_demand then ::RedisClient::Cluster::ConcurrentWorker::OnDemand.new(size: size)
         when :pooled then ::RedisClient::Cluster::ConcurrentWorker::Pooled.new(size: size)
         else raise ArgumentError, "unknown model: #{model}"

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

@@ -25,8 +25,7 @@ class RedisClient
         end
 
         def any_primary_node_key(seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
-          @primary_node_keys.sample(random: random)
+          @primary_node_keys.sample(random: make_random(seed))
         end
 
         def process_topology_update!(replications, options) # rubocop:disable Metrics/AbcSize
@@ -59,6 +58,11 @@ class RedisClient
             @clients[node_key] = client
           end
         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)
+        end
       end
     end
   end

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

@@ -20,8 +20,7 @@ class RedisClient
         end
 
         def any_replica_node_key(seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
-          @existed_replicas.sample(random: random)&.first || any_primary_node_key(seed: seed)
+          @existed_replicas.sample(random: make_random(seed))&.first || any_primary_node_key(seed: seed)
         end
 
         def process_topology_update!(replications, options)

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

@@ -18,8 +18,7 @@ class RedisClient
         end
 
         def any_primary_node_key(seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
-          @primary_node_keys.sample(random: random)
+          @primary_node_keys.sample(random: make_random(seed))
         end
 
         alias any_replica_node_key any_primary_node_key

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

@@ -12,7 +12,7 @@ class RedisClient
         end
 
         def clients_for_scanning(seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
+          random = make_random(seed)
           keys = @replications.map do |primary_node_key, replica_node_keys|
             replica_node_keys.empty? ? primary_node_key : replica_node_keys.sample(random: random)
           end
@@ -21,13 +21,13 @@ class RedisClient
         end
 
         def find_node_key_of_replica(primary_node_key, seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
-          @replications.fetch(primary_node_key, EMPTY_ARRAY).sample(random: random) || primary_node_key
+          replica_node_keys = @replications.fetch(primary_node_key, EMPTY_ARRAY)
+          replica_node_key = replica_node_keys.size <= 1 ? replica_node_keys.first : replica_node_keys.sample(random: make_random(seed))
+          replica_node_key || primary_node_key
         end
 
         def any_replica_node_key(seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
-          @replica_node_keys.sample(random: random) || any_primary_node_key(seed: seed)
+          @replica_node_keys.sample(random: make_random(seed)) || any_primary_node_key(seed: seed)
         end
       end
     end

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

@@ -12,7 +12,7 @@ class RedisClient
         end
 
         def clients_for_scanning(seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
+          random = make_random(seed)
           keys = @replications.map do |primary_node_key, replica_node_keys|
             decide_use_primary?(random, replica_node_keys.size) ? primary_node_key : replica_node_keys.sample(random: random)
           end
@@ -21,7 +21,7 @@ class RedisClient
         end
 
         def find_node_key_of_replica(primary_node_key, seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
+          random = make_random(seed)
 
           replica_node_keys = @replications.fetch(primary_node_key, EMPTY_ARRAY)
           if decide_use_primary?(random, replica_node_keys.size)
@@ -32,8 +32,7 @@ class RedisClient
         end
 
         def any_replica_node_key(seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
-          @replica_node_keys.sample(random: random) || any_primary_node_key(seed: seed)
+          @replica_node_keys.sample(random: make_random(seed)) || any_primary_node_key(seed: seed)
         end
 
         private

data/lib/redis_client/cluster/node.rb

@@ -412,13 +412,13 @@ class RedisClient
           primary_id = nodes.find { |n| n.fetch('role') == 'master' }.fetch('id')
 
           nodes.each do |node|
-            ip = node.fetch('ip')
-            next if node.fetch('health') != 'online' || ip.nil? || ip.empty? || ip == '?'
+            host = pick_shard_host(node)
+            next if node.fetch('health') != 'online' || host.nil? || host.empty? || host == '?'
 
             role = node.fetch('role')
             acc << ::RedisClient::Cluster::Node::Info.new(
               id: node.fetch('id'),
-              node_key: NodeKey.build_from_host_port(ip, node['port'] || node['tls-port']),
+              node_key: NodeKey.build_from_host_port(host, node['port'] || node['tls-port']),
               role: role == 'master' ? role : 'slave',
               primary_id: role == 'master' ? EMPTY_STRING : primary_id,
               slots: role == 'master' ? shard.fetch('slots').each_slice(2).to_a.freeze : EMPTY_ARRAY
@@ -427,6 +427,25 @@ class RedisClient
         end
       end
 
+      # Pick the host for a CLUSTER SHARDS node entry.
+      #
+      # `endpoint` is the server-selected preferred endpoint (driven by the
+      # `cluster-preferred-endpoint-type` config), so prefer it when present and
+      # usable. Some managed services (e.g. AWS ElastiCache Serverless) report
+      # `127.0.0.1` in `ip` while exposing the reachable address only via
+      # `endpoint` / `hostname`; falling through to `ip` in that case would build
+      # an unreachable topology. This mirrors the precedence `parse_node_key`
+      # uses for CLUSTER NODES output (see #207).
+      def pick_shard_host(node)
+        endpoint = node['endpoint']
+        return endpoint if endpoint && !endpoint.empty? && endpoint != '?'
+
+        hostname = node['hostname']
+        return hostname if hostname && !hostname.empty?
+
+        node['ip']
+      end
+
       # As redirection node_key is dependent on `cluster-preferred-endpoint-type` config,
       # node_key should use hostname if present in CLUSTER NODES output.
       #

data/lib/redis_client/cluster/pipeline.rb

@@ -230,10 +230,10 @@ class RedisClient
 
       def append_pipeline(node_key)
         @pipelines ||= {}
-        @pipelines[node_key] ||= ::RedisClient::Cluster::Pipeline::Extended.new(::RedisClient::Cluster::NoopCommandBuilder)
-        @pipelines[node_key].add_outer_index(@size)
+        pi = (@pipelines[node_key] ||= ::RedisClient::Cluster::Pipeline::Extended.new(::RedisClient::Cluster::NoopCommandBuilder))
+        pi.add_outer_index(@size)
         @size += 1
-        @pipelines[node_key]
+        pi
       end
 
       def do_pipelining(client, pipeline)

data/lib/redis_client/cluster/router.rb

@@ -246,23 +246,27 @@ class RedisClient
       end
 
       def find_node_key(command, seed: nil)
-        key = @command.extract_first_key(command)
-        find_node_key_by_key(key, seed: seed, primary: @command.should_send_to_primary?(command))
+        cmd_spec = @command.get_spec(command.first)
+        find_node_key_by_key(
+          cmd_spec&.extract_first_key(command),
+          seed: seed,
+          primary: cmd_spec&.should_send_to_primary?
+        )
       end
 
       def find_primary_node_key(command)
-        key = @command.extract_first_key(command)
-        return nil unless key&.size&.> 0
+        key = @command.get_spec(command.first)&.extract_first_key(command)
+        return unless key&.size&.> 0
 
         find_node_key_by_key(key, primary: true)
       end
 
       def find_slot(command)
-        find_slot_by_key(@command.extract_first_key(command))
+        find_slot_by_key(@command.get_spec(command.first)&.extract_first_key(command))
       end
 
       def find_slot_by_key(key)
-        return if key.empty?
+        return if key.nil? || key.empty?
 
         ::RedisClient::Cluster::KeySlotConverter.convert(key)
       end
@@ -467,8 +471,13 @@ class RedisClient
 
         return assign_node_and_send_command(method, command, args, &block) if command.size <= keys_step + 1 || ::RedisClient::Cluster::KeySlotConverter.hash_tag_included?(command[1])
 
-        seed = @config.use_replica? && @config.replica_affinity == :random ? nil : Random.new_seed
-        pipeline = ::RedisClient::Cluster::Pipeline.new(self, @command_builder, @concurrent_worker, exception: true, seed: seed)
+        pipeline = ::RedisClient::Cluster::Pipeline.new(
+          self,
+          @command_builder,
+          @concurrent_worker,
+          exception: true,
+          seed: Random.new_seed
+        )
 
         single_command = Array.new(keys_step + 1)
         single_command[0] = single_key_cmd

data/lib/redis_client/cluster.rb

@@ -95,13 +95,12 @@ class RedisClient
     end
 
     def pipelined(exception: true)
-      seed = @config.use_replica? && @config.replica_affinity == :random ? nil : Random.new_seed
       pipeline = ::RedisClient::Cluster::Pipeline.new(
         router,
         @command_builder,
         @concurrent_worker,
         exception: exception,
-        seed: seed
+        seed: Random.new_seed
       )
 
       yield pipeline

metadata

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