redis-client 0.2.1 → 0.5.0

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

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.1"
+  VERSION = "0.5.0"
 end