redis-cluster-client 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 367df4e02bcd425f14da73b2ff243dfdb7fd44c6cb565bcc46952b939057904f
-  data.tar.gz: bfdb8033d0695fe0389563ad563c8445f9624e99ef6315e7374ee7f2e440fe40
+  metadata.gz: 5160c83d23cb638fc76cf079377981d6778560ba0eb476da03f58d6f4eded9af
+  data.tar.gz: dd0baec0d24de14e2cba10c4ea3f45af7f1bef2db30f609c9551ed2d13c0bf4a
 SHA512:
-  metadata.gz: 278740e8829a1def72a411552ed7c17d0d265930c81dfc2b967cfa325a74cdbdbd0adb832dacc77e4c86c8316648695b94044cb6fdf3dd3267617d5f18b95ec1
-  data.tar.gz: 007bf587198b7575dabee128c0500700ef0d10c7b699a632023ce4d80fa788d2a88e851748f041ab5f6453350d7de6f9d8c96bcbc798deec7acbf37b2700ea6a
+  metadata.gz: 1cf5c16776bb7ff4c53ffa66e3de3371c1130fed7a4916982e7fba9859ba9ae7505af0bc5e8e02b58f22d116ab74692a4572d835f05672457bac4ddd469e3162
+  data.tar.gz: f08215c00f2b12b00247604917a7f7abc228ddd0e4305c67af38f8e2087a8b3785a22bfbd09ac32f75789719a624be49663f5048f6187318477069e4ef9627a1

data/lib/redis-cluster-client.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'redis_cluster_client'

data/lib/redis_client/cluster/node.rb

@@ -128,9 +128,9 @@ class RedisClient
         @clients.fetch(node_key)
       end
 
-      def call_all(method, *args, **kwargs, &block)
+      def call_all(method, command, args, &block)
         results, errors = try_map do |_, client|
-          client.send(method, *args, **kwargs, &block)
+          client.send(method, *args, command, &block)
         end
 
         return results.values if errors.empty?
@@ -138,11 +138,11 @@ class RedisClient
         raise ::RedisClient::Cluster::ErrorCollection, errors
       end
 
-      def call_primaries(method, *args, **kwargs, &block)
+      def call_primaries(method, command, args, &block)
         results, errors = try_map do |node_key, client|
           next if replica?(node_key)
 
-          client.send(method, *args, **kwargs, &block)
+          client.send(method, *args, command, &block)
         end
 
         return results.values if errors.empty?
@@ -150,14 +150,14 @@ class RedisClient
         raise ::RedisClient::Cluster::ErrorCollection, errors
       end
 
-      def call_replicas(method, *args, **kwargs, &block)
-        return call_primaries(method, *args, **kwargs, &block) if replica_disabled?
+      def call_replicas(method, command, args, &block)
+        return call_primaries(method, command, args, &block) if replica_disabled?
 
         replica_node_keys = @replications.values.map(&:sample)
         results, errors = try_map do |node_key, client|
           next if primary?(node_key) || !replica_node_keys.include?(node_key)
 
-          client.send(method, *args, **kwargs, &block)
+          client.send(method, *args, command, &block)
         end
 
         return results.values if errors.empty?
@@ -165,9 +165,9 @@ class RedisClient
         raise ::RedisClient::Cluster::ErrorCollection, errors
       end
 
-      def send_ping(method, *args, **kwargs, &block)
+      def send_ping(method, command, args, &block)
         results, errors = try_map do |_, client|
-          client.send(method, *args, **kwargs, &block)
+          client.send(method, *args, command, &block)
         end
 
         return results.values if errors.empty?

data/lib/redis_client/cluster/pipeline.rb

@@ -8,27 +8,52 @@ class RedisClient
     class Pipeline
       ReplySizeError = Class.new(::RedisClient::Error)
 
-      def initialize(router)
+      def initialize(router, command_builder)
         @router = router
+        @command_builder = command_builder
         @grouped = Hash.new([].freeze)
         @size = 0
       end
 
-      def call(*command, **kwargs)
-        node_key = @router.find_node_key(*command, primary_only: true, **kwargs)
-        @grouped[node_key] += [[@size, :call, command, kwargs]]
+      def call(*args, **kwargs, &block)
+        command = @command_builder.generate(args, kwargs)
+        node_key = @router.find_node_key(command, primary_only: true)
+        @grouped[node_key] += [[@size, :call_v, command, block]]
         @size += 1
       end
 
-      def call_once(*command, **kwargs)
-        node_key = @router.find_node_key(*command, primary_only: true, **kwargs)
-        @grouped[node_key] += [[@size, :call_once, command, kwargs]]
+      def call_v(args, &block)
+        command = @command_builder.generate(args)
+        node_key = @router.find_node_key(command, primary_only: true)
+        @grouped[node_key] += [[@size, :call_v, command, block]]
         @size += 1
       end
 
-      def blocking_call(timeout, *command, **kwargs)
-        node_key = @router.find_node_key(*command, primary_only: true, **kwargs)
-        @grouped[node_key] += [[@size, :blocking_call, timeout, command, kwargs]]
+      def call_once(*args, **kwargs, &block)
+        command = @command_builder.generate(args, kwargs)
+        node_key = @router.find_node_key(command, primary_only: true)
+        @grouped[node_key] += [[@size, :call_once_v, command, block]]
+        @size += 1
+      end
+
+      def call_once_v(args, &block)
+        command = @command_builder.generate(args)
+        node_key = @router.find_node_key(command, primary_only: true)
+        @grouped[node_key] += [[@size, :call_once_v, command, block]]
+        @size += 1
+      end
+
+      def blocking_call(timeout, *args, **kwargs, &block)
+        command = @command_builder.generate(args, kwargs)
+        node_key = @router.find_node_key(command, primary_only: true)
+        @grouped[node_key] += [[@size, :blocking_call_v, timeout, command, block]]
+        @size += 1
+      end
+
+      def blocking_call_v(timeout, args, &block)
+        command = @command_builder.generate(args)
+        node_key = @router.find_node_key(command, primary_only: true)
+        @grouped[node_key] += [[@size, :blocking_call_v, timeout, command, block]]
         @size += 1
       end
 
@@ -37,20 +62,15 @@ class RedisClient
       end
 
       # TODO: https://github.com/redis-rb/redis-cluster-client/issues/37 handle redirections
-      def execute # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def execute # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
         all_replies = Array.new(@size)
         errors = {}
         threads = @grouped.map do |k, v|
           Thread.new(@router, k, v) do |router, node_key, rows|
             Thread.pass
             replies = router.find_node(node_key).pipelined do |pipeline|
-              rows.each do |row|
-                case row[1]
-                when :call then pipeline.call(*row[2], **row[3])
-                when :call_once then pipeline.call_once(*row[2], **row[3])
-                when :blocking_call then pipeline.blocking_call(row[2], *row[3], **row[4])
-                else raise NotImplementedError, row[1]
-                end
+              rows.each do |(_size, *row, block)|
+                pipeline.send(*row, &block)
               end
             end
 

data/lib/redis_client/cluster/pub_sub.rb

@@ -3,15 +3,24 @@
 class RedisClient
   class Cluster
     class PubSub
-      def initialize(router)
+      def initialize(router, command_builder)
         @router = router
+        @command_builder = command_builder
         @pubsub = nil
       end
 
-      def call(*command, **kwargs)
+      def call(*args, **kwargs)
         close
-        @pubsub = @router.assign_node(*command, **kwargs).pubsub
-        @pubsub.call(*command, **kwargs)
+        command = @command_builder.generate(args, kwargs)
+        @pubsub = @router.assign_node(command).pubsub
+        @pubsub.call_v(command)
+      end
+
+      def call_v(command)
+        close
+        command = @command_builder.generate(command)
+        @pubsub = @router.assign_node(command).pubsub
+        @pubsub.call_v(command)
       end
 
       def close

data/lib/redis_client/cluster/router.rb

@@ -20,40 +20,37 @@ class RedisClient
         @client_kwargs = kwargs
         @node = fetch_cluster_info(@config, pool: @pool, **@client_kwargs)
         @command = ::RedisClient::Cluster::Command.load(@node)
-        @command_builder = @config.command_builder
         @mutex = Mutex.new
+        @command_builder = @config.command_builder
       end
 
-      def send_command(method, *args, **kwargs, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-        command = method == :blocking_call && args.size > 1 ? args[1..] : args
-        command = @command_builder.generate!(command, kwargs)
-
+      def send_command(method, command, *args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         cmd = command.first.to_s.downcase
         case cmd
         when 'acl', 'auth', 'bgrewriteaof', 'bgsave', 'quit', 'save'
-          @node.call_all(method, *args, **kwargs, &block).first
+          @node.call_all(method, command, args, &block).first
         when 'flushall', 'flushdb'
-          @node.call_primaries(method, *args, **kwargs, &block).first
-        when 'ping'     then @node.send_ping(method, *args, **kwargs, &block).first
-        when 'wait'     then send_wait_command(method, *args, **kwargs, &block)
-        when 'keys'     then @node.call_replicas(method, *args, **kwargs, &block).flatten.sort_by(&:to_s)
-        when 'dbsize'   then @node.call_replicas(method, *args, **kwargs, &block).select { |e| e.is_a?(Integer) }.sum
-        when 'scan'     then scan(*command, **kwargs)
-        when 'lastsave' then @node.call_all(method, *args, **kwargs, &block).sort_by(&:to_i)
-        when 'role'     then @node.call_all(method, *args, **kwargs, &block)
-        when 'config'   then send_config_command(method, *args, **kwargs, &block)
-        when 'client'   then send_client_command(method, *args, **kwargs, &block)
-        when 'cluster'  then send_cluster_command(method, *args, **kwargs, &block)
+          @node.call_primaries(method, command, args, &block).first
+        when 'ping'     then @node.send_ping(method, command, args, &block).first
+        when 'wait'     then send_wait_command(method, command, args, &block)
+        when 'keys'     then @node.call_replicas(method, command, args, &block).flatten.sort_by(&:to_s)
+        when 'dbsize'   then @node.call_replicas(method, command, args, &block).select { |e| e.is_a?(Integer) }.sum
+        when 'scan'     then scan(command)
+        when 'lastsave' then @node.call_all(method, command, args, &block).sort_by(&:to_i)
+        when 'role'     then @node.call_all(method, command, args, &block)
+        when 'config'   then send_config_command(method, command, args, &block)
+        when 'client'   then send_client_command(method, command, args, &block)
+        when 'cluster'  then send_cluster_command(method, command, args, &block)
         when 'readonly', 'readwrite', 'shutdown'
           raise ::RedisClient::Cluster::OrchestrationCommandNotSupported, cmd
-        when 'memory'   then send_memory_command(method, *args, **kwargs, &block)
-        when 'script'   then send_script_command(method, *args, **kwargs, &block)
-        when 'pubsub'   then send_pubsub_command(method, *args, **kwargs, &block)
+        when 'memory'   then send_memory_command(method, command, args, &block)
+        when 'script'   then send_script_command(method, command, args, &block)
+        when 'pubsub'   then send_pubsub_command(method, command, args, &block)
         when 'discard', 'exec', 'multi', 'unwatch'
           raise ::RedisClient::Cluster::AmbiguousNodeError, cmd
         else
-          node = assign_node(*command)
-          try_send(node, method, *args, **kwargs, &block)
+          node = assign_node(command)
+          try_send(node, method, command, args, &block)
         end
       rescue ::RedisClient::Cluster::Node::ReloadNeeded
         update_cluster_info!
@@ -67,7 +64,37 @@ class RedisClient
 
       # @see https://redis.io/topics/cluster-spec#redirection-and-resharding
       #   Redirection and resharding
-      def try_send(node, method, *args, retry_count: 3, **kwargs, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def try_send(node, method, command, args, retry_count: 3, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        node.send(method, *args, command, &block)
+      rescue ::RedisClient::CommandError => e
+        raise if retry_count <= 0
+
+        if e.message.start_with?('MOVED')
+          node = assign_redirection_node(e.message)
+          retry_count -= 1
+          retry
+        elsif e.message.start_with?('ASK')
+          node = assign_asking_node(e.message)
+          node.call('ASKING')
+          retry_count -= 1
+          retry
+        elsif e.message.start_with?('CLUSTERDOWN Hash slot not served')
+          update_cluster_info!
+          retry_count -= 1
+          retry
+        else
+          raise
+        end
+      rescue ::RedisClient::ConnectionError => e
+        raise if method == :blocking_call_v || (method == :blocking_call && e.is_a?(RedisClient::ReadTimeoutError))
+        raise if retry_count <= 0
+
+        update_cluster_info!
+        retry_count -= 1
+        retry
+      end
+
+      def try_delegate(node, method, *args, retry_count: 3, **kwargs, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         node.send(method, *args, **kwargs, &block)
       rescue ::RedisClient::CommandError => e
         raise if retry_count <= 0
@@ -97,7 +124,7 @@ class RedisClient
       end
 
       def scan(*command, **kwargs) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-        command = @command_builder.generate!(command, kwargs)
+        command = @command_builder.generate(command, kwargs)
 
         command[1] = ZERO_CURSOR_FOR_SCAN if command.size == 1
         input_cursor = Integer(command[1])
@@ -112,7 +139,7 @@ class RedisClient
 
         command[1] = raw_cursor.to_s
 
-        result_cursor, result_keys = client.call(*command, **kwargs)
+        result_cursor, result_keys = client.call_v(command)
         result_cursor = Integer(result_cursor)
 
         client_index += 1 if result_cursor == 0
@@ -120,14 +147,12 @@ class RedisClient
         [((result_cursor << 8) + client_index).to_s, result_keys]
       end
 
-      def assign_node(*command, **kwargs)
-        node_key = find_node_key(*command, **kwargs)
+      def assign_node(command, primary_only: false)
+        node_key = find_node_key(command, primary_only: primary_only)
         find_node(node_key)
       end
 
-      def find_node_key(*command, primary_only: false, **kwargs)
-        command = @command_builder.generate!(command, kwargs)
-
+      def find_node_key(command, primary_only: false)
         key = @command.extract_first_key(command)
         slot = key.empty? ? nil : ::RedisClient::Cluster::KeySlotConverter.convert(key)
 
@@ -154,8 +179,8 @@ class RedisClient
 
       private
 
-      def send_wait_command(method, *args, retry_count: 3, **kwargs, &block)
-        @node.call_primaries(method, *args, **kwargs, &block).select { |r| r.is_a?(Integer) }.sum
+      def send_wait_command(method, command, args, retry_count: 3, &block)
+        @node.call_primaries(method, command, args, &block).select { |r| r.is_a?(Integer) }.sum
       rescue ::RedisClient::Cluster::ErrorCollection => e
         raise if retry_count <= 0
         raise if e.errors.values.none? do |err|
@@ -167,82 +192,65 @@ class RedisClient
         retry
       end
 
-      def send_config_command(method, *args, **kwargs, &block)
-        command = method == :blocking_call && args.size > 1 ? args[1..] : args
-        command = @command_builder.generate!(command, kwargs)
-
+      def send_config_command(method, command, args, &block)
         case command[1].to_s.downcase
         when 'resetstat', 'rewrite', 'set'
-          @node.call_all(method, *args, **kwargs, &block).first
-        else assign_node(*command).send(method, *args, **kwargs, &block)
+          @node.call_all(method, command, args, &block).first
+        else assign_node(command).send(method, *args, command, &block)
         end
       end
 
-      def send_memory_command(method, *args, **kwargs, &block)
-        command = method == :blocking_call && args.size > 1 ? args[1..] : args
-        command = @command_builder.generate!(command, kwargs)
-
+      def send_memory_command(method, command, args, &block)
         case command[1].to_s.downcase
-        when 'stats' then @node.call_all(method, *args, **kwargs, &block)
-        when 'purge' then @node.call_all(method, *args, **kwargs, &block).first
-        else assign_node(*command).send(method, *args, **kwargs, &block)
+        when 'stats' then @node.call_all(method, command, args, &block)
+        when 'purge' then @node.call_all(method, command, args, &block).first
+        else assign_node(command).send(method, *args, command, &block)
         end
       end
 
-      def send_client_command(method, *args, **kwargs, &block)
-        command = method == :blocking_call && args.size > 1 ? args[1..] : args
-        command = @command_builder.generate!(command, kwargs)
-
+      def send_client_command(method, command, args, &block)
         case command[1].to_s.downcase
-        when 'list' then @node.call_all(method, *args, **kwargs, &block).flatten
+        when 'list' then @node.call_all(method, command, args, &block).flatten
         when 'pause', 'reply', 'setname'
-          @node.call_all(method, *args, **kwargs, &block).first
-        else assign_node(*command).send(method, *args, **kwargs, &block)
+          @node.call_all(method, command, args, &block).first
+        else assign_node(command).send(method, *args, command, &block)
         end
       end
 
-      def send_cluster_command(method, *args, **kwargs, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-        command = method == :blocking_call && args.size > 1 ? args[1..] : args
-        command = @command_builder.generate!(command, kwargs)
+      def send_cluster_command(method, command, args, &block) # rubocop:disable Metrics/MethodLength
         subcommand = command[1].to_s.downcase
 
         case subcommand
         when 'addslots', 'delslots', 'failover', 'forget', 'meet', 'replicate',
              'reset', 'set-config-epoch', 'setslot'
           raise ::RedisClient::Cluster::OrchestrationCommandNotSupported, ['cluster', subcommand]
-        when 'saveconfig' then @node.call_all(method, *args, **kwargs, &block).first
+        when 'saveconfig' then @node.call_all(method, command, args, &block).first
         when 'getkeysinslot'
           raise ArgumentError, command.join(' ') if command.size != 4
 
-          find_node(@node.find_node_key_of_replica(command[2])).send(method, *args, **kwargs, &block)
-        else assign_node(*command).send(method, *args, **kwargs, &block)
+          find_node(@node.find_node_key_of_replica(command[2])).send(method, *args, command, &block)
+        else assign_node(command).send(method, *args, command, &block)
         end
       end
 
-      def send_script_command(method, *args, **kwargs, &block)
-        command = method == :blocking_call && args.size > 1 ? args[1..] : args
-        command = @command_builder.generate!(command, kwargs)
-
+      def send_script_command(method, command, args, &block)
         case command[1].to_s.downcase
         when 'debug', 'kill'
-          @node.call_all(method, *args, **kwargs, &block).first
+          @node.call_all(method, command, args, &block).first
         when 'flush', 'load'
-          @node.call_primaries(method, *args, **kwargs, &block).first
-        else assign_node(*command).send(method, *args, **kwargs, &block)
+          @node.call_primaries(method, command, args, &block).first
+        else assign_node(command).send(method, *args, command, &block)
         end
       end
 
-      def send_pubsub_command(method, *args, **kwargs, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        command = method == :blocking_call && args.size > 1 ? args[1..] : args
-        command = @command_builder.generate!(command, kwargs)
-
+      def send_pubsub_command(method, command, args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         case command[1].to_s.downcase
-        when 'channels' then @node.call_all(method, *args, **kwargs, &block).flatten.uniq.sort_by(&:to_s)
+        when 'channels' then @node.call_all(method, command, args, &block).flatten.uniq.sort_by(&:to_s)
         when 'numsub'
-          @node.call_all(method, *args, **kwargs, &block).reject(&:empty?).map { |e| Hash[*e] }
+          @node.call_all(method, command, args, &block).reject(&:empty?).map { |e| Hash[*e] }
                .reduce({}) { |a, e| a.merge(e) { |_, v1, v2| v1 + v2 } }
-        when 'numpat' then @node.call_all(method, *args, **kwargs, &block).select { |e| e.is_a?(Integer) }.sum
-        else assign_node(*command).send(method, *args, **kwargs, &block)
+        when 'numpat' then @node.call_all(method, command, args, &block).select { |e| e.is_a?(Integer) }.sum
+        else assign_node(command).send(method, *args, command, &block)
         end
       end
 
@@ -269,7 +277,7 @@ class RedisClient
       def update_cluster_info!
         @mutex.synchronize do
           begin
-            @node.call_all(:close)
+            @node.each(&:close)
           rescue ::RedisClient::Cluster::ErrorCollection
             # ignore
           end

data/lib/redis_client/cluster.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'redis_client'
 require 'redis_client/cluster/pipeline'
 require 'redis_client/cluster/pub_sub'
 require 'redis_client/cluster/router'
@@ -9,24 +8,46 @@ class RedisClient
   class Cluster
     ZERO_CURSOR_FOR_SCAN = '0'
 
+    attr_reader :config
+
     def initialize(config, pool: nil, **kwargs)
+      @config = config
       @router = ::RedisClient::Cluster::Router.new(config, pool: pool, **kwargs)
+      @command_builder = config.command_builder
     end
 
     def inspect
       "#<#{self.class.name} #{@router.node.node_keys.join(', ')}>"
     end
 
-    def call(*command, **kwargs, &block)
-      @router.send_command(:call, *command, **kwargs, &block)
+    def call(*args, **kwargs, &block)
+      command = @command_builder.generate(args, kwargs)
+      @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)
+    end
+
+    def call_once(*args, **kwargs, &block)
+      command = @command_builder.generate(args, kwargs)
+      @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)
     end
 
-    def call_once(*command, **kwargs, &block)
-      @router.send_command(:call_once, *command, **kwargs, &block)
+    def blocking_call(timeout, *args, **kwargs, &block)
+      command = @command_builder.generate(args, kwargs)
+      @router.send_command(:blocking_call_v, command, timeout, &block)
     end
 
-    def blocking_call(timeout, *command, **kwargs, &block)
-      @router.send_command(:blocking_call, timeout, *command, **kwargs, &block)
+    def blocking_call_v(timeout, command, &block)
+      command = @command_builder.generate(command)
+      @router.send_command(:blocking_call_v, command, timeout, &block)
     end
 
     def scan(*args, **kwargs, &block)
@@ -41,22 +62,22 @@ class RedisClient
     end
 
     def sscan(key, *args, **kwargs, &block)
-      node = @router.assign_node('SSCAN', key)
-      @router.try_send(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_send(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_send(node, :zscan, key, *args, **kwargs, &block)
+      node = @router.assign_node(['ZSCAN', key])
+      @router.try_delegate(node, :zscan, key, *args, **kwargs, &block)
     end
 
     def pipelined
-      pipeline = ::RedisClient::Cluster::Pipeline.new(@router)
+      pipeline = ::RedisClient::Cluster::Pipeline.new(@router, @command_builder)
       yield pipeline
       return [] if pipeline.empty? == 0
 
@@ -64,11 +85,11 @@ class RedisClient
     end
 
     def pubsub
-      ::RedisClient::Cluster::PubSub.new(@router)
+      ::RedisClient::Cluster::PubSub.new(@router, @command_builder)
     end
 
     def close
-      @router.node.call_all(:close)
+      @router.node.each(&:close)
       nil
     end
 
@@ -77,7 +98,8 @@ class RedisClient
     def method_missing(name, *args, **kwargs, &block)
       if @router.command_exists?(name)
         args.unshift(name)
-        return @router.send_command(:call, *args, **kwargs, &block)
+        command = @command_builder.generate(args, kwargs)
+        return @router.send_command(:call_v, command, &block)
       end
 
       super

data/lib/redis_client/cluster_config.rb

@@ -20,15 +20,16 @@ class RedisClient
 
     InvalidClientConfigError = Class.new(::RedisClient::Error)
 
-    attr_reader :command_builder
+    attr_reader :command_builder, :client_config
 
-    def initialize(nodes: DEFAULT_NODES, replica: false, fixed_hostname: '', **client_config)
+    def initialize(nodes: DEFAULT_NODES, replica: false, client_implementation: Cluster, fixed_hostname: '', **client_config)
       @replica = true & replica
       @fixed_hostname = fixed_hostname.to_s
       @node_configs = build_node_configs(nodes.dup)
       client_config = client_config.reject { |k, _| IGNORE_GENERIC_CONFIG_KEYS.include?(k) }
       @command_builder = client_config.fetch(:command_builder, ::RedisClient::CommandBuilder)
       @client_config = merge_generic_config(client_config, @node_configs)
+      @client_implementation = client_implementation
       @mutex = Mutex.new
     end
 
@@ -36,12 +37,16 @@ class RedisClient
       "#<#{self.class.name} #{per_node_key.values}>"
     end
 
+    def read_timeout
+      @client_config[:read_timeout] || @client_config[:timeout] || RedisClient::Config::DEFAULT_TIMEOUT
+    end
+
     def new_pool(size: 5, timeout: 5, **kwargs)
-      ::RedisClient::Cluster.new(self, pool: { size: size, timeout: timeout }, **kwargs)
+      @client_implementation.new(self, pool: { size: size, timeout: timeout }, **kwargs)
     end
 
     def new_client(**kwargs)
-      ::RedisClient::Cluster.new(self, **kwargs)
+      @client_implementation.new(self, **kwargs)
     end
 
     def per_node_key

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-02 00:00:00.000000000 Z
+date: 2022-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.6'
 description:
 email:
 - proxy0721@gmail.com
@@ -31,6 +31,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/redis-cluster-client.rb
 - lib/redis_client/cluster.rb
 - lib/redis_client/cluster/command.rb
 - lib/redis_client/cluster/errors.rb