redis-cluster-client 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97383b0daf1dcc2e5fcd8e50640e9ecbd903562a10cca0f4996ada1807469f80
-  data.tar.gz: 675ae25f2fbf2d9d67234b4e1ad81894656f11a32fe4cd1ebf8ae73c90c67509
+  metadata.gz: f88b4bd96fd24566377d49a45a06eaa5fc8029749462995e746074979ba25e70
+  data.tar.gz: a5ecd1339399ba2dda3c004c1cf1bbb2e2510c2f963f0f69afcf71544a8b530c
 SHA512:
-  metadata.gz: 851565ace738fb9bf51d1211ece97767520c94a7b02e49b053732de351d77a30e7104ae1f8143a0ee3903a2b99de39b298b3eec80c2fb94b08fb4747180bb03d
-  data.tar.gz: 0a0b6ada72bccfcdb7cecda533f8f31761f15f991e359bc211a4d54ba973b2c68983efd3a9a594e7baab11b614fecb058de98b71f1890f7e52150f40e2c34d1b
+  metadata.gz: 81b1776f48d1b84866c21e0f00ee644df2f077e06536a6af2b305e50104296b7dabeb9732cce51e0aaca6ce5111a406b21b14db8c114d56e2b3f8f4b7701f2f7
+  data.tar.gz: b2ecb424e00825a115d15808814ee58a7afc06205cf5ca1e4732ca7189a6b9d42d13597974fa8674ca6f1102aa13641d8b7b25883bcea9ede743e2df3dba4814

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/key_slot_converter.rb

@@ -70,6 +70,17 @@ class RedisClient
 
         key[s + 1..e - 1]
       end
+
+      def hash_tag_included?(key)
+        key = key.to_s
+        s = key.index(LEFT_BRACKET)
+        return false if s.nil?
+
+        e = key.index(RIGHT_BRACKET, s + 1)
+        return false if e.nil?
+
+        s + 1 < e
+      end
     end
   end
 end

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.extract_hash_tag(command[1]).empty? # 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-05-02 00:00:00.000000000 Z
+date: 2024-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client