redis-client 0.2.1 → 0.5.0

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

@@ -1,78 +0,0 @@
-#!/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

@@ -1,56 +0,0 @@
-#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/buffered_io.rb

@@ -1,151 +0,0 @@
-# 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
-
-    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

data/lib/redis_client/hiredis_connection.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require "redis_client/hiredis_connection.so"
-
-class RedisClient
-  class HiredisConnection
-    include Connection::Common
-
-    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