redis-cluster-client 0.9.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75b8f7550c743c813f79d15ba60d5e78fe5e81c751854b5600cc1984b56256fa
-  data.tar.gz: c560f4fb9a3e5e044a64c8b8c0da8bf51413d384dd19d069994f14f44e4d4055
+  metadata.gz: d885c147de46fd113d493e60bd340cac591ecc94b7eafcfddbd6044abe10f79a
+  data.tar.gz: f13c1012ef977e8f9c3e38d928c5c3eb95ba2242761fa992033323c115b318f9
 SHA512:
-  metadata.gz: 5165edd2f2ae4c27680be76227cc73ed1b5e5c17914dc08eb6f9015199d29bb14f0c4961f5a291c3e764b78dfee3892e6666fff6aca95bc466eab144d4ce43d4
-  data.tar.gz: 91f09f17897dcd974f11001cd2ea0445a384cb83134d8b51835ad197835ee4710935253e024fd6c938f12fa10bb8daea56465ac7f522a6e2484ec25f942fcb0d
+  metadata.gz: 68c939431088425c7735c68b4af0949bc5918837d9f19878c62d71aa1fec6e31efee5de2868325447a9e4672c108299a86cc6d047447ef10e7987daa04ecb1e9
+  data.tar.gz: f8ae784f6977151fd825c34878e7f6162175cd828d0b81a92da07e5af96a00a56467ffbed3822f24c198f2373900dc20ea69f8446e3468fc7ba54945baa44f65

data/lib/redis_client/cluster/command.rb

@@ -97,12 +97,6 @@ class RedisClient
         @commands.key?(::RedisClient::Cluster::NormalizedCmdName.instance.get_by_name(name))
       end
 
-      def determine_key_step(command)
-        name = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
-        # Some commands like EVALSHA have zero as the step in COMMANDS somehow.
-        @commands[name].key_step == 0 ? 1 : @commands[name].key_step
-      end
-
       private
 
       def determine_first_key_position(command) # rubocop:disable Metrics/CyclomaticComplexity
@@ -153,6 +147,12 @@ class RedisClient
         idx = command&.flatten&.map(&:to_s)&.map(&:downcase)&.index(option_name&.downcase)
         idx.nil? ? 0 : idx + 1
       end
+
+      def determine_key_step(command)
+        name = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
+        # Some commands like EVALSHA have zero as the step in COMMANDS somehow.
+        @commands[name].key_step == 0 ? 1 : @commands[name].key_step
+      end
     end
   end
 end

data/lib/redis_client/cluster/node.rb

@@ -13,9 +13,6 @@ class RedisClient
     class Node
       include Enumerable
 
-      # It affects to strike a balance between load and stability in initialization or changed states.
-      MAX_STARTUP_SAMPLE = Integer(ENV.fetch('REDIS_CLIENT_MAX_STARTUP_SAMPLE', 3))
-
       # less memory consumption, but slow
       USE_CHAR_ARRAY_SLOT = Integer(ENV.fetch('REDIS_CLIENT_USE_CHAR_ARRAY_SLOT', 1)) == 1
 
@@ -197,7 +194,7 @@ class RedisClient
 
       def reload!
         with_reload_lock do
-          with_startup_clients(MAX_STARTUP_SAMPLE) do |startup_clients|
+          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)]

data/lib/redis_client/cluster/router.rb

@@ -18,11 +18,6 @@ class RedisClient
     class Router
       ZERO_CURSOR_FOR_SCAN = '0'
       TSF = ->(f, x) { f.nil? ? x : f.call(x) }.curry
-      MULTIPLE_KEYS_COMMAND_TO_PIPELINE = {
-        'mset' => 'set',
-        'mget' => 'get',
-        'del' => 'del'
-      }.freeze
 
       def initialize(config, concurrent_worker, pool: nil, **kwargs)
         @config = config.dup
@@ -334,27 +329,31 @@ class RedisClient
         end
       end
 
+      MULTIPLE_KEYS_COMMAND_TO_SINGLE = {
+        'mget' => ['get', 1].freeze,
+        'mset' => ['set', 2].freeze,
+        'del' => ['del', 1].freeze
+      }.freeze
+
       def send_multiple_keys_command(cmd, method, command, args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        key_step = @command.determine_key_step(cmd)
-        if command.size <= key_step + 1 || ::RedisClient::Cluster::KeySlotConverter.hash_tag_included?(command[1]) # rubocop:disable Style/IfUnlessModifier
-          return try_send(assign_node(command), method, command, args, &block)
-        end
+        # This implementation is prioritized performance rather than readability or so.
+        single_key_cmd, keys_step = MULTIPLE_KEYS_COMMAND_TO_SINGLE.fetch(cmd)
+
+        return try_send(assign_node(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)
 
-        # This implementation is prioritized to lessen memory consumption rather than readability.
-        single_key_cmd = MULTIPLE_KEYS_COMMAND_TO_PIPELINE[cmd]
-        single_command = Array.new(key_step + 1)
+        single_command = Array.new(keys_step + 1)
         single_command[0] = single_key_cmd
-        if key_step == 1
+        if keys_step == 1
           command[1..].each do |key|
             single_command[1] = key
             pipeline.call_v(single_command)
           end
         else
-          command[1..].each_slice(key_step) do |v|
-            key_step.times { |i| single_command[i + 1] = v[i] }
+          command[1..].each_slice(keys_step) do |v|
+            keys_step.times { |i| single_command[i + 1] = v[i] }
             pipeline.call_v(single_command)
           end
         end

data/lib/redis_client/cluster.rb

@@ -16,42 +16,47 @@ class RedisClient
     def initialize(config, pool: nil, concurrency: nil, **kwargs)
       @config = config
       @concurrent_worker = ::RedisClient::Cluster::ConcurrentWorker.create(**(concurrency || {}))
-      @router = ::RedisClient::Cluster::Router.new(config, @concurrent_worker, pool: pool, **kwargs)
       @command_builder = config.command_builder
+
+      @pool = pool
+      @kwargs = kwargs
+      @router = nil
+      @mutex = Mutex.new
     end
 
     def inspect
-      "#<#{self.class.name} #{@router.node_keys.join(', ')}>"
+      node_keys = @router.nil? ? @config.startup_nodes.keys : router.node_keys
+      "#<#{self.class.name} #{node_keys.join(', ')}>"
     end
 
     def call(*args, **kwargs, &block)
       command = @command_builder.generate(args, kwargs)
-      @router.send_command(:call_v, command, &block)
+      router.send_command(:call_v, command, &block)
     end
 
     def call_v(command, &block)
       command = @command_builder.generate(command)
-      @router.send_command(:call_v, command, &block)
+      router.send_command(:call_v, command, &block)
     end
 
     def call_once(*args, **kwargs, &block)
       command = @command_builder.generate(args, kwargs)
-      @router.send_command(:call_once_v, command, &block)
+      router.send_command(:call_once_v, command, &block)
     end
 
     def call_once_v(command, &block)
       command = @command_builder.generate(command)
-      @router.send_command(:call_once_v, command, &block)
+      router.send_command(:call_once_v, command, &block)
     end
 
     def blocking_call(timeout, *args, **kwargs, &block)
       command = @command_builder.generate(args, kwargs)
-      @router.send_command(:blocking_call_v, command, timeout, &block)
+      router.send_command(:blocking_call_v, command, timeout, &block)
     end
 
     def blocking_call_v(timeout, command, &block)
       command = @command_builder.generate(command)
-      @router.send_command(:blocking_call_v, command, timeout, &block)
+      router.send_command(:blocking_call_v, command, timeout, &block)
     end
 
     def scan(*args, **kwargs, &block)
@@ -60,31 +65,31 @@ class RedisClient
       seed = Random.new_seed
       cursor = ZERO_CURSOR_FOR_SCAN
       loop do
-        cursor, keys = @router.scan('SCAN', cursor, *args, seed: seed, **kwargs)
+        cursor, keys = router.scan('SCAN', cursor, *args, seed: seed, **kwargs)
         keys.each(&block)
         break if cursor == ZERO_CURSOR_FOR_SCAN
       end
     end
 
     def sscan(key, *args, **kwargs, &block)
-      node = @router.assign_node(['SSCAN', key])
-      @router.try_delegate(node, :sscan, key, *args, **kwargs, &block)
+      node = router.assign_node(['SSCAN', key])
+      router.try_delegate(node, :sscan, key, *args, **kwargs, &block)
     end
 
     def hscan(key, *args, **kwargs, &block)
-      node = @router.assign_node(['HSCAN', key])
-      @router.try_delegate(node, :hscan, key, *args, **kwargs, &block)
+      node = router.assign_node(['HSCAN', key])
+      router.try_delegate(node, :hscan, key, *args, **kwargs, &block)
     end
 
     def zscan(key, *args, **kwargs, &block)
-      node = @router.assign_node(['ZSCAN', key])
-      @router.try_delegate(node, :zscan, key, *args, **kwargs, &block)
+      node = router.assign_node(['ZSCAN', key])
+      router.try_delegate(node, :zscan, key, *args, **kwargs, &block)
     end
 
     def pipelined(exception: true)
       seed = @config.use_replica? && @config.replica_affinity == :random ? nil : Random.new_seed
       pipeline = ::RedisClient::Cluster::Pipeline.new(
-        @router,
+        router,
         @command_builder,
         @concurrent_worker,
         exception: exception,
@@ -99,14 +104,14 @@ class RedisClient
 
     def multi(watch: nil)
       if watch.nil? || watch.empty?
-        transaction = ::RedisClient::Cluster::Transaction.new(@router, @command_builder)
+        transaction = ::RedisClient::Cluster::Transaction.new(router, @command_builder)
         yield transaction
         return transaction.execute
       end
 
-      ::RedisClient::Cluster::OptimisticLocking.new(@router).watch(watch) do |c, slot, asking|
+      ::RedisClient::Cluster::OptimisticLocking.new(router).watch(watch) do |c, slot, asking|
         transaction = ::RedisClient::Cluster::Transaction.new(
-          @router, @command_builder, node: c, slot: slot, asking: asking
+          router, @command_builder, node: c, slot: slot, asking: asking
         )
         yield transaction
         transaction.execute
@@ -114,7 +119,7 @@ class RedisClient
     end
 
     def pubsub
-      ::RedisClient::Cluster::PubSub.new(@router, @command_builder)
+      ::RedisClient::Cluster::PubSub.new(router, @command_builder)
     end
 
     def with(...)
@@ -122,25 +127,33 @@ class RedisClient
     end
 
     def close
+      @router&.close
       @concurrent_worker.close
-      @router.close
       nil
     end
 
     private
 
+    def router
+      return @router unless @router.nil?
+
+      @mutex.synchronize do
+        @router ||= ::RedisClient::Cluster::Router.new(@config, @concurrent_worker, pool: @pool, **@kwargs)
+      end
+    end
+
     def method_missing(name, *args, **kwargs, &block)
-      if @router.command_exists?(name)
+      if router.command_exists?(name)
         args.unshift(name)
         command = @command_builder.generate(args, kwargs)
-        return @router.send_command(:call_v, command, &block)
+        return router.send_command(:call_v, command, &block)
       end
 
       super
     end
 
     def respond_to_missing?(name, include_private = false)
-      return true if @router.command_exists?(name)
+      return true if router.command_exists?(name)
 
       super
     end

data/lib/redis_client/cluster_config.rb

@@ -20,13 +20,15 @@ class RedisClient
     MAX_WORKERS = Integer(ENV.fetch('REDIS_CLIENT_MAX_THREADS', 5))
     # It's used with slow queries of fetching meta data like CLUSTER NODES, COMMAND and so on.
     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.
+    MAX_STARTUP_SAMPLE = Integer(ENV.fetch('REDIS_CLIENT_MAX_STARTUP_SAMPLE', 3))
 
     InvalidClientConfigError = Class.new(::RedisClient::Error)
 
     attr_reader :command_builder, :client_config, :replica_affinity, :slow_command_timeout,
-                :connect_with_original_config, :startup_nodes
+                :connect_with_original_config, :startup_nodes, :max_startup_sample
 
-    def initialize(
+    def initialize( # rubocop:disable Metrics/ParameterLists
       nodes: DEFAULT_NODES,
       replica: false,
       replica_affinity: :random,
@@ -36,6 +38,7 @@ class RedisClient
       client_implementation: ::RedisClient::Cluster, # for redis gem
       slow_command_timeout: SLOW_COMMAND_TIMEOUT,
       command_builder: ::RedisClient::CommandBuilder,
+      max_startup_sample: MAX_STARTUP_SAMPLE,
       **client_config
     )
 
@@ -51,6 +54,7 @@ class RedisClient
       @connect_with_original_config = connect_with_original_config
       @client_implementation = client_implementation
       @slow_command_timeout = slow_command_timeout
+      @max_startup_sample = max_startup_sample
     end
 
     def inspect

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.11.0
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-05-04 00:00:00.000000000 Z
+date: 2024-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -77,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.11
 signing_key: 
 specification_version: 4
 summary: A Redis cluster client for Ruby