redis-cluster-client 0.11.0 → 0.13.5

data/lib/redis_client/cluster/transaction.rb

@@ -1,20 +1,25 @@
 # frozen_string_literal: true
 
 require 'redis_client'
+require 'redis_client/cluster/errors'
+require 'redis_client/cluster/noop_command_builder'
 require 'redis_client/cluster/pipeline'
 
 class RedisClient
   class Cluster
     class Transaction
-      ConsistencyError = Class.new(::RedisClient::Error)
+      ConsistencyError = Class.new(::RedisClient::Cluster::Error)
+
       MAX_REDIRECTION = 2
       EMPTY_ARRAY = [].freeze
 
+      private_constant :MAX_REDIRECTION, :EMPTY_ARRAY
+
       def initialize(router, command_builder, node: nil, slot: nil, asking: false)
         @router = router
         @command_builder = command_builder
         @retryable = true
-        @pipeline = ::RedisClient::Pipeline.new(@command_builder)
+        @pipeline = ::RedisClient::Pipeline.new(::RedisClient::Cluster::NoopCommandBuilder)
         @pending_commands = []
         @node = node
         prepare_tx unless @node.nil?
@@ -64,7 +69,7 @@ class RedisClient
         @pending_commands.each(&:call)
 
         return EMPTY_ARRAY if @pipeline._empty?
-        raise ConsistencyError, "couldn't determine the node: #{@pipeline._commands}" if @node.nil?
+        raise ConsistencyError.new("couldn't determine the node: #{@pipeline._commands}").with_config(@router.config) if @node.nil?
 
         commit
       end
@@ -88,24 +93,24 @@ class RedisClient
       end
 
       def prepare_tx
-        @pipeline.call('MULTI')
+        @pipeline.call('multi')
         @pending_commands.each(&:call)
         @pending_commands.clear
       end
 
       def commit
-        @pipeline.call('EXEC')
+        @pipeline.call('exec')
         settle
       end
 
       def cancel
-        @pipeline.call('DISCARD')
+        @pipeline.call('discard')
         settle
       end
 
       def settle
         # If we needed ASKING on the watch, we need ASKING on the multi as well.
-        @node.call('ASKING') if @asking
+        @node.call('asking') if @asking
         # Don't handle redirections at this level if we're in a watch (the watcher handles redirections
         # at the whole-transaction level.)
         send_transaction(@node, redirect: !!@watching_slot ? 0 : MAX_REDIRECTION)
@@ -119,7 +124,7 @@ class RedisClient
         end
       end
 
-      def send_pipeline(client, redirect:)
+      def send_pipeline(client, redirect:) # rubocop:disable Metrics/AbcSize
         replies = client.ensure_connected_cluster_scoped(retryable: @retryable) do |connection|
           commands = @pipeline._commands
           client.middlewares.call_pipelined(commands, client.config) do
@@ -135,6 +140,9 @@ class RedisClient
         return if replies.last.nil?
 
         coerce_results!(replies.last)
+      rescue ::RedisClient::ConnectionError
+        @router.renew_cluster_state if @watching_slot.nil?
+        raise
       end
 
       def coerce_results!(results, offset: 1)
@@ -157,13 +165,16 @@ class RedisClient
 
       def handle_command_error!(err, redirect:) # rubocop:disable Metrics/AbcSize
         if err.message.start_with?('CROSSSLOT')
-          raise ConsistencyError, "#{err.message}: #{err.command}"
+          raise ConsistencyError.new("#{err.message}: #{err.command}").with_config(@router.config)
         elsif err.message.start_with?('MOVED')
           node = @router.assign_redirection_node(err.message)
           send_transaction(node, redirect: redirect - 1)
         elsif err.message.start_with?('ASK')
           node = @router.assign_asking_node(err.message)
           try_asking(node) ? send_transaction(node, redirect: redirect - 1) : err
+        elsif err.message.start_with?('CLUSTERDOWN')
+          @router.renew_cluster_state if @watching_slot.nil?
+          raise err
         else
           raise err
         end
@@ -174,11 +185,11 @@ class RedisClient
         return if slots.size == 1 && @watching_slot.nil?
         return if slots.size == 1 && @watching_slot == slots.first
 
-        raise(ConsistencyError, "the transaction should be executed to a slot in a node: #{commands}")
+        raise ConsistencyError.new("the transaction should be executed to a slot in a node: #{commands}").with_config(@router.config)
       end
 
       def try_asking(node)
-        node.call('ASKING') == 'OK'
+        node.call('asking') == 'OK'
       rescue StandardError
         false
       end

data/lib/redis_client/cluster.rb

@@ -11,13 +11,14 @@ class RedisClient
   class Cluster
     ZERO_CURSOR_FOR_SCAN = '0'
 
+    private_constant :ZERO_CURSOR_FOR_SCAN
+
     attr_reader :config
 
-    def initialize(config, pool: nil, concurrency: nil, **kwargs)
-      @config = config
+    def initialize(config = nil, pool: nil, concurrency: nil, **kwargs)
+      @config = config.nil? ? ClusterConfig.new(**kwargs) : config
       @concurrent_worker = ::RedisClient::Cluster::ConcurrentWorker.create(**(concurrency || {}))
-      @command_builder = config.command_builder
-
+      @command_builder = @config.command_builder
       @pool = pool
       @kwargs = kwargs
       @router = nil
@@ -60,30 +61,37 @@ class RedisClient
     end
 
     def scan(*args, **kwargs, &block)
-      raise ArgumentError, 'block required' unless block
+      return to_enum(__callee__, *args, **kwargs) unless block_given?
 
+      command = @command_builder.generate(['scan', ZERO_CURSOR_FOR_SCAN] + args, kwargs)
       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(command, seed: seed)
+        command[1] = cursor
         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)
+      return to_enum(__callee__, key, *args, **kwargs) unless block_given?
+
+      command = @command_builder.generate(['sscan', key, ZERO_CURSOR_FOR_SCAN] + args, kwargs)
+      router.scan_single_key(command, arity: 1, &block)
     end
 
     def hscan(key, *args, **kwargs, &block)
-      node = router.assign_node(['HSCAN', key])
-      router.try_delegate(node, :hscan, key, *args, **kwargs, &block)
+      return to_enum(__callee__, key, *args, **kwargs) unless block_given?
+
+      command = @command_builder.generate(['hscan', key, ZERO_CURSOR_FOR_SCAN] + args, kwargs)
+      router.scan_single_key(command, arity: 2, &block)
     end
 
     def zscan(key, *args, **kwargs, &block)
-      node = router.assign_node(['ZSCAN', key])
-      router.try_delegate(node, :zscan, key, *args, **kwargs, &block)
+      return to_enum(__callee__, key, *args, **kwargs) unless block_given?
+
+      command = @command_builder.generate(['zscan', key, ZERO_CURSOR_FOR_SCAN] + args, kwargs)
+      router.scan_single_key(command, arity: 2, &block)
     end
 
     def pipelined(exception: true)
@@ -143,8 +151,9 @@ class RedisClient
     end
 
     def method_missing(name, *args, **kwargs, &block)
-      if router.command_exists?(name)
-        args.unshift(name)
+      cmd = name.respond_to?(:name) ? name.name : name.to_s
+      if router.command_exists?(cmd)
+        args.unshift(cmd)
         command = @command_builder.generate(args, kwargs)
         return router.send_command(:call_v, command, &block)
       end

data/lib/redis_client/cluster_config.rb

@@ -3,7 +3,9 @@
 require 'uri'
 require 'redis_client'
 require 'redis_client/cluster'
+require 'redis_client/cluster/errors'
 require 'redis_client/cluster/node_key'
+require 'redis_client/cluster/noop_command_builder'
 require 'redis_client/command_builder'
 
 class RedisClient
@@ -12,21 +14,27 @@ class RedisClient
     DEFAULT_PORT = 6379
     DEFAULT_SCHEME = 'redis'
     SECURE_SCHEME = 'rediss'
-    DEFAULT_NODES = ["#{DEFAULT_SCHEME}://#{DEFAULT_HOST}:#{DEFAULT_PORT}"].freeze
+    DEFAULT_NODE = "#{DEFAULT_SCHEME}://#{DEFAULT_HOST}:#{DEFAULT_PORT}"
+    Ractor.make_shareable(DEFAULT_NODE) if Object.const_defined?(:Ractor, false) && Ractor.respond_to?(:make_shareable)
+    DEFAULT_NODES = [DEFAULT_NODE].freeze
     VALID_SCHEMES = [DEFAULT_SCHEME, SECURE_SCHEME].freeze
     VALID_NODES_KEYS = %i[ssl username password host port db].freeze
     MERGE_CONFIG_KEYS = %i[ssl username password].freeze
     IGNORE_GENERIC_CONFIG_KEYS = %i[url host port path].freeze
-    MAX_WORKERS = Integer(ENV.fetch('REDIS_CLIENT_MAX_THREADS', 5))
+    MAX_WORKERS = Integer(ENV.fetch('REDIS_CLIENT_MAX_THREADS', -1)) # for backward compatibility
     # 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)
+    private_constant :DEFAULT_HOST, :DEFAULT_PORT, :DEFAULT_SCHEME, :SECURE_SCHEME, :DEFAULT_NODES,
+                     :VALID_SCHEMES, :VALID_NODES_KEYS, :MERGE_CONFIG_KEYS, :IGNORE_GENERIC_CONFIG_KEYS,
+                     :MAX_WORKERS, :SLOW_COMMAND_TIMEOUT, :MAX_STARTUP_SAMPLE
+
+    InvalidClientConfigError = Class.new(::RedisClient::Cluster::Error)
 
     attr_reader :command_builder, :client_config, :replica_affinity, :slow_command_timeout,
-                :connect_with_original_config, :startup_nodes, :max_startup_sample
+                :connect_with_original_config, :startup_nodes, :max_startup_sample, :id
 
     def initialize( # rubocop:disable Metrics/ParameterLists
       nodes: DEFAULT_NODES,
@@ -41,7 +49,6 @@ class RedisClient
       max_startup_sample: MAX_STARTUP_SAMPLE,
       **client_config
     )
-
       @replica = true & replica
       @replica_affinity = replica_affinity.to_s.to_sym
       @fixed_hostname = fixed_hostname.to_s
@@ -55,16 +62,25 @@ class RedisClient
       @client_implementation = client_implementation
       @slow_command_timeout = slow_command_timeout
       @max_startup_sample = max_startup_sample
+      @id = client_config[:id]
     end
 
     def inspect
-      "#<#{self.class.name} #{startup_nodes.values}>"
+      "#<#{self.class.name} #{startup_nodes.values.map { |v| v.reject { |k| k == :command_builder } }}>"
+    end
+
+    def connect_timeout
+      @client_config[:connect_timeout] || @client_config[:timeout] || ::RedisClient::Config::DEFAULT_TIMEOUT
     end
 
     def read_timeout
       @client_config[:read_timeout] || @client_config[:timeout] || ::RedisClient::Config::DEFAULT_TIMEOUT
     end
 
+    def write_timeout
+      @client_config[:write_timeout] || @client_config[:timeout] || ::RedisClient::Config::DEFAULT_TIMEOUT
+    end
+
     def new_pool(size: 5, timeout: 5, **kwargs)
       @client_implementation.new(
         self,
@@ -88,15 +104,31 @@ class RedisClient
       augment_client_config(config)
     end
 
+    def resolved?
+      true
+    end
+
+    def sentinel?
+      false
+    end
+
+    def server_url
+      nil
+    end
+
     private
 
     def merge_concurrency_option(option)
-      case option
-      when Hash
-        option = option.transform_keys(&:to_sym)
-        { size: MAX_WORKERS }.merge(option)
-      else { size: MAX_WORKERS }
+      opts = {}
+
+      if MAX_WORKERS.positive?
+        opts[:model] = :on_demand
+        opts[:size] = MAX_WORKERS
       end
+
+      opts.merge!(option.transform_keys(&:to_sym)) if option.is_a?(Hash)
+      opts[:model] = :none if opts.empty?
+      opts.freeze
     end
 
     def build_node_configs(addrs)
@@ -169,6 +201,7 @@ class RedisClient
     def augment_client_config(config)
       config = @client_config.merge(config)
       config = config.merge(host: @fixed_hostname) unless @fixed_hostname.empty?
+      config[:command_builder] = ::RedisClient::Cluster::NoopCommandBuilder # prevent twice call
       config
     end
   end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.13.5
 platform: ruby
 authors:
 - Taishi Kasuga
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-08-19 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -16,15 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.22'
+        version: '0.24'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.22'
-description: 
+        version: '0.24'
 email:
 - proxy0721@gmail.com
 executables: []
@@ -48,7 +46,7 @@ files:
 - lib/redis_client/cluster/node/random_replica.rb
 - lib/redis_client/cluster/node/random_replica_or_primary.rb
 - lib/redis_client/cluster/node_key.rb
-- lib/redis_client/cluster/normalized_cmd_name.rb
+- lib/redis_client/cluster/noop_command_builder.rb
 - lib/redis_client/cluster/optimistic_locking.rb
 - lib/redis_client/cluster/pipeline.rb
 - lib/redis_client/cluster/pub_sub.rb
@@ -62,7 +60,6 @@ licenses:
 metadata:
   rubygems_mfa_required: 'true'
   allowed_push_host: https://rubygems.org
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -77,8 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
-summary: A Redis cluster client for Ruby
+summary: Redis cluster-aware client for Ruby
 test_files: []

data/lib/redis_client/cluster/normalized_cmd_name.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-
-class RedisClient
-  class Cluster
-    class NormalizedCmdName
-      include Singleton
-
-      EMPTY_STRING = ''
-
-      def initialize
-        @cache = {}
-        @mutex = Mutex.new
-      end
-
-      def get_by_command(command)
-        get(command, index: 0)
-      end
-
-      def get_by_subcommand(command)
-        get(command, index: 1)
-      end
-
-      def get_by_name(name)
-        get(name, index: 0)
-      end
-
-      def clear
-        @mutex.synchronize { @cache.clear }
-        true
-      end
-
-      private
-
-      def get(command, index:)
-        name = extract_name(command, index: index)
-        return EMPTY_STRING if name.nil? || name.empty?
-
-        normalize(name)
-      end
-
-      def extract_name(command, index:)
-        case command
-        when String, Symbol then index.zero? ? command : nil
-        when Array then extract_name_from_array(command, index: index)
-        end
-      end
-
-      def extract_name_from_array(command, index:)
-        return if command.size - 1 < index
-
-        case e = command[index]
-        when String, Symbol then e
-        when Array then e[index]
-        end
-      end
-
-      def normalize(name)
-        return @cache[name] || name.to_s.downcase if @cache.key?(name)
-        return name.to_s.downcase if @mutex.locked?
-
-        str = name.to_s.downcase
-        @mutex.synchronize { @cache[name] = str }
-        str
-      end
-    end
-  end
-end