redis-client 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eba18b5a126a8f4f9e76c842c41fd3ab2672c6d08be0d9023536e7fdbbf2ac1c
-  data.tar.gz: 0a012bad73ae54550cae8dde282fdaf644a04a1bd748cd37993a31592ccf2259
+  metadata.gz: 6bd28ab66722c23791118818d83505de8cbc1b141c75959f2408b8a0c90cb6ad
+  data.tar.gz: 30f85f2bb0df340facd9a743f63dcfd2ff8fa8b8a3e363c9fdeb2f1101d5d076
 SHA512:
-  metadata.gz: 37ccff70160eff897f9881784db776679e8b97cec95b89e6db3f13e5294799c3d6ca7dd97e83ce54699819943c7a10904fb76567a7944a8c83fc88408217d294
-  data.tar.gz: c366d95353b081199751910676a9b0e682ff7cb0559c91d7c5112ec7f486a2edb0afa9317f9066953bd13b2f359f6fcb0c4fda268852aa7176557cc42d6b0f94
+  metadata.gz: 528b4cd6f9377f083a19ca1da7b117625ad32c1849c8cc53d795dc5af8e6d23c372fdb5714c043b7c796a6fcfda54ef28ee0142268846445cbfb60e00eabf625
+  data.tar.gz: af0040e6a5cf498587818b5161122d57e3057a39a22d0eb5fc8252e4cb56e71ad61c0a381fbe35c75cd6f5e5e2998169487e33b74f7635f7e025f6e06d7351ca

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Unreleased
 
+# 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.
+
 # 0.2.0
 - Added `RedisClient.register` as a public instrumentation API.
 - Fix `read_timeout=` and `write_timeout=` to apply even when the client or pool is already connected.

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.0)
+    redis-client (0.4.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

@@ -145,19 +145,68 @@ redis.call("LPUSH", "list", "1", "2", "3", "4")
 Hashes are flatenned 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.
 
+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 explictly 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 postional 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` familly 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
 
 For blocking commands such as `BRPOP`, a custom timeout duration can be passed as first argument of the `#blocking_call` method:
@@ -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,83 @@
+# 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
+
+        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
+
+        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,41 +78,8 @@ 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],
-        )
-      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
-        end
+      def ssl_context
+        @ssl_context ||= @driver.ssl_context(@ssl_params)
       end
 
       private

data/lib/redis_client/connection_mixin.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class RedisClient
+  module ConnectionMixin
+    def call(command, timeout)
+      write(command)
+      result = read(timeout)
+      if result.is_a?(CommandError)
+        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)
+          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

data/lib/redis_client/pooled.rb

@@ -49,40 +49,48 @@ class RedisClient
       pool.size
     end
 
-    %w(pipelined).each do |method|
-      class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def #{method}(&block)
-          with { |r| r.#{method}(&block) }
-        end
-      RUBY
-    end
-
-    %w(multi).each do |method|
-      class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def #{method}(**kwargs, &block)
-          with { |r| r.#{method}(**kwargs, &block) }
-        end
-      RUBY
-    end
+    methods = %w(pipelined multi pubsub call call_once blocking_call)
+    iterable_methods = %w(scan sscan hscan zscan)
+    begin
+      methods.each do |method|
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{method}(...)
+            with { |r| r.#{method}(...) }
+          end
+        RUBY
+      end
 
-    %w(call call_once blocking_call pubsub).each do |method|
-      class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def #{method}(*args)
-          with { |r| r.#{method}(*args) }
-        end
-      RUBY
-    end
+      iterable_methods.each do |method|
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{method}(...)
+            unless block_given?
+              return to_enum(__callee__, ...)
+            end
 
-    %w(scan sscan hscan zscan).each do |method|
-      class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def #{method}(*args, &block)
-          unless block_given?
-            return to_enum(__callee__, *args)
+            with { |r| r.#{method}(...) }
+          end
+        RUBY
+      end
+    rescue SyntaxError
+      methods.each do |method|
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{method}(*args, &block)
+            with { |r| r.#{method}(*args, &block) }
           end
+        RUBY
+      end
 
-          with { |r| r.#{method}(*args, &block) }
-        end
-      RUBY
+      iterable_methods.each do |method|
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{method}(*args, &block)
+            unless block_given?
+              return to_enum(__callee__, *args)
+            end
+
+            with { |r| r.#{method}(*args, &block) }
+          end
+        RUBY
+      end
     end
 
     private