redis-client 0.2.0 → 0.4.0

data/lib/redis_client/ruby_connection/buffered_io.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "io/wait" unless IO.method_defined?(:wait_readable) && IO.method_defined?(:wait_writable)
+
+class RedisClient
+  class RubyConnection
+    class BufferedIO
+      EOL = "\r\n".b.freeze
+      EOL_SIZE = EOL.bytesize
+
+      attr_accessor :read_timeout, :write_timeout
+
+      def initialize(io, read_timeout:, write_timeout:, chunk_size: 4096)
+        @io = io
+        @buffer = "".b
+        @offset = 0
+        @chunk_size = chunk_size
+        @read_timeout = read_timeout
+        @write_timeout = write_timeout
+        @blocking_reads = false
+      end
+
+      def close
+        @io.to_io.close
+      end
+
+      def closed?
+        @io.to_io.closed?
+      end
+
+      def eof?
+        @offset >= @buffer.bytesize && @io.eof?
+      end
+
+      def with_timeout(new_timeout)
+        new_timeout = false if new_timeout == 0
+
+        previous_read_timeout = @read_timeout
+        previous_blocking_reads = @blocking_reads
+
+        if new_timeout
+          @read_timeout = new_timeout
+        else
+          @blocking_reads = true
+        end
+
+        begin
+          yield
+        ensure
+          @read_timeout = previous_read_timeout
+          @blocking_reads = previous_blocking_reads
+        end
+      end
+
+      def skip(offset)
+        ensure_remaining(offset)
+        @offset += offset
+        nil
+      end
+
+      def write(string)
+        total = remaining = string.bytesize
+        loop do
+          case bytes_written = @io.write_nonblock(string, exception: false)
+          when Integer
+            remaining -= bytes_written
+            if remaining > 0
+              string = string.byteslice(bytes_written..-1)
+            else
+              return total
+            end
+          when :wait_readable
+            @io.to_io.wait_readable(@read_timeout) or raise ReadTimeoutError
+          when :wait_writable
+            @io.to_io.wait_writable(@write_timeout) or raise WriteTimeoutError
+          when nil
+            raise Errno::ECONNRESET
+          else
+            raise "Unexpected `write_nonblock` return: #{bytes.inspect}"
+          end
+        end
+      end
+
+      def getbyte
+        ensure_remaining(1)
+        byte = @buffer.getbyte(@offset)
+        @offset += 1
+        byte
+      end
+
+      def gets_chomp
+        fill_buffer(false) if @offset >= @buffer.bytesize
+        until eol_index = @buffer.index(EOL, @offset)
+          fill_buffer(false)
+        end
+
+        line = @buffer.byteslice(@offset, eol_index - @offset)
+        @offset = eol_index + EOL_SIZE
+        line
+      end
+
+      def read_chomp(bytes)
+        ensure_remaining(bytes + EOL_SIZE)
+        str = @buffer.byteslice(@offset, bytes)
+        @offset += bytes + EOL_SIZE
+        str
+      end
+
+      private
+
+      def ensure_remaining(bytes)
+        needed = bytes - (@buffer.bytesize - @offset)
+        if needed > 0
+          fill_buffer(true, needed)
+        end
+      end
+
+      def fill_buffer(strict, size = @chunk_size)
+        remaining = size
+        empty_buffer = @offset >= @buffer.bytesize
+
+        loop do
+          bytes = if empty_buffer
+            @io.read_nonblock([remaining, @chunk_size].max, @buffer, exception: false)
+          else
+            @io.read_nonblock([remaining, @chunk_size].max, exception: false)
+          end
+          case bytes
+          when String
+            if empty_buffer
+              @offset = 0
+              empty_buffer = false
+            else
+              @buffer << bytes
+            end
+            remaining -= bytes.bytesize
+            return if !strict || remaining <= 0
+          when :wait_readable
+            unless @io.to_io.wait_readable(@read_timeout)
+              raise ReadTimeoutError unless @blocking_reads
+            end
+          when :wait_writable
+            @io.to_io.wait_writable(@write_timeout) or raise WriteTimeoutError
+          when nil
+            raise Errno::ECONNRESET
+          else
+            raise "Unexpected `read_nonblock` return: #{bytes.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis_client/{resp3.rb → ruby_connection/resp3.rb}

@@ -58,32 +58,6 @@ class RedisClient
       String.new(encoding: Encoding::BINARY, capacity: 128)
     end
 
-    def coerce_command!(command)
-      command = command.flat_map do |element|
-        case element
-        when Hash
-          element.flatten
-        when Set
-          element.to_a
-        else
-          element
-        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
-
     def dump_any(object, buffer)
       method = DUMP_TYPES.fetch(object.class) do
         raise TypeError, "Unsupported command argument type: #{object.class}"

data/lib/redis_client/{connection.rb → ruby_connection.rb}

@@ -2,47 +2,42 @@
 
 require "socket"
 require "openssl"
-require "redis_client/buffered_io"
+require "redis_client/connection_mixin"
+require "redis_client/ruby_connection/buffered_io"
+require "redis_client/ruby_connection/resp3"
 
 class RedisClient
-  class Connection
-    module Common
-      def call(command, timeout)
-        write(command)
-        result = read(timeout)
-        if result.is_a?(CommandError)
-          raise result
-        else
-          result
-        end
-      end
+  class RubyConnection
+    include ConnectionMixin
 
-      def call_pipelined(commands, timeouts)
-        exception = nil
+    class << self
+      def ssl_context(ssl_params)
+        params = ssl_params.dup || {}
 
-        size = commands.size
-        results = Array.new(commands.size)
-        write_multi(commands)
+        cert = params[:cert]
+        if cert.is_a?(String)
+          cert = File.read(cert) if File.exist?(cert)
+          params[:cert] = OpenSSL::X509::Certificate.new(cert)
+        end
 
-        size.times do |index|
-          timeout = timeouts && timeouts[index]
-          result = read(timeout)
-          if result.is_a?(CommandError)
-            exception ||= result
-          end
-          results[index] = result
+        key = params[:key]
+        if key.is_a?(String)
+          key = File.read(key) if File.exist?(key)
+          params[:key] = OpenSSL::PKey.read(key)
         end
 
-        if exception
-          raise exception
-        else
-          results
+        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
     end
 
-    include Common
-
     SUPPORTS_RESOLV_TIMEOUT = Socket.method(:tcp).parameters.any? { |p| p.last == :resolv_timeout }
 
     def initialize(config, connect_timeout:, read_timeout:, write_timeout:)
@@ -60,7 +55,7 @@ class RedisClient
       end
 
       if config.ssl
-        socket = OpenSSL::SSL::SSLSocket.new(socket, config.openssl_context)
+        socket = OpenSSL::SSL::SSLSocket.new(socket, config.ssl_context)
         socket.hostname = config.host
         loop do
           case status = socket.connect_nonblock(exception: false)

data/lib/redis_client/version.rb

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

data/lib/redis_client.rb

@@ -1,12 +1,57 @@
 # 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 :ruby do
+    require "redis_client/ruby_connection"
+    RubyConnection
+  end
+
   module Common
     attr_reader :config, :id
     attr_accessor :connect_timeout, :read_timeout, :write_timeout
@@ -23,6 +68,7 @@ class RedisClient
       @connect_timeout = connect_timeout
       @read_timeout = read_timeout
       @write_timeout = write_timeout
+      @command_builder = config.command_builder
     end
 
     def timeout=(timeout)
@@ -54,10 +100,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
@@ -115,67 +165,89 @@ class RedisClient
   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)
-    ensure_connected do |connection|
+  def call(*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_once(*command)
-    command = RESP3.coerce_command!(command)
-    ensure_connected(retryable: false) do |connection|
+  def call_once(*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 blocking_call(timeout, *command)
-    command = RESP3.coerce_command!(command)
-    ensure_connected do |connection|
+  def blocking_call(timeout, *command, **kwargs)
+    command = @command_builder.generate!(command, kwargs)
+    result = ensure_connected do |connection|
       Middlewares.call(command, config) do
         connection.call(command, timeout)
       end
     end
+
+    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
 
@@ -190,23 +262,27 @@ 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|
+      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|
@@ -214,7 +290,7 @@ class RedisClient
         begin
           if transaction = build_transaction(&block)
             commands = transaction._commands
-            Middlewares.call_pipelined(commands, config) do
+            results = Middlewares.call_pipelined(commands, config) do
               connection.call_pipelined(commands, nil)
             end.last
           else
@@ -239,15 +315,22 @@ class RedisClient
         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
 
@@ -273,20 +356,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
 
@@ -294,6 +383,10 @@ class RedisClient
       @commands
     end
 
+    def _blocks
+      @blocks
+    end
+
     def _size
       @commands.size
     end
@@ -309,18 +402,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
 
@@ -331,12 +444,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")
@@ -436,5 +561,6 @@ class RedisClient
   end
 end
 
-require "redis_client/resp3"
 require "redis_client/pooled"
+
+RedisClient.default_driver

data/redis-client.gemspec

@@ -10,6 +10,7 @@ Gem::Specification.new do |spec|
 
   spec.summary = "Simple low-level client for Redis 6+"
   spec.homepage = "https://github.com/redis-rb/redis-client"
+  spec.license = "MIT"
   spec.required_ruby_version = ">= 2.5.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
@@ -22,13 +23,10 @@ Gem::Specification.new do |spec|
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features|benchmark)/|\.(?:git|travis|circleci)|appveyor)})
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|hiredis-client|test|spec|features|benchmark)/|\.(?:git|rubocop))})
     end
   end
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.extensions = ["ext/redis_client/hiredis/extconf.rb"]
 
   spec.add_runtime_dependency "connection_pool"
 end