redis-client 0.2.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f09f4bc8f3f2cf92a6beb3b02ef601209bc36073eee68e4d57c93f802b10db2f
-  data.tar.gz: c3539ba4db69fac8a98649e27125409feb62d925b55a2c03bc75e87d26e60a89
+  metadata.gz: 770636c5814252674d680c45f75af4ea291b698c18382b49d93bec4e3d7ab45b
+  data.tar.gz: bdef4f0f80574a9aaf29613ec23d31d7a0c3d916ca3945ac412b36b55eecd73a
 SHA512:
-  metadata.gz: '08bbfce855729654d6f74830a18a6aaea755f4790c58ccf92cc53ac321a6a3ca4d5935a885498c89d48d781b5affc16e757524e7d1f2355da57b5048ca968528'
-  data.tar.gz: aac332fe44444ac5afdf5b23ba35e23dc3129a50c5c9c51628f24d151620c26108984574decd5ab25435f39ee305cf4933ab0413aaad7076cf525503c9ec50d3
+  metadata.gz: 3367281b907b6e38e73ba1e9a74f63404e40f422b319c551645fec1efa694e87c09cd96c67d308c362407c84be59eb62435b9951740cd515727a554050ae3137
+  data.tar.gz: 9dc6f5e6638405c8841b267d0c9cf882d0721cbd04655984af71bddb66cc7e2f4698e7199e752582064e4db3ca8e3f45a77b56241df309ae0c2e231ebff1cf2b

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Unreleased
 
+- 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.
+
+# 0.3.0
+
+- `hiredis` is now the default driver when available.
+- Add `RedisClient.default_driver=`.
+- `#call` now takes an optional block to cast the return value.
+- Treat `#call` keyword arguments as Redis flags.
+- Fix `RedisClient#multi` returning some errors as values instead of raising them.
+
 # 0.2.1
 
 - Use a more robust way to detect the current compiler.

data/Gemfile

@@ -3,9 +3,8 @@
 source "https://rubygems.org"
 
 # Specify your gem's dependencies in redis-client.gemspec
-gemspec
+gemspec name: "redis-client"
 
-gem "connection_pool"
 gem "minitest"
 gem "rake", "~> 13.0"
 gem "rake-compiler"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    redis-client (0.2.1)
+    redis-client (0.5.0)
       connection_pool
 
 GEM
@@ -51,7 +51,6 @@ PLATFORMS
 DEPENDENCIES
   benchmark-ips
   byebug
-  connection_pool
   hiredis
   minitest
   rake (~> 13.0)
@@ -64,4 +63,4 @@ DEPENDENCIES
   toxiproxy
 
 BUNDLED WITH
-   2.3.8
+   2.3.13

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.
@@ -142,21 +142,70 @@ 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)
-redis.call("SET", "key", "value", ex: 5)
+redis.call("HMSET", "hash", { "foo" => "1", "bar" => "2" })
 ```
 
 is equivalent to:
 
 ```ruby
 redis.call("HMSET", "hash", "foo", "1", "bar", "2")
-redis.call("SET", "key", "value", "ex", "5")
 ```
 
-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:
+
+```ruby
+redis.call("SET", "mykey", "value", nx: true, ex: 60)
+redis.call("SET", "mykey", "value", nx: false, ex: nil)
+```
+
+is equivalent to:
+
+```ruby
+redis.call("SET", "mykey", "value", "nx", "ex", "60")
+redis.call("SET", "mykey", "value")
+```
+
+If flags are built dynamically, you'll have to explicitly pass them as keyword arguments with `**`:
+
+```ruby
+flags = {}
+flags[:nx] = true if something?
+redis.call("SET", "mykey", "value", **flags)
+```
+
+**Important Note**: because of the keyword argument semantic change between Ruby 2 and Ruby 3,
+unclosed hash literals with string keys may be interpreted differently:
+
+```ruby
+redis.call("HMSET", "hash", "foo" => "bar")
+```
+
+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
+redis.call("HMSET", "hash", { "foo" => "bar" })
+```
+
+### Commands return values
+
+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` family of methods:
+
+```ruby
+redis.call("INCR", "counter") # => 1
+redis.call("GET", "counter") # => "1"
+redis.call("GET", "counter", &:to_i) # => 1
+
+redis.call("EXISTS", "counter") # => 1
+redis.call("EXISTS", "counter") { |c| c > 0 } # => true
+```
 
 ### Blocking commands
 
@@ -248,7 +297,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
 
@@ -338,6 +387,20 @@ redis.call("GET", "counter") # Will be retried up to 3 times.
 redis.call_once("INCR", "counter") # Won't be retried.
 ```
 
+### Drivers
+
+`redis-client` ships with a pure Ruby socket implementation.
+
+For increased performance, you can enable the `hiredis` binding by adding `hiredis-client` to your Gemfile:
+
+```ruby
+gem "hiredis-client"
+```
+
+The hiredis binding is only available on Linux, macOS and other POSIX platforms. You can install the gem on other platforms, but it won't have any effect.
+
+The default driver can be set through `RedisClient.default_driver=`:
+
 ## Notable differences with the `redis` gem
 
 ### Thread Safety

data/Rakefile

@@ -1,33 +1,53 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
 require "rake/extensiontask"
 require "rake/testtask"
 require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new
 
+require "rake/clean"
+CLOBBER.include "pkg"
+require "bundler/gem_helper"
+Bundler::GemHelper.install_tasks(name: "redis-client")
+Bundler::GemHelper.install_tasks(dir: "hiredis-client", name: "hiredis-client")
+
 gemspec = Gem::Specification.load("redis-client.gemspec")
 Rake::ExtensionTask.new do |ext|
   ext.name = "hiredis_connection"
-  ext.ext_dir = "ext/redis_client/hiredis"
-  ext.lib_dir = "lib/redis_client"
+  ext.ext_dir = "hiredis-client/ext/redis_client/hiredis"
+  ext.lib_dir = "hiredis-client/lib/redis_client"
   ext.gem_spec = gemspec
   CLEAN.add("#{ext.ext_dir}/vendor/*.{a,o}")
 end
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"].exclude("test/sentinel/*_test.rb")
-end
-
 namespace :test do
+  Rake::TestTask.new(:ruby) do |t|
+    t.libs << "test"
+    t.libs << "lib"
+    t.test_files = FileList["test/**/*_test.rb"].exclude("test/sentinel/*_test.rb")
+  end
+
   Rake::TestTask.new(:sentinel) do |t|
+    t.libs << "test/sentinel"
     t.libs << "test"
     t.libs << "lib"
     t.test_files = FileList["test/sentinel/*_test.rb"]
   end
+
+  Rake::TestTask.new(:hiredis) do |t|
+    t.libs << "test/hiredis"
+    t.libs << "test"
+    t.libs << "lib"
+    t.test_files = FileList["test/**/*_test.rb"].exclude("test/sentinel/*_test.rb")
+  end
+end
+
+hiredis_supported = RUBY_ENGINE == "ruby" && !RUBY_PLATFORM.match?(/mswin/)
+if hiredis_supported
+  task test: %i[test:ruby test:hiredis test:sentinel]
+else
+  task test: %i[test:ruby test:sentinel]
 end
 
 namespace :hiredis do
@@ -36,10 +56,14 @@ namespace :hiredis do
     archive_path = "tmp/hiredis-#{version}.tar.gz"
     url = "https://github.com/redis/hiredis/archive/refs/tags/v#{version}.tar.gz"
     system("curl", "-L", url, out: archive_path) or raise "Downloading of #{url} failed"
-    system("rm", "-rf", "ext/redis_client/hiredis/vendor/")
-    system("mkdir", "-p", "ext/redis_client/hiredis/vendor/")
-    system("tar", "xvzf", archive_path, "-C", "ext/redis_client/hiredis/vendor", "--strip-components", "1")
-    system("rm", "-rf", "ext/redis_client/hiredis/vendor/examples")
+    system("rm", "-rf", "hiredis-client/ext/redis_client/hiredis/vendor/")
+    system("mkdir", "-p", "hiredis-client/ext/redis_client/hiredis/vendor/")
+    system(
+      "tar", "xvzf", archive_path,
+      "-C", "hiredis-client/ext/redis_client/hiredis/vendor",
+      "--strip-components", "1",
+    )
+    system("rm", "-rf", "hiredis-client/ext/redis_client/hiredis/vendor/examples")
   end
 end
 
@@ -57,7 +81,7 @@ namespace :benchmark do
           env = {}
           args = []
           args << "--yjit" if mode == :yjit
-          env["DRIVER"] = "hiredis" if mode == :hiredis
+          env["DRIVER"] = mode == :hiredis ? "hiredis" : "ruby"
           system(env, RbConfig.ruby, *args, "benchmark/#{suite}.rb", out: output)
         end
 
@@ -81,14 +105,10 @@ namespace :benchmark do
   end
 end
 
-if RUBY_PLATFORM == "java"
-  task default: %i[test test:sentinel rubocop]
-else
-  task default: %i[compile test test:sentinel rubocop]
-end
-
-if ENV["DRIVER"] == "hiredis"
-  task ci: %i[compile test test:sentinel]
+if hiredis_supported
+  task default: %i[compile test rubocop]
+  task ci: %i[compile test]
 else
-  task ci: %i[test test:sentinel]
+  task default: %i[test rubocop]
+  task ci: %i[test]
 end

data/lib/redis_client/command_builder.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+class RedisClient
+  module CommandBuilder
+    extend self
+
+    if Symbol.method_defined?(:name)
+      def generate!(args, kwargs)
+        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|
+          if value
+            if value == true
+              command << key.name
+            else
+              command << key.name << value
+            end
+          end
+        end
+
+        command.map! do |element|
+          case element
+          when String
+            element
+          when Symbol
+            element.name
+          when Integer, Float
+            element.to_s
+          else
+            raise TypeError, "Unsupported command argument type: #{element.class}"
+          end
+        end
+
+        if command.empty?
+          raise ArgumentError, "can't issue an empty redis command"
+        end
+
+        command
+      end
+    else
+      def generate!(args, kwargs)
+        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|
+          if value
+            if value == true
+              command << key.to_s
+            else
+              command << key.to_s << value
+            end
+          end
+        end
+
+        command.map! do |element|
+          case element
+          when String
+            element
+          when Integer, Float, Symbol
+            element.to_s
+          else
+            raise TypeError, "Unsupported command argument type: #{element.class}"
+          end
+        end
+
+        if command.empty?
+          raise ArgumentError, "can't issue an empty redis command"
+        end
+
+        command
+      end
+    end
+  end
+end

data/lib/redis_client/config.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "openssl"
 require "uri"
 
 class RedisClient
@@ -11,7 +12,7 @@ class RedisClient
     DEFAULT_DB = 0
 
     module Common
-      attr_reader :db, :username, :password, :id, :ssl, :ssl_params,
+      attr_reader :db, :username, :password, :id, :ssl, :ssl_params, :command_builder,
         :connect_timeout, :read_timeout, :write_timeout, :driver, :connection_prelude
 
       alias_method :ssl?, :ssl
@@ -27,7 +28,8 @@ class RedisClient
         connect_timeout: timeout,
         ssl: nil,
         ssl_params: nil,
-        driver: :ruby,
+        driver: nil,
+        command_builder: CommandBuilder,
         reconnect_attempts: false
       )
         @username = username || DEFAULT_USERNAME
@@ -41,17 +43,9 @@ class RedisClient
         @read_timeout = read_timeout
         @write_timeout = write_timeout
 
-        @driver = case driver
-        when :ruby
-          Connection
-        when :hiredis
-          unless defined?(RedisClient::HiredisConnection)
-            require "redis_client/hiredis_connection"
-          end
-          HiredisConnection
-        else
-          raise ArgumentError, "Unknown driver #{driver.inspect}, expected one of: `:ruby`, `:hiredis`"
-        end
+        @driver = driver ? RedisClient.driver(driver) : RedisClient.default_driver
+
+        @command_builder = command_builder
 
         reconnect_attempts = Array.new(reconnect_attempts, 0).freeze if reconnect_attempts.is_a?(Integer)
         @reconnect_attempts = reconnect_attempts
@@ -84,40 +78,15 @@ class RedisClient
         false
       end
 
-      def hiredis_ssl_context
-        @hiredis_ssl_context ||= HiredisConnection::SSLContext.new(
-          ca_file: @ssl_params[:ca_file],
-          ca_path: @ssl_params[:ca_path],
-          cert: @ssl_params[:cert],
-          key: @ssl_params[:key],
-          hostname: @ssl_params[:hostname],
-        )
+      def ssl_context
+        @ssl_context ||= @driver.ssl_context(@ssl_params)
       end
 
-      def openssl_context
-        @openssl_context ||= begin
-          params = @ssl_params.dup || {}
-
-          cert = params[:cert]
-          if cert.is_a?(String)
-            cert = File.read(cert) if File.exist?(cert)
-            params[:cert] = OpenSSL::X509::Certificate.new(cert)
-          end
-
-          key = params[:key]
-          if key.is_a?(String)
-            key = File.read(key) if File.exist?(key)
-            params[:key] = OpenSSL::PKey.read(key)
-          end
-
-          context = OpenSSL::SSL::SSLContext.new
-          context.set_params(params)
-          if context.verify_mode != OpenSSL::SSL::VERIFY_NONE
-            if context.respond_to?(:verify_hostname) # Missing on JRuby
-              context.verify_hostname
-            end
-          end
-          context
+      def server_url
+        if path
+          "#{path}/#{db}"
+        else
+          "redis#{'s' if ssl?}://#{host}:#{port}/#{db}"
         end
       end
 
@@ -149,15 +118,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
 
@@ -166,7 +135,7 @@ class RedisClient
 
       super(**kwargs)
 
-      @host = host || uri&.host || DEFAULT_HOST
+      @host = host || uri&.host&.sub(/\A\[(.*)\]\z/, '\1') || DEFAULT_HOST
       @port = port || uri&.port || DEFAULT_PORT
       @path = path
     end

data/lib/redis_client/connection_mixin.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class RedisClient
+  module ConnectionMixin
+    def call(command, timeout)
+      write(command)
+      result = read(timeout)
+      if result.is_a?(CommandError)
+        result._set_command(command)
+        raise result
+      else
+        result
+      end
+    end
+
+    def call_pipelined(commands, timeouts)
+      exception = nil
+
+      size = commands.size
+      results = Array.new(commands.size)
+      write_multi(commands)
+
+      size.times do |index|
+        timeout = timeouts && timeouts[index]
+        result = read(timeout)
+        if result.is_a?(CommandError)
+          result._set_command(commands[index])
+          exception ||= result
+        end
+        results[index] = result
+      end
+
+      if exception
+        raise exception
+      else
+        results
+      end
+    end
+  end
+end

data/lib/redis_client/decorator.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+class RedisClient
+  module Decorator
+    class << self
+      def create(commands_mixin)
+        client_decorator = Class.new(Client)
+        client_decorator.include(commands_mixin)
+
+        pipeline_decorator = Class.new(Pipeline)
+        pipeline_decorator.include(commands_mixin)
+        client_decorator.const_set(:Pipeline, pipeline_decorator)
+
+        client_decorator
+      end
+    end
+
+    module CommandsMixin
+      def initialize(client)
+        @client = client
+      end
+
+      %i(call call_once blocking_call).each do |method|
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{method}(*args, &block)
+            @client.#{method}(*args, &block)
+          end
+          ruby2_keywords :#{method} if respond_to?(:ruby2_keywords, true)
+        RUBY
+      end
+    end
+
+    class Pipeline
+      include CommandsMixin
+    end
+
+    class Client
+      include CommandsMixin
+
+      def initialize(_client)
+        super
+        @_pipeline_class = self.class::Pipeline
+      end
+
+      def with(*args)
+        @client.with(*args) { |c| yield self.class.new(c) }
+      end
+      ruby2_keywords :with if respond_to?(:ruby2_keywords, true)
+
+      def pipelined
+        @client.pipelined { |p| yield @_pipeline_class.new(p) }
+      end
+
+      def multi(**kwargs)
+        @client.multi(**kwargs) { |p| yield @_pipeline_class.new(p) }
+      end
+
+      %i(close scan hscan sscan zscan).each do |method|
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{method}(*args, &block)
+            @client.#{method}(*args, &block)
+          end
+          ruby2_keywords :#{method} if respond_to?(:ruby2_keywords, true)
+        RUBY
+      end
+
+      %i(id config size connect_timeout read_timeout write_timeout).each do |reader|
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{reader}
+            @client.#{reader}
+          end
+        RUBY
+      end
+
+      %i(timeout connect_timeout read_timeout write_timeout).each do |writer|
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{writer}=(value)
+            @client.#{writer} = value
+          end
+        RUBY
+      end
+    end
+  end
+end