redis-cluster-client 0.16.2 → 0.16.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8d639d8939c9fdf304fa0f61886c1274f6e1c08bcd9e213dae3c7e0d844be02
-  data.tar.gz: 6f540ce88572df689c8a3e3971e3e96054b09b9fee7ef53c9aa518566ec3dd75
+  metadata.gz: 5c16432e083671229128632c116401dc9b1bd56f6b3b1e3c8f107956901d29f2
+  data.tar.gz: b464a6f87e8c952a5e4f5b22d0609a9be09b3c6c7817eb91ed779e0b142a4290
 SHA512:
-  metadata.gz: 7d9c164a6590fb0ab3fa43328b484f8919895f17d3a6d5a9114c0c7b1a7867864be6d8e12ae1af45cdc81d39b9aa590e8c088de878ab964c18d9ae6f3c58682d
-  data.tar.gz: 01c0503f5f75d2441bdd2ea71537114c380db552e00ed8b130b0330626440f58a0d94bf94974dc044f4aebca9e024c931635dd8cbe5c96e225c80a7e10120840
+  metadata.gz: 0b94204a193f0bfe56c75da819651c8c16c72bd9620c51996f2dcfc8b2c7faefc416c342ca7631772c96d4fec7a9e7c8aede9638c28fb540855603b829a1042d
+  data.tar.gz: 6d873858848aa00124a043efce6ee8fdd629516e8c5447802b079636de1dd4782b0584c84d791ed0bc7c589d66c273e985878cdea238054e60f1a5a5a2ce72c9

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(
+      Spec = Struct.new(
         'RedisCommand',
         :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, &block)
+            block&.call(*args, **kwargs)
+          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/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.3
 platform: ruby
 authors:
 - Taishi Kasuga