redis-client 0.1.0 → 0.3.0

data/lib/redis_client.rb

@@ -1,11 +1,86 @@
 # frozen_string_literal: true
 
+require "set"
+
 require "redis_client/version"
+require "redis_client/command_builder"
 require "redis_client/config"
 require "redis_client/sentinel_config"
-require "redis_client/connection"
+require "redis_client/middlewares"
 
 class RedisClient
+  @driver_definitions = {}
+  @drivers = {}
+
+  @default_driver = nil
+
+  class << self
+    def register_driver(name, &block)
+      @driver_definitions[name] = block
+    end
+
+    def driver(name)
+      return name if name.is_a?(Class)
+
+      name = name.to_sym
+      unless @driver_definitions.key?(name)
+        raise ArgumentError, "Unknown driver #{name.inspect}, expected one of: `#{DRIVER_DEFINITIONS.keys.inspect}`"
+      end
+
+      @drivers[name] ||= @driver_definitions[name]&.call
+    end
+
+    def default_driver
+      unless @default_driver
+        @driver_definitions.each_key do |name|
+          if @default_driver = driver(name)
+            break
+          end
+        rescue LoadError
+        end
+      end
+      @default_driver
+    end
+
+    def default_driver=(name)
+      @default_driver = driver(name)
+    end
+  end
+
+  register_driver :hiredis do
+    require "redis_client/hiredis_connection"
+    HiredisConnection
+  end
+
+  register_driver :ruby do
+    require "redis_client/ruby_connection"
+    RubyConnection
+  end
+
+  module Common
+    attr_reader :config, :id
+    attr_accessor :connect_timeout, :read_timeout, :write_timeout
+
+    def initialize(
+      config,
+      id: config.id,
+      connect_timeout: config.connect_timeout,
+      read_timeout: config.read_timeout,
+      write_timeout: config.write_timeout
+    )
+      @config = config
+      @id = id
+      @connect_timeout = connect_timeout
+      @read_timeout = read_timeout
+      @write_timeout = write_timeout
+      @command_builder = config.command_builder
+    end
+
+    def timeout=(timeout)
+      @connect_timeout = @read_timeout = @write_timeout = timeout
+    end
+  end
+
   Error = Class.new(StandardError)
 
   ConnectionError = Class.new(Error)
@@ -30,10 +105,14 @@ class RedisClient
 
   AuthenticationError = Class.new(CommandError)
   PermissionError = Class.new(CommandError)
+  ReadOnlyError = Class.new(CommandError)
+  WrongTypeError = Class.new(CommandError)
 
   CommandError::ERRORS = {
     "WRONGPASS" => AuthenticationError,
     "NOPERM" => PermissionError,
+    "READONLY" => ReadOnlyError,
+    "WRONGTYPE" => WrongTypeError,
   }.freeze
 
   class << self
@@ -52,23 +131,16 @@ class RedisClient
         super(config(**(arg || {}), **kwargs))
       end
     end
+
+    def register(middleware)
+      Middlewares.extend(middleware)
+    end
   end
 
-  attr_reader :config, :id
-  attr_accessor :connect_timeout, :read_timeout, :write_timeout
+  include Common
 
-  def initialize(
-    config,
-    id: config.id,
-    connect_timeout: config.connect_timeout,
-    read_timeout: config.read_timeout,
-    write_timeout: config.write_timeout
-  )
-    @config = config
-    @id = id
-    @connect_timeout = connect_timeout
-    @read_timeout = read_timeout
-    @write_timeout = write_timeout
+  def initialize(config, **)
+    super
     @raw_connection = nil
     @disable_reconnection = false
   end
@@ -83,86 +155,104 @@ class RedisClient
   alias_method :then, :with
 
   def timeout=(timeout)
-    @connect_timeout = @read_timeout = @write_timeout = timeout
+    super
+    raw_connection.read_timeout = raw_connection.write_timeout = timeout if connected?
+  end
+
+  def read_timeout=(timeout)
+    super
+    raw_connection.read_timeout = timeout if connected?
+  end
+
+  def write_timeout=(timeout)
+    super
+    raw_connection.write_timeout = timeout if connected?
   end
 
   def pubsub
-    sub = PubSub.new(ensure_connected)
+    sub = PubSub.new(ensure_connected, @command_builder)
     @raw_connection = nil
     sub
   end
 
-  def call(*command)
-    command = RESP3.coerce_command!(command)
+  def call(*command, **kwargs)
+    command = @command_builder.generate!(command, kwargs)
     result = ensure_connected do |connection|
-      connection.write(command)
-      connection.read
+      Middlewares.call(command, config) do
+        connection.call(command, nil)
+      end
     end
 
-    if result.is_a?(CommandError)
-      raise result
+    if block_given?
+      yield result
     else
       result
     end
   end
 
-  def call_once(*command)
-    command = RESP3.coerce_command!(command)
+  def call_once(*command, **kwargs)
+    command = @command_builder.generate!(command, kwargs)
     result = ensure_connected(retryable: false) do |connection|
-      connection.write(command)
-      connection.read
+      Middlewares.call(command, config) do
+        connection.call(command, nil)
+      end
     end
 
-    if result.is_a?(CommandError)
-      raise result
+    if block_given?
+      yield result
     else
       result
     end
   end
 
-  def blocking_call(timeout, *command)
-    command = RESP3.coerce_command!(command)
+  def blocking_call(timeout, *command, **kwargs)
+    command = @command_builder.generate!(command, kwargs)
     result = ensure_connected do |connection|
-      connection.write(command)
-      connection.read(timeout)
+      Middlewares.call(command, config) do
+        connection.call(command, timeout)
+      end
     end
 
-    if result.is_a?(CommandError)
-      raise result
+    if block_given?
+      yield result
     else
       result
     end
   end
 
-  def scan(*args, &block)
+  def scan(*args, **kwargs, &block)
     unless block_given?
-      return to_enum(__callee__, *args)
+      return to_enum(__callee__, *args, **kwargs)
     end
 
+    args = @command_builder.generate!(args, kwargs)
     scan_list(1, ["SCAN", 0, *args], &block)
   end
 
-  def sscan(key, *args, &block)
+  def sscan(key, *args, **kwargs, &block)
     unless block_given?
-      return to_enum(__callee__, key, *args)
+      return to_enum(__callee__, key, *args, **kwargs)
     end
 
+    args = @command_builder.generate!(args, kwargs)
     scan_list(2, ["SSCAN", key, 0, *args], &block)
   end
 
-  def hscan(key, *args, &block)
+  def hscan(key, *args, **kwargs, &block)
     unless block_given?
-      return to_enum(__callee__, key, *args)
+      return to_enum(__callee__, key, *args, **kwargs)
     end
 
+    args = @command_builder.generate!(args, kwargs)
     scan_pairs(2, ["HSCAN", key, 0, *args], &block)
   end
 
-  def zscan(key, *args, &block)
+  def zscan(key, *args, **kwargs, &block)
     unless block_given?
-      return to_enum(__callee__, key, *args)
+      return to_enum(__callee__, key, *args, **kwargs)
     end
 
+    args = @command_builder.generate!(args, kwargs)
     scan_pairs(2, ["ZSCAN", key, 0, *args], &block)
   end
 
@@ -177,27 +267,37 @@ class RedisClient
   end
 
   def pipelined
-    pipeline = Pipeline.new
+    pipeline = Pipeline.new(@command_builder)
     yield pipeline
 
     if pipeline._size == 0
       []
     else
-      ensure_connected(retryable: pipeline._retryable?) do |connection|
-        call_pipelined(connection, pipeline._commands, pipeline._timeouts)
+      results = ensure_connected(retryable: pipeline._retryable?) do |connection|
+        commands = pipeline._commands
+        Middlewares.call_pipelined(commands, config) do
+          connection.call_pipelined(commands, pipeline._timeouts)
+        end
       end
+
+      pipeline._coerce!(results)
     end
   end
 
   def multi(watch: nil, &block)
-    if watch
+    transaction = nil
+
+    results = if watch
       # WATCH is stateful, so we can't reconnect if it's used, the whole transaction
       # has to be redone.
       ensure_connected(retryable: false) do |connection|
         call("WATCH", *watch)
         begin
           if transaction = build_transaction(&block)
-            call_pipelined(connection, transaction._commands).last
+            commands = transaction._commands
+            results = Middlewares.call_pipelined(commands, config) do
+              connection.call_pipelined(commands, nil)
+            end.last
           else
             call("UNWATCH")
             []
@@ -213,19 +313,29 @@ class RedisClient
         []
       else
         ensure_connected(retryable: transaction._retryable?) do |connection|
-          call_pipelined(connection, transaction._commands).last
+          commands = transaction._commands
+          Middlewares.call_pipelined(commands, config) do
+            connection.call_pipelined(commands, nil)
+          end.last
         end
       end
     end
+
+    if transaction
+      transaction._coerce!(results)
+    else
+      results
+    end
   end
 
   class PubSub
-    def initialize(raw_connection)
+    def initialize(raw_connection, command_builder)
       @raw_connection = raw_connection
+      @command_builder = command_builder
     end
 
-    def call(*command)
-      raw_connection.write(RESP3.coerce_command!(command))
+    def call(*command, **kwargs)
+      raw_connection.write(@command_builder.generate!(command, kwargs))
       nil
     end
 
@@ -251,20 +361,26 @@ class RedisClient
   end
 
   class Multi
-    def initialize
+    def initialize(command_builder)
+      @command_builder = command_builder
       @size = 0
       @commands = []
+      @blocks = nil
       @retryable = true
     end
 
-    def call(*command)
-      @commands << RESP3.coerce_command!(command)
+    def call(*command, **kwargs, &block)
+      command = @command_builder.generate!(command, kwargs)
+      (@blocks ||= [])[@commands.size] = block if block_given?
+      @commands << command
       nil
     end
 
-    def call_once(*command)
+    def call_once(*command, **kwargs)
+      command = @command_builder.generate!(command, kwargs)
       @retryable = false
-      @commands << RESP3.coerce_command!(command)
+      (@blocks ||= [])[@commands.size] = block if block_given?
+      @commands << command
       nil
     end
 
@@ -272,6 +388,10 @@ class RedisClient
       @commands
     end
 
+    def _blocks
+      @blocks
+    end
+
     def _size
       @commands.size
     end
@@ -287,18 +407,38 @@ class RedisClient
     def _retryable?
       @retryable
     end
+
+    def _coerce!(results)
+      if results
+        results.each do |result|
+          if result.is_a?(CommandError)
+            raise result
+          end
+        end
+
+        @blocks&.each_with_index do |block, index|
+          if block
+            results[index - 1] = block.call(results[index - 1])
+          end
+        end
+      end
+
+      results
+    end
   end
 
   class Pipeline < Multi
-    def initialize
+    def initialize(_command_builder)
       super
       @timeouts = nil
     end
 
-    def blocking_call(timeout, *command)
+    def blocking_call(timeout, *command, **kwargs)
+      command = @command_builder.generate!(command, kwargs)
       @timeouts ||= []
       @timeouts[@commands.size] = timeout
-      @commands << RESP3.coerce_command!(command)
+      (@blocks ||= [])[@commands.size] = block if block_given?
+      @commands << command
       nil
     end
 
@@ -309,12 +449,24 @@ class RedisClient
     def _empty?
       @commands.empty?
     end
+
+    def _coerce!(results)
+      return results unless results
+
+      @blocks&.each_with_index do |block, index|
+        if block
+          results[index] = block.call(results[index])
+        end
+      end
+
+      results
+    end
   end
 
   private
 
   def build_transaction
-    transaction = Multi.new
+    transaction = Multi.new(@command_builder)
     transaction.call("MULTI")
     yield transaction
     transaction.call("EXEC")
@@ -347,29 +499,6 @@ class RedisClient
     nil
   end
 
-  def call_pipelined(connection, commands, timeouts = nil)
-    exception = nil
-
-    size = commands.size
-    results = Array.new(commands.size)
-    connection.write_multi(commands)
-
-    size.times do |index|
-      timeout = timeouts && timeouts[index]
-      result = connection.read(timeout)
-      if result.is_a?(CommandError)
-        exception ||= result
-      end
-      results[index] = result
-    end
-
-    if exception
-      raise exception
-    else
-      results
-    end
-  end
-
   def ensure_connected(retryable: true)
     if @disable_reconnection
       yield @raw_connection
@@ -407,32 +536,36 @@ class RedisClient
   end
 
   def raw_connection
-    @raw_connection ||= begin
-      connection = config.driver.new(
-        config,
-        connect_timeout: connect_timeout,
-        read_timeout: read_timeout,
-        write_timeout: write_timeout,
-      )
-
-      prelude = config.connection_prelude.dup
-
-      if id
-        prelude << ["CLIENT", "SETNAME", id.to_s]
-      end
+    @raw_connection ||= connect
+  end
 
-      if config.sentinel?
-        prelude << ["ROLE"]
-        role, = call_pipelined(connection, prelude).last
-        config.check_role!(role)
-      else
-        call_pipelined(connection, prelude)
-      end
+  def connect
+    connection = config.driver.new(
+      config,
+      connect_timeout: connect_timeout,
+      read_timeout: read_timeout,
+      write_timeout: write_timeout,
+    )
+
+    prelude = config.connection_prelude.dup
 
-      connection
+    if id
+      prelude << ["CLIENT", "SETNAME", id.to_s]
     end
+
+    # The connection prelude is deliberately not sent to Middlewares
+    if config.sentinel?
+      prelude << ["ROLE"]
+      role, = connection.call_pipelined(prelude, nil).last
+      config.check_role!(role)
+    else
+      connection.call_pipelined(prelude, nil)
+    end
+
+    connection
   end
 end
 
-require "redis_client/resp3"
 require "redis_client/pooled"
+
+RedisClient.default_driver

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-client
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jean Boussier
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-04-15 00:00:00.000000000 Z
+date: 2022-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -39,6 +39,8 @@ files:
 - LICENSE.md
 - README.md
 - Rakefile
+- ext/redis_client/hiredis/export.clang
+- ext/redis_client/hiredis/export.gcc
 - ext/redis_client/hiredis/extconf.rb
 - ext/redis_client/hiredis/hiredis_connection.c
 - ext/redis_client/hiredis/vendor/.gitignore
@@ -87,12 +89,16 @@ files:
 - ext/redis_client/hiredis/vendor/win32.h
 - lib/redis-client.rb
 - lib/redis_client.rb
-- lib/redis_client/buffered_io.rb
+- lib/redis_client/command_builder.rb
 - lib/redis_client/config.rb
-- lib/redis_client/connection.rb
+- lib/redis_client/connection_mixin.rb
+- lib/redis_client/decorator.rb
 - lib/redis_client/hiredis_connection.rb
+- lib/redis_client/middlewares.rb
 - lib/redis_client/pooled.rb
-- lib/redis_client/resp3.rb
+- lib/redis_client/ruby_connection.rb
+- lib/redis_client/ruby_connection/buffered_io.rb
+- lib/redis_client/ruby_connection/resp3.rb
 - lib/redis_client/sentinel_config.rb
 - lib/redis_client/version.rb
 - redis-client.gemspec