class RedisClient::RubyConnection

Constants

SUPPORTS_RESOLV_TIMEOUT

Public Class Methods

new(config, connect_timeout:, read_timeout:, write_timeout:) click to toggle source
Calls superclass method RedisClient::ConnectionMixin::new
# File lib/redis_client/ruby_connection.rb, line 43
def initialize(config, connect_timeout:, read_timeout:, write_timeout:)
  super()
  socket = if config.path
    UNIXSocket.new(config.path)
  else
    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.ssl_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 CannotConnectError
      when :wait_writable
        socket.to_io.wait_writable(connect_timeout) or raise CannotConnectError
      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 SystemCallError, OpenSSL::SSL::SSLError, SocketError => error
  raise CannotConnectError, error.message, error.backtrace
end
ssl_context(ssl_params) click to toggle source
# File lib/redis_client/ruby_connection.rb, line 14
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

Public Instance Methods

close() click to toggle source
# File lib/redis_client/ruby_connection.rb, line 88
def close
  @io.close
end
connected?() click to toggle source
# File lib/redis_client/ruby_connection.rb, line 84
def connected?
  !@io.closed?
end
read(timeout = nil) click to toggle source
# File lib/redis_client/ruby_connection.rb, line 121
def read(timeout = nil)
  if timeout.nil?
    RESP3.load(@io)
  else
    @io.with_timeout(timeout) { RESP3.load(@io) }
  end
rescue RedisClient::RESP3::UnknownType => error
  raise RedisClient::ProtocolError, error.message
rescue SystemCallError, IOError, OpenSSL::SSL::SSLError => error
  raise ConnectionError, error.message
end
read_timeout=(timeout) click to toggle source
# File lib/redis_client/ruby_connection.rb, line 92
def read_timeout=(timeout)
  @io.read_timeout = timeout if @io
end
write(command) click to toggle source
# File lib/redis_client/ruby_connection.rb, line 100
def write(command)
  buffer = RESP3.dump(command)
  begin
    @io.write(buffer)
  rescue SystemCallError, IOError => error
    raise ConnectionError, error.message
  end
end
write_multi(commands) click to toggle source
# File lib/redis_client/ruby_connection.rb, line 109
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
write_timeout=(timeout) click to toggle source
# File lib/redis_client/ruby_connection.rb, line 96
def write_timeout=(timeout)
  @io.write_timeout = timeout if @io
end