redis-client 0.1.0 → 0.3.0

data/lib/redis_client/pooled.rb

@@ -6,17 +6,29 @@ class RedisClient
   class Pooled
     EMPTY_HASH = {}.freeze
 
-    attr_reader :config
+    include Common
 
-    def initialize(config, **kwargs)
-      @config = config
+    def initialize(
+      config,
+      id: config.id,
+      connect_timeout: config.connect_timeout,
+      read_timeout: config.read_timeout,
+      write_timeout: config.write_timeout,
+      **kwargs
+    )
+      super(config, id: id, connect_timeout: connect_timeout, read_timeout: read_timeout, write_timeout: write_timeout)
       @pool_kwargs = kwargs
       @pool = new_pool
       @mutex = Mutex.new
     end
 
-    def with(options = EMPTY_HASH, &block)
-      pool.with(options, &block)
+    def with(options = EMPTY_HASH)
+      pool.with(options) do |client|
+        client.connect_timeout = connect_timeout
+        client.read_timeout = read_timeout
+        client.write_timeout = write_timeout
+        yield client
+      end
     rescue ConnectionPool::TimeoutError => error
       raise CheckoutTimeoutError, "Couldn't checkout a connection in time: #{error.message}"
     end
@@ -37,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
+    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(multi).each do |method|
-      class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def #{method}(**kwargs, &block)
-          with { |r| r.#{method}(**kwargs, &block) }
-        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(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
-
-    %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

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}"
@@ -147,7 +121,7 @@ class RedisClient
       str = io.gets_chomp
       str.force_encoding(Encoding.default_external)
       str.force_encoding(Encoding::BINARY) unless str.valid_encoding?
-      str
+      str.freeze
     end
 
     def parse_error(io)

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

@@ -2,22 +2,60 @@
 
 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
+  class RubyConnection
+    include ConnectionMixin
+
+    class << self
+      def ssl_context(ssl_params)
+        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
+    end
+
+    SUPPORTS_RESOLV_TIMEOUT = Socket.method(:tcp).parameters.any? { |p| p.last == :resolv_timeout }
+
     def initialize(config, connect_timeout:, read_timeout:, write_timeout:)
       socket = if config.path
         UNIXSocket.new(config.path)
       else
-        sock = Socket.tcp(config.host, config.port, connect_timeout: connect_timeout)
+        sock = if SUPPORTS_RESOLV_TIMEOUT
+          Socket.tcp(config.host, config.port, connect_timeout: connect_timeout, resolv_timeout: connect_timeout)
+        else
+          Socket.tcp(config.host, config.port, connect_timeout: connect_timeout)
+        end
         # disables Nagle's Algorithm, prevents multiple round trips with MULTI
         sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
         sock
       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)
@@ -40,7 +78,7 @@ class RedisClient
       )
     rescue Errno::ETIMEDOUT => error
       raise ConnectTimeoutError, error.message
-    rescue SystemCallError, OpenSSL::SSL::SSLError => error
+    rescue SystemCallError, OpenSSL::SSL::SSLError, SocketError => error
       raise ConnectionError, error.message
     end
 
@@ -52,6 +90,14 @@ class RedisClient
       @io.close
     end
 
+    def read_timeout=(timeout)
+      @io.read_timeout = timeout if @io
+    end
+
+    def write_timeout=(timeout)
+      @io.write_timeout = timeout if @io
+    end
+
     def write(command)
       buffer = RESP3.dump(command)
       begin

data/lib/redis_client/version.rb

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