redis-client 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bd28ab66722c23791118818d83505de8cbc1b141c75959f2408b8a0c90cb6ad
-  data.tar.gz: 30f85f2bb0df340facd9a743f63dcfd2ff8fa8b8a3e363c9fdeb2f1101d5d076
+  metadata.gz: 05e24d8136cd8dc878d579c850297b1a016133447fd1f6135bd29dba55cd764e
+  data.tar.gz: 9f67aa59e1dfe2370f5f786ef3dea8076abe172301d263a13624b65cb2ab3888
 SHA512:
-  metadata.gz: 528b4cd6f9377f083a19ca1da7b117625ad32c1849c8cc53d795dc5af8e6d23c372fdb5714c043b7c796a6fcfda54ef28ee0142268846445cbfb60e00eabf625
-  data.tar.gz: af0040e6a5cf498587818b5161122d57e3057a39a22d0eb5fc8252e4cb56e71ad61c0a381fbe35c75cd6f5e5e2998169487e33b74f7635f7e025f6e06d7351ca
+  metadata.gz: 2e18d178c2d520073189c71f643c7da18f46f7324c75c8757fc28a8673599064c1678186b4a6833beacf40068498cb5bf19dc6175040caedc8e9286b13e079c2
+  data.tar.gz: d682b304d13901199f71e3c77561eb6562d7dddeae37068e9a20c0e8383a7c12bfbd5c1b250a506990425f126884a5f8946ea7df335bf31ee89713df187b3490

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Unreleased
 
+# 0.6.0
+
+- Added `protocol: 2` options to talk with Redis 5 and older servers.
+- Added `_v` versions of `call` methods to make it easier to pass commands as arrays without splating.
+- Fix calling `blocking_call` with a block in a pipeline.
+- `blocking_call` now raise `ReadTimeoutError` if the command didn't complete in time.
+- Fix `blocking_call` to not respect `retry_attempts` on timeout.
+- Stop parsing RESP3 sets as Ruby Set instances.
+- Fix `SystemStackError` when parsing very large hashes. Fix: #30
+- `hiredis` now more properly release the GVL when doing IOs.
+
+# 0.5.1
+
+- Fix a regression in the `scan` familly of methods, they would raise with `ArgumentError: can't issue an empty redis command`. Fix: #24
+
+# 0.5.0
+
+- Fix handling of connection URLs with empty passwords (`redis://:pass@example.com`).
+- Handle URLs with IPv6 hosts.
+- Add `RedisClient::Config#server_url` as a quick way to identify which server the client is pointing to.
+- Add `CommandError#command` to expose the command that caused the error.
+- Raise a more explicit error when connecting to older redises without RESP3 support (5.0 and older).
+- Properly reject empty commands early.
+
 # 0.4.0
 
 - The `hiredis` driver have been moved to the `hiredis-client` gem.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    redis-client (0.4.0)
+    redis-client (0.6.0)
       connection_pool
 
 GEM

data/README.md

@@ -2,7 +2,7 @@
 
 `redis-client` is a simple, low-level, client for Redis 6+.
 
-Contrary to the `redis` gem, `redis-client` doesn't try to map all redis commands to Ruby constructs,
+Contrary to the `redis` gem, `redis-client` doesn't try to map all Redis commands to Ruby constructs,
 it merely is a thin wrapper on top of the RESP3 protocol.
 
 ## Installation
@@ -63,7 +63,7 @@ redis.call("GET", "mykey")
 ### Configuration
 
 - `url`: A Redis connection URL, e.g. `redis://example.com:6379/5`, a `rediss://` scheme enable SSL, and the path is interpreted as a database number.
-  Note tht all other configurtions take precedence, e.g. `RedisClient.config(url: "redis://localhost:3000" port: 6380)` will connect on port `6380`.
+  Note that all other configurations take precedence, e.g. `RedisClient.config(url: "redis://localhost:3000" port: 6380)` will connect on port `6380`.
 - `host`: The server hostname or IP address. Defaults to `"localhost"`.
 - `port`: The server port. Defaults to `6379`.
 - `path`: The path to a UNIX socket, if set `url`, `host` and `port` are ignored.
@@ -81,6 +81,7 @@ redis.call("GET", "mykey")
 - `read_timeout`: The read timeout, takes precedence over the general timeout when reading responses from the server.
 - `write_timeout`: The write timeout, takes precedence over the general timeout when sending commands to the server.
 - `reconnect_attempts`: Specify how many times the client should retry to send queries. Defaults to `0`. Makes sure to read the [reconnection section](#reconnection) before enabling it.
+- `protocol:` The version of the RESP protocol to use. Default to `3`.
 
 ### Sentinel support
 
@@ -142,7 +143,7 @@ is equivalent to:
 redis.call("LPUSH", "list", "1", "2", "3", "4")
 ```
 
-Hashes are flatenned as well:
+Hashes are flattened as well:
 
 ```ruby
 redis.call("HMSET", "hash", { "foo" => "1", "bar" => "2" })
@@ -154,7 +155,7 @@ is equivalent to:
 redis.call("HMSET", "hash", "foo", "1", "bar", "2")
 ```
 
-Any other type requires the caller to explictly cast the argument as a string.
+Any other type requires the caller to explicitly cast the argument as a string.
 
 Keywords arguments are treated as Redis command flags:
 
@@ -170,7 +171,7 @@ redis.call("SET", "mykey", "value", "nx", "ex", "60")
 redis.call("SET", "mykey", "value")
 ```
 
-If flags are built dynamically, you'll have to explictly pass them as keyword arguments with `**`:
+If flags are built dynamically, you'll have to explicitly pass them as keyword arguments with `**`:
 
 ```ruby
 flags = {}
@@ -185,7 +186,7 @@ unclosed hash literals with string keys may be interpreted differently:
 redis.call("HMSET", "hash", "foo" => "bar")
 ```
 
-On Ruby 2 `"foo" => "bar"` will be passed as a postional argument, but on Ruby 3 it will be interpreted as keyword
+On Ruby 2 `"foo" => "bar"` will be passed as a positional argument, but on Ruby 3 it will be interpreted as keyword
 arguments. To avoid such problem, make sure to enclose hash literals:
 
 ```ruby
@@ -196,7 +197,7 @@ redis.call("HMSET", "hash", { "foo" => "bar" })
 
 Contrary to the `redis` gem, `redis-client` doesn't do any type casting on the return value of commands.
 
-If you wish to cast the return value, you can pass a block to the `#call` familly of methods:
+If you wish to cast the return value, you can pass a block to the `#call` family of methods:
 
 ```ruby
 redis.call("INCR", "counter") # => 1
@@ -207,6 +208,16 @@ redis.call("EXISTS", "counter") # => 1
 redis.call("EXISTS", "counter") { |c| c > 0 } # => true
 ```
 
+### `*_v` methods
+
+In some it's more convenient to pass commands as arrays, for that `_v` versions of `call` methods are available.
+
+```ruby
+redis.call_v(["MGET"] + keys)
+redis.blocking_call_v(1, ["MGET"] + keys)
+redis.call_once_v(1, ["MGET"] + keys)
+```
+
 ### Blocking commands
 
 For blocking commands such as `BRPOP`, a custom timeout duration can be passed as first argument of the `#blocking_call` method:
@@ -215,7 +226,7 @@ For blocking commands such as `BRPOP`, a custom timeout duration can be passed a
 redis.blocking_call(timeout, "BRPOP", "key", 0)
 ```
 
-If `timeout` is reached, `#blocking_call` returns `nil`.
+If `timeout` is reached, `#blocking_call` raises `RedisClient::ReadTimeoutError` and doesn't retry regardless of the `reconnect_attempts` configuration.
 
 `timeout` is expressed in seconds, you can pass `false` or `0` to mean no timeout.
 
@@ -297,7 +308,7 @@ end
 
 If the transaction wasn't successful, `#multi` will return `nil`.
 
-Note that transactions using optimistic locking aren't automatically retried uppon connection errors.
+Note that transactions using optimistic locking aren't automatically retried upon connection errors.
 
 ### Publish / Subscribe
 

data/Rakefile

@@ -107,8 +107,8 @@ end
 
 if hiredis_supported
   task default: %i[compile test rubocop]
-  task ci: %i[compile test]
+  task ci: %i[compile test:ruby test:hiredis]
 else
   task default: %i[test rubocop]
-  task ci: %i[test]
+  task ci: %i[test:ruby]
 end

data/lib/redis_client/command_builder.rb

@@ -5,19 +5,17 @@ class RedisClient
     extend self
 
     if Symbol.method_defined?(:name)
-      def generate!(args, kwargs)
+      def generate(args, kwargs = nil)
         command = args.flat_map do |element|
           case element
           when Hash
             element.flatten
-          when Set
-            element.to_a
           else
             element
           end
         end
 
-        kwargs.each do |key, value|
+        kwargs&.each do |key, value|
           if value
             if value == true
               command << key.name
@@ -40,22 +38,24 @@ class RedisClient
           end
         end
 
+        if command.empty?
+          raise ArgumentError, "can't issue an empty redis command"
+        end
+
         command
       end
     else
-      def generate!(args, kwargs)
+      def generate(args, kwargs = nil)
         command = args.flat_map do |element|
           case element
           when Hash
             element.flatten
-          when Set
-            element.to_a
           else
             element
           end
         end
 
-        kwargs.each do |key, value|
+        kwargs&.each do |key, value|
           if value
             if value == true
               command << key.to_s
@@ -76,6 +76,10 @@ class RedisClient
           end
         end
 
+        if command.empty?
+          raise ArgumentError, "can't issue an empty redis command"
+        end
+
         command
       end
     end

data/lib/redis_client/config.rb

@@ -12,8 +12,8 @@ class RedisClient
     DEFAULT_DB = 0
 
     module Common
-      attr_reader :db, :username, :password, :id, :ssl, :ssl_params, :command_builder,
-        :connect_timeout, :read_timeout, :write_timeout, :driver, :connection_prelude
+      attr_reader :db, :password, :id, :ssl, :ssl_params, :command_builder,
+        :connect_timeout, :read_timeout, :write_timeout, :driver, :connection_prelude, :protocol
 
       alias_method :ssl?, :ssl
 
@@ -29,10 +29,12 @@ class RedisClient
         ssl: nil,
         ssl_params: nil,
         driver: nil,
+        protocol: 3,
+        client_implementation: RedisClient,
         command_builder: CommandBuilder,
         reconnect_attempts: false
       )
-        @username = username || DEFAULT_USERNAME
+        @username = username
         @password = password
         @db = db || DEFAULT_DB
         @id = id
@@ -45,14 +47,23 @@ class RedisClient
 
         @driver = driver ? RedisClient.driver(driver) : RedisClient.default_driver
 
+        @client_implementation = client_implementation
+        @protocol = protocol
+        unless protocol == 2 || protocol == 3
+          raise ArgumentError, "Unknown protocol version #{protocol.inspect}, expected 2 or 3"
+        end
+
         @command_builder = command_builder
 
         reconnect_attempts = Array.new(reconnect_attempts, 0).freeze if reconnect_attempts.is_a?(Integer)
         @reconnect_attempts = reconnect_attempts
-
         @connection_prelude = build_connection_prelude
       end
 
+      def username
+        @username || DEFAULT_USERNAME
+      end
+
       def sentinel?
         false
       end
@@ -63,7 +74,7 @@ class RedisClient
       end
 
       def new_client(**kwargs)
-        RedisClient.new(self, **kwargs)
+        @client_implementation.new(self, **kwargs)
       end
 
       def retry_connecting?(attempt, _error)
@@ -79,17 +90,33 @@ class RedisClient
       end
 
       def ssl_context
-        @ssl_context ||= @driver.ssl_context(@ssl_params)
+        @ssl_context ||= @driver.ssl_context(@ssl_params || {})
+      end
+
+      def server_url
+        if path
+          "#{path}/#{db}"
+        else
+          "redis#{'s' if ssl?}://#{host}:#{port}/#{db}"
+        end
       end
 
       private
 
       def build_connection_prelude
         prelude = []
-        prelude <<  if @password
-          ["HELLO", "3", "AUTH", @username, @password]
-        else
-          ["HELLO", "3"]
+        if protocol == 3
+          prelude << if @password
+            ["HELLO", "3", "AUTH", @username || DEFAULT_USERNAME, @password]
+          else
+            ["HELLO", "3"]
+          end
+        elsif @password
+          prelude << if @username && !@username.empty?
+            ["AUTH", @username, @password]
+          else
+            ["AUTH", @password]
+          end
         end
 
         if @db && @db != 0
@@ -110,15 +137,15 @@ class RedisClient
       path: nil,
       **kwargs
     )
-      uri = url && URI.parse(url)
-      if uri
+      if url
+        uri = URI.parse(url)
         kwargs[:ssl] = uri.scheme == "rediss" unless kwargs.key?(:ssl)
 
-        kwargs[:username] ||= uri.user && uri.password
+        kwargs[:username] ||= uri.user if uri.password && !uri.user.empty?
 
         kwargs[:password] ||= if uri.user && !uri.password
           URI.decode_www_form_component(uri.user)
-        elsif uri&.user && uri&.password
+        elsif uri.user && uri.password
           URI.decode_www_form_component(uri.password)
         end
 
@@ -127,8 +154,8 @@ class RedisClient
 
       super(**kwargs)
 
-      @host = host || uri&.host || DEFAULT_HOST
-      @port = port || uri&.port || DEFAULT_PORT
+      @host = host || uri&.host&.sub(/\A\[(.*)\]\z/, '\1') || DEFAULT_HOST
+      @port = Integer(port || uri&.port || DEFAULT_PORT)
       @path = path
     end
   end

data/lib/redis_client/connection_mixin.rb

@@ -6,6 +6,7 @@ class RedisClient
       write(command)
       result = read(timeout)
       if result.is_a?(CommandError)
+        result._set_command(command)
         raise result
       else
         result
@@ -23,6 +24,7 @@ class RedisClient
         timeout = timeouts && timeouts[index]
         result = read(timeout)
         if result.is_a?(CommandError)
+          result._set_command(commands[index])
           exception ||= result
         end
         results[index] = result

data/lib/redis_client/decorator.rb

@@ -20,7 +20,7 @@ class RedisClient
         @client = client
       end
 
-      %i(call call_once blocking_call).each do |method|
+      %i(call call_v call_once call_once_v blocking_call blocking_call_v).each do |method|
         class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
           def #{method}(*args, &block)
             @client.#{method}(*args, &block)
@@ -64,7 +64,7 @@ class RedisClient
         RUBY
       end
 
-      %i(id config size connect_timeout read_timeout write_timeout).each do |reader|
+      %i(id config size connect_timeout read_timeout write_timeout pubsub).each do |reader|
         class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
           def #{reader}
             @client.#{reader}

data/lib/redis_client/pooled.rb

@@ -49,7 +49,7 @@ class RedisClient
       pool.size
     end
 
-    methods = %w(pipelined multi pubsub call call_once blocking_call)
+    methods = %w(pipelined multi pubsub call call_v call_once call_once_v blocking_call blocking_call_v)
     iterable_methods = %w(scan sscan hscan zscan)
     begin
       methods.each do |method|

data/lib/redis_client/ruby_connection/resp3.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 class RedisClient
   module RESP3
     module_function
@@ -41,8 +39,6 @@ class RedisClient
         case element
         when Hash
           element.flatten
-        when Set
-          element.to_a
         else
           element
         end
@@ -55,7 +51,7 @@ class RedisClient
     end
 
     def new_buffer
-      String.new(encoding: Encoding::BINARY, capacity: 128)
+      String.new(encoding: Encoding::BINARY, capacity: 127)
     end
 
     def dump_any(object, buffer)
@@ -144,11 +140,15 @@ class RedisClient
     end
 
     def parse_set(io)
-      parse_sequence(io, parse_integer(io)).to_set
+      parse_sequence(io, parse_integer(io))
     end
 
     def parse_map(io)
-      Hash[*parse_sequence(io, parse_integer(io) * 2)]
+      hash = {}
+      parse_integer(io).times do
+        hash[parse(io)] = parse(io)
+      end
+      hash
     end
 
     def parse_push(io)
@@ -156,6 +156,8 @@ class RedisClient
     end
 
     def parse_sequence(io, size)
+      return if size < 0 # RESP2 nil
+
       array = Array.new(size)
       size.times do |index|
         array[index] = parse(io)
@@ -185,6 +187,8 @@ class RedisClient
 
     def parse_blob(io)
       bytesize = parse_integer(io)
+      return if bytesize < 0 # RESP2 nil type
+
       str = io.read_chomp(bytesize)
       str.force_encoding(Encoding.default_external)
       str.force_encoding(Encoding::BINARY) unless str.valid_encoding?

data/lib/redis_client/ruby_connection.rb

@@ -60,9 +60,9 @@ class RedisClient
         loop do
           case status = socket.connect_nonblock(exception: false)
           when :wait_readable
-            socket.to_io.wait_readable(connect_timeout) or raise ReadTimeoutError
+            socket.to_io.wait_readable(connect_timeout) or raise CannotConnectError
           when :wait_writable
-            socket.to_io.wait_writable(connect_timeout) or raise WriteTimeoutError
+            socket.to_io.wait_writable(connect_timeout) or raise CannotConnectError
           when socket
             break
           else
@@ -76,10 +76,8 @@ class RedisClient
         read_timeout: read_timeout,
         write_timeout: write_timeout,
       )
-    rescue Errno::ETIMEDOUT => error
-      raise ConnectTimeoutError, error.message
     rescue SystemCallError, OpenSSL::SSL::SSLError, SocketError => error
-      raise ConnectionError, error.message
+      raise CannotConnectError, error.message, error.backtrace
     end
 
     def connected?
@@ -125,6 +123,8 @@ class RedisClient
       else
         @io.with_timeout(timeout) { RESP3.load(@io) }
       end
+    rescue RedisClient::RESP3::UnknownType => error
+      raise RedisClient::ProtocolError, error.message
     rescue SystemCallError, IOError, OpenSSL::SSL::SSLError => error
       raise ConnectionError, error.message
     end

data/lib/redis_client/sentinel_config.rb

@@ -12,8 +12,21 @@ class RedisClient
         raise ArgumentError, "Expected role to be either :master or :replica, got: #{role.inspect}"
       end
 
+      @to_list_of_hash = @to_hash = nil
+      extra_config = {}
+      if client_config[:protocol] == 2
+        extra_config[:protocol] = client_config[:protocol]
+        @to_list_of_hash = lambda do |may_be_a_list|
+          if may_be_a_list.is_a?(Array)
+            may_be_a_list.map { |l| l.each_slice(2).to_h }
+          else
+            may_be_a_list
+          end
+        end
+      end
+
       @name = name
-      @sentinel_configs = sentinels.map { |s| Config.new(**s) }
+      @sentinel_configs = sentinels.map { |s| Config.new(**extra_config, **s) }
       @sentinels = {}.compare_by_identity
       @role = role
       @mutex = Mutex.new
@@ -90,7 +103,10 @@ class RedisClient
           return Config.new(host: host, port: Integer(port), **@client_config)
         end
       end
-      raise ConnectionError, "Couldn't locate a master for role: #{@name}"
+    rescue ConnectionError
+      raise ConnectionError, "No sentinels available"
+    else
+      raise ConnectionError, "Couldn't locate a replica for role: #{@name}"
     end
 
     def sentinel_client(sentinel_config)
@@ -99,13 +115,16 @@ class RedisClient
 
     def resolve_replica
       each_sentinel do |sentinel_client|
-        replicas = sentinel_client.call("SENTINEL", "replicas", @name)
+        replicas = sentinel_client.call("SENTINEL", "replicas", @name, &@to_list_of_hash)
         next if replicas.empty?
 
         replica = replicas.reject { |r| r["flags"].to_s.split(",").include?("disconnected") }.sample
         replica ||= replicas.sample
         return Config.new(host: replica["ip"], port: Integer(replica["port"]), **@client_config)
       end
+    rescue ConnectionError
+      raise ConnectionError, "No sentinels available"
+    else
       raise ConnectionError, "Couldn't locate a replica for role: #{@name}"
     end
 

data/lib/redis_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class RedisClient
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/lib/redis_client.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 require "redis_client/version"
 require "redis_client/command_builder"
 require "redis_client/config"
@@ -78,17 +76,22 @@ class RedisClient
 
   Error = Class.new(StandardError)
 
+  ProtocolError = Class.new(Error)
+  UnsupportedServer = Class.new(Error)
+
   ConnectionError = Class.new(Error)
+  CannotConnectError = Class.new(ConnectionError)
 
   FailoverError = Class.new(ConnectionError)
 
   TimeoutError = Class.new(ConnectionError)
   ReadTimeoutError = Class.new(TimeoutError)
   WriteTimeoutError = Class.new(TimeoutError)
-  ConnectTimeoutError = Class.new(TimeoutError)
-  CheckoutTimeoutError = Class.new(ConnectTimeoutError)
+  CheckoutTimeoutError = Class.new(TimeoutError)
 
   class CommandError < Error
+    attr_reader :command
+
     class << self
       def parse(error_message)
         code = error_message.split(' ', 2).first
@@ -96,6 +99,10 @@ class RedisClient
         klass.new(error_message)
       end
     end
+
+    def _set_command(command)
+      @command = command
+    end
   end
 
   AuthenticationError = Class.new(CommandError)
@@ -112,11 +119,11 @@ class RedisClient
 
   class << self
     def config(**kwargs)
-      Config.new(**kwargs)
+      Config.new(client_implementation: self, **kwargs)
     end
 
     def sentinel(**kwargs)
-      SentinelConfig.new(**kwargs)
+      SentinelConfig.new(client_implementation: self, **kwargs)
     end
 
     def new(arg = nil, **kwargs)
@@ -140,6 +147,11 @@ class RedisClient
     @disable_reconnection = false
   end
 
+  def inspect
+    id_string = " id=#{id}" if id
+    "#<#{self.class.name} #{config.server_url}#{id_string}>"
+  end
+
   def size
     1
   end
@@ -171,7 +183,22 @@ class RedisClient
   end
 
   def call(*command, **kwargs)
-    command = @command_builder.generate!(command, kwargs)
+    command = @command_builder.generate(command, kwargs)
+    result = ensure_connected do |connection|
+      Middlewares.call(command, config) do
+        connection.call(command, nil)
+      end
+    end
+
+    if block_given?
+      yield result
+    else
+      result
+    end
+  end
+
+  def call_v(command)
+    command = @command_builder.generate(command)
     result = ensure_connected do |connection|
       Middlewares.call(command, config) do
         connection.call(command, nil)
@@ -186,7 +213,22 @@ class RedisClient
   end
 
   def call_once(*command, **kwargs)
-    command = @command_builder.generate!(command, kwargs)
+    command = @command_builder.generate(command, kwargs)
+    result = ensure_connected(retryable: false) do |connection|
+      Middlewares.call(command, config) do
+        connection.call(command, nil)
+      end
+    end
+
+    if block_given?
+      yield result
+    else
+      result
+    end
+  end
+
+  def call_once_v(command)
+    command = @command_builder.generate(command)
     result = ensure_connected(retryable: false) do |connection|
       Middlewares.call(command, config) do
         connection.call(command, nil)
@@ -201,14 +243,39 @@ class RedisClient
   end
 
   def blocking_call(timeout, *command, **kwargs)
-    command = @command_builder.generate!(command, kwargs)
+    command = @command_builder.generate(command, kwargs)
+    error = nil
     result = ensure_connected do |connection|
       Middlewares.call(command, config) do
         connection.call(command, timeout)
       end
+    rescue ReadTimeoutError => error
+      break
     end
 
-    if block_given?
+    if error
+      raise error
+    elsif block_given?
+      yield result
+    else
+      result
+    end
+  end
+
+  def blocking_call_v(timeout, command)
+    command = @command_builder.generate(command)
+    error = nil
+    result = ensure_connected do |connection|
+      Middlewares.call(command, config) do
+        connection.call(command, timeout)
+      end
+    rescue ReadTimeoutError => error
+      break
+    end
+
+    if error
+      raise error
+    elsif block_given?
       yield result
     else
       result
@@ -220,8 +287,8 @@ class RedisClient
       return to_enum(__callee__, *args, **kwargs)
     end
 
-    args = @command_builder.generate!(args, kwargs)
-    scan_list(1, ["SCAN", 0, *args], &block)
+    args = @command_builder.generate(["SCAN", 0] + args, kwargs)
+    scan_list(1, args, &block)
   end
 
   def sscan(key, *args, **kwargs, &block)
@@ -229,8 +296,8 @@ class RedisClient
       return to_enum(__callee__, key, *args, **kwargs)
     end
 
-    args = @command_builder.generate!(args, kwargs)
-    scan_list(2, ["SSCAN", key, 0, *args], &block)
+    args = @command_builder.generate(["SSCAN", key, 0] + args, kwargs)
+    scan_list(2, args, &block)
   end
 
   def hscan(key, *args, **kwargs, &block)
@@ -238,8 +305,8 @@ class RedisClient
       return to_enum(__callee__, key, *args, **kwargs)
     end
 
-    args = @command_builder.generate!(args, kwargs)
-    scan_pairs(2, ["HSCAN", key, 0, *args], &block)
+    args = @command_builder.generate(["HSCAN", key, 0] + args, kwargs)
+    scan_pairs(2, args, &block)
   end
 
   def zscan(key, *args, **kwargs, &block)
@@ -247,8 +314,8 @@ class RedisClient
       return to_enum(__callee__, key, *args, **kwargs)
     end
 
-    args = @command_builder.generate!(args, kwargs)
-    scan_pairs(2, ["ZSCAN", key, 0, *args], &block)
+    args = @command_builder.generate(["ZSCAN", key, 0] + args, kwargs)
+    scan_pairs(2, args, &block)
   end
 
   def connected?
@@ -330,7 +397,12 @@ class RedisClient
     end
 
     def call(*command, **kwargs)
-      raw_connection.write(@command_builder.generate!(command, kwargs))
+      raw_connection.write(@command_builder.generate(command, kwargs))
+      nil
+    end
+
+    def call_v(command)
+      raw_connection.write(@command_builder.generate(command))
       nil
     end
 
@@ -365,14 +437,29 @@ class RedisClient
     end
 
     def call(*command, **kwargs, &block)
-      command = @command_builder.generate!(command, kwargs)
+      command = @command_builder.generate(command, kwargs)
       (@blocks ||= [])[@commands.size] = block if block_given?
       @commands << command
       nil
     end
 
-    def call_once(*command, **kwargs)
-      command = @command_builder.generate!(command, kwargs)
+    def call_v(command, &block)
+      command = @command_builder.generate(command)
+      (@blocks ||= [])[@commands.size] = block if block_given?
+      @commands << command
+      nil
+    end
+
+    def call_once(*command, **kwargs, &block)
+      command = @command_builder.generate(command, kwargs)
+      @retryable = false
+      (@blocks ||= [])[@commands.size] = block if block_given?
+      @commands << command
+      nil
+    end
+
+    def call_once_v(command, &block)
+      command = @command_builder.generate(command)
       @retryable = false
       (@blocks ||= [])[@commands.size] = block if block_given?
       @commands << command
@@ -404,17 +491,14 @@ class RedisClient
     end
 
     def _coerce!(results)
-      if results
-        results.each do |result|
-          if result.is_a?(CommandError)
-            raise result
-          end
+      results&.each_with_index do |result, index|
+        if result.is_a?(CommandError)
+          result._set_command(@commands[index + 1])
+          raise result
         end
 
-        @blocks&.each_with_index do |block, index|
-          if block
-            results[index - 1] = block.call(results[index - 1])
-          end
+        if @blocks && block = @blocks[index + 1]
+          results[index] = block.call(result)
         end
       end
 
@@ -428,8 +512,17 @@ class RedisClient
       @timeouts = nil
     end
 
-    def blocking_call(timeout, *command, **kwargs)
-      command = @command_builder.generate!(command, kwargs)
+    def blocking_call(timeout, *command, **kwargs, &block)
+      command = @command_builder.generate(command, kwargs)
+      @timeouts ||= []
+      @timeouts[@commands.size] = timeout
+      (@blocks ||= [])[@commands.size] = block if block_given?
+      @commands << command
+      nil
+    end
+
+    def blocking_call_v(timeout, command, &block)
+      command = @command_builder.generate(command)
       @timeouts ||= []
       @timeouts[@commands.size] = timeout
       (@blocks ||= [])[@commands.size] = block if block_given?
@@ -524,6 +617,10 @@ class RedisClient
       begin
         @disable_reconnection = true
         yield connection
+      rescue ConnectionError
+        connection&.close
+        close
+        raise
       ensure
         @disable_reconnection = previous_disable_reconnection
       end
@@ -554,10 +651,23 @@ class RedisClient
       role, = connection.call_pipelined(prelude, nil).last
       config.check_role!(role)
     else
-      connection.call_pipelined(prelude, nil)
+      unless prelude.empty?
+        connection.call_pipelined(prelude, nil)
+      end
     end
 
     connection
+  rescue FailoverError
+    raise
+  rescue ConnectionError => error
+    raise CannotConnectError, error.message, error.backtrace
+  rescue CommandError => error
+    if error.message.include?("ERR unknown command `HELLO`")
+      raise UnsupportedServer,
+        "Your Redis server version is too old. redis-client requires Redis 6+. (#{config.server_url})"
+    else
+      raise
+    end
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-client
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Jean Boussier
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-06 00:00:00.000000000 Z
+date: 2022-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool