redis-client 0.1.0

data/ext/redis_client/hiredis/vendor/test.sh

@@ -0,0 +1,78 @@
+#!/bin/sh -ue
+
+REDIS_SERVER=${REDIS_SERVER:-redis-server}
+REDIS_PORT=${REDIS_PORT:-56379}
+REDIS_SSL_PORT=${REDIS_SSL_PORT:-56443}
+TEST_SSL=${TEST_SSL:-0}
+SKIPS_AS_FAILS=${SKIPS_AS_FAILS-:0}
+SSL_TEST_ARGS=
+SKIPS_ARG=
+
+tmpdir=$(mktemp -d)
+PID_FILE=${tmpdir}/hiredis-test-redis.pid
+SOCK_FILE=${tmpdir}/hiredis-test-redis.sock
+
+if [ "$TEST_SSL" = "1" ]; then
+    SSL_CA_CERT=${tmpdir}/ca.crt
+    SSL_CA_KEY=${tmpdir}/ca.key
+    SSL_CERT=${tmpdir}/redis.crt
+    SSL_KEY=${tmpdir}/redis.key
+
+    openssl genrsa -out ${tmpdir}/ca.key 4096
+    openssl req \
+        -x509 -new -nodes -sha256 \
+        -key ${SSL_CA_KEY} \
+        -days 3650 \
+        -subj '/CN=Hiredis Test CA' \
+        -out ${SSL_CA_CERT}
+    openssl genrsa -out ${SSL_KEY} 2048
+    openssl req \
+        -new -sha256 \
+        -key ${SSL_KEY} \
+        -subj '/CN=Hiredis Test Cert' | \
+        openssl x509 \
+            -req -sha256 \
+            -CA ${SSL_CA_CERT} \
+            -CAkey ${SSL_CA_KEY} \
+            -CAserial ${tmpdir}/ca.txt \
+            -CAcreateserial \
+            -days 365 \
+            -out ${SSL_CERT}
+
+    SSL_TEST_ARGS="--ssl-host 127.0.0.1 --ssl-port ${REDIS_SSL_PORT} --ssl-ca-cert ${SSL_CA_CERT} --ssl-cert ${SSL_CERT} --ssl-key ${SSL_KEY}"
+fi
+
+cleanup() {
+  set +e
+  kill $(cat ${PID_FILE})
+  rm -rf ${tmpdir}
+}
+trap cleanup INT TERM EXIT
+
+cat > ${tmpdir}/redis.conf <<EOF
+daemonize yes
+pidfile ${PID_FILE}
+port ${REDIS_PORT}
+bind 127.0.0.1
+unixsocket ${SOCK_FILE}
+EOF
+
+if [ "$TEST_SSL" = "1" ]; then
+    cat >> ${tmpdir}/redis.conf <<EOF
+tls-port ${REDIS_SSL_PORT}
+tls-ca-cert-file ${SSL_CA_CERT}
+tls-cert-file ${SSL_CERT}
+tls-key-file ${SSL_KEY}
+EOF
+fi
+
+cat ${tmpdir}/redis.conf
+${REDIS_SERVER} ${tmpdir}/redis.conf
+
+# Wait until we detect the unix socket
+while [ ! -S "${SOCK_FILE}" ]; do sleep 1; done
+
+# Treat skips as failures if directed
+[ "$SKIPS_AS_FAILS" = 1 ] && SKIPS_ARG="--skips-as-fails"
+
+${TEST_PREFIX:-} ./hiredis-test -h 127.0.0.1 -p ${REDIS_PORT} -s ${SOCK_FILE} ${SSL_TEST_ARGS} ${SKIPS_ARG}

data/ext/redis_client/hiredis/vendor/win32.h

@@ -0,0 +1,56 @@
+#ifndef _WIN32_HELPER_INCLUDE
+#define _WIN32_HELPER_INCLUDE
+#ifdef _MSC_VER
+
+#include <winsock2.h> /* for struct timeval */
+
+#ifndef inline
+#define inline __inline
+#endif
+
+#ifndef strcasecmp
+#define strcasecmp stricmp
+#endif
+
+#ifndef strncasecmp
+#define strncasecmp strnicmp
+#endif
+
+#ifndef va_copy
+#define va_copy(d,s) ((d) = (s))
+#endif
+
+#ifndef snprintf
+#define snprintf c99_snprintf
+
+__inline int c99_vsnprintf(char* str, size_t size, const char* format, va_list ap)
+{
+    int count = -1;
+
+    if (size != 0)
+        count = _vsnprintf_s(str, size, _TRUNCATE, format, ap);
+    if (count == -1)
+        count = _vscprintf(format, ap);
+
+    return count;
+}
+
+__inline int c99_snprintf(char* str, size_t size, const char* format, ...)
+{
+    int count;
+    va_list ap;
+
+    va_start(ap, format);
+    count = c99_vsnprintf(str, size, format, ap);
+    va_end(ap);
+
+    return count;
+}
+#endif
+#endif /* _MSC_VER */
+
+#ifdef _WIN32
+#define strerror_r(errno,buf,len) strerror_s(buf,len,errno)
+#endif /* _WIN32 */
+
+#endif /* _WIN32_HELPER_INCLUDE */

data/lib/redis-client.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "redis_client"

data/lib/redis_client/buffered_io.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "io/wait" unless IO.method_defined?(:wait_readable) && IO.method_defined?(:wait_writable)
+
+class RedisClient
+  class BufferedIO
+    EOL = "\r\n".b.freeze
+    EOL_SIZE = EOL.bytesize
+
+    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

data/lib/redis_client/config.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "uri"
+
+class RedisClient
+  class Config
+    DEFAULT_TIMEOUT = 1.0
+    DEFAULT_HOST = "localhost"
+    DEFAULT_PORT = 6379
+    DEFAULT_USERNAME = "default"
+    DEFAULT_DB = 0
+
+    module Common
+      attr_reader :db, :username, :password, :id, :ssl, :ssl_params,
+        :connect_timeout, :read_timeout, :write_timeout, :driver, :connection_prelude
+
+      alias_method :ssl?, :ssl
+
+      def initialize(
+        username: nil,
+        password: nil,
+        db: nil,
+        id: nil,
+        timeout: DEFAULT_TIMEOUT,
+        read_timeout: timeout,
+        write_timeout: timeout,
+        connect_timeout: timeout,
+        ssl: nil,
+        ssl_params: nil,
+        driver: :ruby,
+        reconnect_attempts: false
+      )
+        @username = username || DEFAULT_USERNAME
+        @password = password
+        @db = db || DEFAULT_DB
+        @id = id
+        @ssl = ssl || false
+
+        @ssl_params = ssl_params
+        @connect_timeout = connect_timeout
+        @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
+
+        reconnect_attempts = Array.new(reconnect_attempts, 0).freeze if reconnect_attempts.is_a?(Integer)
+        @reconnect_attempts = reconnect_attempts
+
+        @connection_prelude = build_connection_prelude
+      end
+
+      def sentinel?
+        false
+      end
+
+      def new_pool(**kwargs)
+        kwargs[:timeout] ||= DEFAULT_TIMEOUT
+        Pooled.new(self, **kwargs)
+      end
+
+      def new_client(**kwargs)
+        RedisClient.new(self, **kwargs)
+      end
+
+      def retry_connecting?(attempt, _error)
+        if @reconnect_attempts
+          if (pause = @reconnect_attempts[attempt])
+            if pause > 0
+              sleep(pause)
+            end
+            return true
+          end
+        end
+        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
+      end
+
+      private
+
+      def build_connection_prelude
+        prelude = []
+        prelude <<  if @password
+          ["HELLO", "3", "AUTH", @username, @password]
+        else
+          ["HELLO", "3"]
+        end
+
+        if @db && @db != 0
+          prelude << ["SELECT", @db.to_s]
+        end
+        prelude.freeze
+      end
+    end
+
+    include Common
+
+    attr_reader :host, :port, :path
+
+    def initialize(
+      url: nil,
+      host: nil,
+      port: nil,
+      path: nil,
+      **kwargs
+    )
+      uri = url && URI.parse(url)
+      if uri
+        kwargs[:ssl] = uri.scheme == "rediss" unless kwargs.key?(:ssl)
+
+        kwargs[:username] ||= uri.user && uri.password
+
+        kwargs[:password] ||= if uri.user && !uri.password
+          URI.decode_www_form_component(uri.user)
+        elsif uri&.user && uri&.password
+          URI.decode_www_form_component(uri.password)
+        end
+
+        kwargs[:db] ||= Integer(uri.path.delete_prefix("/")) if uri.path && !uri.path.empty?
+      end
+
+      super(**kwargs)
+
+      @host = host || uri&.host || DEFAULT_HOST
+      @port = port || uri&.port || DEFAULT_PORT
+      @path = path
+    end
+  end
+end

data/lib/redis_client/connection.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "socket"
+require "openssl"
+require "redis_client/buffered_io"
+
+class RedisClient
+  class Connection
+    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)
+        # 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.hostname = config.host
+        loop do
+          case status = socket.connect_nonblock(exception: false)
+          when :wait_readable
+            socket.to_io.wait_readable(connect_timeout) or raise ReadTimeoutError
+          when :wait_writable
+            socket.to_io.wait_writable(connect_timeout) or raise WriteTimeoutError
+          when socket
+            break
+          else
+            raise "Unexpected `connect_nonblock` return: #{status.inspect}"
+          end
+        end
+      end
+
+      @io = BufferedIO.new(
+        socket,
+        read_timeout: read_timeout,
+        write_timeout: write_timeout,
+      )
+    rescue Errno::ETIMEDOUT => error
+      raise ConnectTimeoutError, error.message
+    rescue SystemCallError, OpenSSL::SSL::SSLError => error
+      raise ConnectionError, error.message
+    end
+
+    def connected?
+      !@io.closed?
+    end
+
+    def close
+      @io.close
+    end
+
+    def write(command)
+      buffer = RESP3.dump(command)
+      begin
+        @io.write(buffer)
+      rescue SystemCallError, IOError => error
+        raise ConnectionError, error.message
+      end
+    end
+
+    def write_multi(commands)
+      buffer = nil
+      commands.each do |command|
+        buffer = RESP3.dump(command, buffer)
+      end
+      begin
+        @io.write(buffer)
+      rescue SystemCallError, IOError => error
+        raise ConnectionError, error.message
+      end
+    end
+
+    def read(timeout = nil)
+      if timeout.nil?
+        RESP3.load(@io)
+      else
+        @io.with_timeout(timeout) { RESP3.load(@io) }
+      end
+    rescue SystemCallError, IOError, OpenSSL::SSL::SSLError => error
+      raise ConnectionError, error.message
+    end
+  end
+end

data/lib/redis_client/hiredis_connection.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "redis_client/hiredis_connection.so"
+
+class RedisClient
+  class HiredisConnection
+    class SSLContext
+      def initialize(ca_file: nil, ca_path: nil, cert: nil, key: nil, hostname: nil)
+        if (error = init(ca_file, ca_path, cert, key, hostname))
+          raise error
+        end
+      end
+    end
+
+    def initialize(config, connect_timeout:, read_timeout:, write_timeout:)
+      self.connect_timeout = connect_timeout
+      self.read_timeout = read_timeout
+      self.write_timeout = write_timeout
+
+      if config.path
+        connect_unix(config.path)
+      else
+        connect_tcp(config.host, config.port)
+      end
+
+      if config.ssl
+        init_ssl(config.hiredis_ssl_context)
+      end
+    end
+
+    def connect_timeout=(timeout)
+      self.connect_timeout_us = timeout ? (timeout * 1_000_000).to_i : 0
+      @connect_timeout = timeout
+    end
+
+    def read_timeout=(timeout)
+      self.read_timeout_us = timeout ? (timeout * 1_000_000).to_i : 0
+      @read_timeout = timeout
+    end
+
+    def write_timeout=(timeout)
+      self.write_timeout_us = timeout ? (timeout * 1_000_000).to_i : 0
+      @write_timeout = timeout
+    end
+
+    def read(timeout = nil)
+      if timeout.nil?
+        _read
+      else
+        previous_timeout = @read_timeout
+        self.read_timeout = timeout
+        begin
+          _read
+        ensure
+          self.read_timeout = previous_timeout
+        end
+      end
+    rescue SystemCallError, IOError => error
+      raise ConnectionError, error.message
+    end
+
+    def write(command)
+      _write(command)
+      flush
+    rescue SystemCallError, IOError => error
+      raise ConnectionError, error.message
+    end
+
+    def write_multi(commands)
+      commands.each do |command|
+        _write(command)
+      end
+      flush
+    rescue SystemCallError, IOError => error
+      raise ConnectionError, error.message
+    end
+  end
+end

data/lib/redis_client/pooled.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "connection_pool"
+
+class RedisClient
+  class Pooled
+    EMPTY_HASH = {}.freeze
+
+    attr_reader :config
+
+    def initialize(config, **kwargs)
+      @config = config
+      @pool_kwargs = kwargs
+      @pool = new_pool
+      @mutex = Mutex.new
+    end
+
+    def with(options = EMPTY_HASH, &block)
+      pool.with(options, &block)
+    rescue ConnectionPool::TimeoutError => error
+      raise CheckoutTimeoutError, "Couldn't checkout a connection in time: #{error.message}"
+    end
+    alias_method :then, :with
+
+    def close
+      if @pool
+        @mutex.synchronize do
+          pool = @pool
+          @pool = nil
+          pool&.shutdown(&:close)
+        end
+      end
+      nil
+    end
+
+    def size
+      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
+
+    %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)
+          end
+
+          with { |r| r.#{method}(*args, &block) }
+        end
+      RUBY
+    end
+
+    private
+
+    def pool
+      @pool ||= @mutex.synchronize { new_pool }
+    end
+
+    def new_pool
+      ConnectionPool.new(**@pool_kwargs) { @config.new_client }
+    end
+  end
+end