redis-cluster-client 0.0.11 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7c3e9a3b764d9e5fc52670d17c175ee9ccda2dcd56b4a977b0e9a1e0b71d972
-  data.tar.gz: 191e1fe163f6f2fd111e4b2f69638aa28462d74e002f1ff0a11fc0f52cc740cd
+  metadata.gz: 5160c83d23cb638fc76cf079377981d6778560ba0eb476da03f58d6f4eded9af
+  data.tar.gz: dd0baec0d24de14e2cba10c4ea3f45af7f1bef2db30f609c9551ed2d13c0bf4a
 SHA512:
-  metadata.gz: a42c6a871302686e33026ed570575d5b51637b707501609fdf9e574a5a976e06af388bc69bebd5bb22a58a30741c4b3e43d883d154782675446ce88c49ac2b37
-  data.tar.gz: e2ae0a6dd3af75407cc4d795492afff75e5bc7c01fee84be2ef0761e67dda0d9f93cc103b99219bd1b5e8df9dc3ff1dc86b3406c3a23dc1d011b649c363ab163
+  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/command.rb

@@ -55,6 +55,10 @@ class RedisClient
         dig_details(command, :readonly)
       end
 
+      def exists?(name)
+        @details.key?(name.to_s.downcase)
+      end
+
       private
 
       def pick_details(details)

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)
-        @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)
-        @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)
-        @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).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

@@ -21,46 +21,80 @@ class RedisClient
         @node = fetch_cluster_info(@config, pool: @pool, **@client_kwargs)
         @command = ::RedisClient::Cluster::Command.load(@node)
         @mutex = Mutex.new
+        @command_builder = @config.command_builder
       end
 
-      def send_command(method, *args, **kwargs, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-        command = method == :blocking_call && args.size > 1 ? args[1..] : args
-
+      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
-        when 'dbsize'   then @node.call_replicas(method, *args, **kwargs, &block).sum
-        when 'scan'     then scan(*command, **kwargs)
-        when 'lastsave' then @node.call_all(method, *args, **kwargs, &block).sort
-        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!
         raise ::RedisClient::Cluster::NodeMightBeDown
+      rescue ::RedisClient::Cluster::ErrorCollection => e
+        update_cluster_info! if e.errors.values.any? do |err|
+          err.message.start_with?('CLUSTERDOWN Hash slot not served')
+        end
+        raise
       end
 
       # @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
@@ -74,6 +108,10 @@ class RedisClient
           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
@@ -86,6 +124,8 @@ class RedisClient
       end
 
       def scan(*command, **kwargs) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        command = @command_builder.generate(command, kwargs)
+
         command[1] = ZERO_CURSOR_FOR_SCAN if command.size == 1
         input_cursor = Integer(command[1])
 
@@ -99,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
@@ -107,12 +147,12 @@ class RedisClient
         [((result_cursor << 8) + client_index).to_s, result_keys]
       end
 
-      def assign_node(*command)
-        node_key = find_node_key(*command)
+      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)
+      def find_node_key(command, primary_only: false)
         key = @command.extract_first_key(command)
         slot = key.empty? ? nil : ::RedisClient::Cluster::KeySlotConverter.convert(key)
 
@@ -133,10 +173,14 @@ class RedisClient
         retry
       end
 
+      def command_exists?(name)
+        @command.exists?(name)
+      end
+
       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|
@@ -148,76 +192,65 @@ class RedisClient
         retry
       end
 
-      def send_config_command(method, *args, **kwargs, &block)
-        command = method == :blocking_call && args.size > 1 ? args[1..] : args
-
+      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
-
+      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
-
+      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
+      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
-
+      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
-
+      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
+        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).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
 
@@ -244,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)
-      @router.send_command(:call, *command, **kwargs)
+    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)
-      @router.send_command(:call_once, *command, **kwargs)
+    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)
-      @router.send_command(:blocking_call, timeout, *command, **kwargs)
+    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,12 +85,30 @@ 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
+
+    private
+
+    def method_missing(name, *args, **kwargs, &block)
+      if @router.command_exists?(name)
+        args.unshift(name)
+        command = @command_builder.generate(args, kwargs)
+        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)
+
+      super
+    end
   end
 end

data/lib/redis_client/cluster_config.rb

@@ -4,6 +4,7 @@ require 'uri'
 require 'redis_client'
 require 'redis_client/cluster'
 require 'redis_client/cluster/node_key'
+require 'redis_client/command_builder'
 
 class RedisClient
   class ClusterConfig
@@ -19,12 +20,16 @@ class RedisClient
 
     InvalidClientConfigError = Class.new(::RedisClient::Error)
 
-    def initialize(nodes: DEFAULT_NODES, replica: false, fixed_hostname: '', **client_config)
+    attr_reader :command_builder, :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
 
@@ -32,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.0.11
+  version: 0.2.0
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-27 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