redis 3.0.0 → 4.2.2

data/lib/redis/connection/hiredis.rb

@@ -1,23 +1,27 @@
-require "redis/connection/registry"
-require "redis/errors"
+# frozen_string_literal: true
+
+require_relative "registry"
+require_relative "../errors"
 require "hiredis/connection"
 require "timeout"
 
 class Redis
   module Connection
     class Hiredis
-
       def self.connect(config)
         connection = ::Hiredis::Connection.new
+        connect_timeout = (config.fetch(:connect_timeout, 0) * 1_000_000).to_i
 
         if config[:scheme] == "unix"
-          connection.connect_unix(config[:path], Integer(config[:timeout] * 1_000_000))
+          connection.connect_unix(config[:path], connect_timeout)
+        elsif config[:scheme] == "rediss" || config[:ssl]
+          raise NotImplementedError, "SSL not supported by hiredis driver"
         else
-          connection.connect(config[:host], config[:port], Integer(config[:timeout] * 1_000_000))
+          connection.connect(config[:host], config[:port], connect_timeout)
         end
 
         instance = new(connection)
-        instance.timeout = config[:timeout]
+        instance.timeout = config[:read_timeout]
         instance
       rescue Errno::ETIMEDOUT
         raise TimeoutError
@@ -28,7 +32,7 @@ class Redis
       end
 
       def connected?
-        @connection && @connection.connected?
+        @connection&.connected?
       end
 
       def timeout=(timeout)
@@ -54,7 +58,7 @@ class Redis
       rescue Errno::EAGAIN
         raise TimeoutError
       rescue RuntimeError => err
-        raise ProtocolError.new(err.message)
+        raise ProtocolError, err.message
       end
     end
   end

data/lib/redis/connection/registry.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 class Redis
   module Connection
-
     # Store a list of loaded connection drivers in the Connection module.
     # Redis::Client uses the last required driver by default, and will be aware
     # of the loaded connection drivers if the user chooses to override the

data/lib/redis/connection/ruby.rb

@@ -1,44 +1,48 @@
-require "redis/connection/registry"
-require "redis/connection/command_helper"
-require "redis/errors"
+# frozen_string_literal: true
+
+require_relative "registry"
+require_relative "command_helper"
+require_relative "../errors"
 require "socket"
+require "timeout"
+
+begin
+  require "openssl"
+rescue LoadError
+  # Not all systems have OpenSSL support
+end
 
 class Redis
   module Connection
     module SocketMixin
-
-      CRLF = "\r\n".freeze
+      CRLF = "\r\n"
 
       def initialize(*args)
         super(*args)
 
-        @timeout = nil
-        @buffer = ""
+        @timeout = @write_timeout = nil
+        @buffer = "".dup
       end
 
       def timeout=(timeout)
-        if timeout && timeout > 0
-          @timeout = timeout
-        else
-          @timeout = nil
-        end
+        @timeout = (timeout if timeout && timeout > 0)
+      end
+
+      def write_timeout=(timeout)
+        @write_timeout = (timeout if timeout && timeout > 0)
       end
 
       def read(nbytes)
         result = @buffer.slice!(0, nbytes)
 
-        while result.bytesize < nbytes
-          result << _read_from_socket(nbytes - result.bytesize)
-        end
+        result << _read_from_socket(nbytes - result.bytesize) while result.bytesize < nbytes
 
         result
       end
 
       def gets
-        crlf = nil
-
-        while (crlf = @buffer.index(CRLF)) == nil
-          @buffer << _read_from_socket(1024)
+        while (crlf = @buffer.index(CRLF)).nil?
+          @buffer << _read_from_socket(16_384)
         end
 
         @buffer.slice!(0, crlf + CRLF.bytesize)
@@ -47,18 +51,57 @@ class Redis
       def _read_from_socket(nbytes)
         begin
           read_nonblock(nbytes)
-
-        rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+        rescue IO::WaitReadable
           if IO.select([self], nil, nil, @timeout)
             retry
           else
             raise Redis::TimeoutError
           end
+        rescue IO::WaitWritable
+          if IO.select(nil, [self], nil, @timeout)
+            retry
+          else
+            raise Redis::TimeoutError
+          end
         end
+      rescue EOFError
+        raise Errno::ECONNRESET
+      end
 
+      def _write_to_socket(data)
+        begin
+          write_nonblock(data)
+        rescue IO::WaitWritable
+          if IO.select(nil, [self], nil, @write_timeout)
+            retry
+          else
+            raise Redis::TimeoutError
+          end
+        rescue IO::WaitReadable
+          if IO.select([self], nil, nil, @write_timeout)
+            retry
+          else
+            raise Redis::TimeoutError
+          end
+        end
       rescue EOFError
         raise Errno::ECONNRESET
       end
+
+      def write(data)
+        return super(data) unless @write_timeout
+
+        length = data.bytesize
+        total_count = 0
+        loop do
+          count = _write_to_socket(data)
+
+          total_count += count
+          return total_count if total_count >= length
+
+          data = data.byteslice(count..-1)
+        end
+      end
     end
 
     if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
@@ -66,7 +109,6 @@ class Redis
       require "timeout"
 
       class TCPSocket < ::TCPSocket
-
         include SocketMixin
 
         def self.connect(host, port, timeout)
@@ -79,42 +121,46 @@ class Redis
         end
       end
 
-      class UNIXSocket < ::UNIXSocket
+      if defined?(::UNIXSocket)
 
-        # This class doesn't include the mixin, because JRuby raises
-        # Errno::EAGAIN on #read_nonblock even when IO.select says it is
-        # readable. This behavior shows in 1.6.6 in both 1.8 and 1.9 mode.
-        # Therefore, fall back on the default Unix socket implementation,
-        # without timeouts.
+        class UNIXSocket < ::UNIXSocket
+          include SocketMixin
 
-        def self.connect(path, timeout)
-          Timeout.timeout(timeout) do
-            sock = new(path)
-            sock
+          def self.connect(path, timeout)
+            Timeout.timeout(timeout) do
+              sock = new(path)
+              sock
+            end
+          rescue Timeout::Error
+            raise TimeoutError
+          end
+
+          # JRuby raises Errno::EAGAIN on #read_nonblock even when IO.select
+          # says it is readable (1.6.6, in both 1.8 and 1.9 mode).
+          # Use the blocking #readpartial method instead.
+
+          def _read_from_socket(nbytes)
+            readpartial(nbytes)
+          rescue EOFError
+            raise Errno::ECONNRESET
           end
-        rescue Timeout::Error
-          raise TimeoutError
         end
+
       end
 
     else
 
       class TCPSocket < ::Socket
-
         include SocketMixin
 
-        def self.connect(host, port, timeout)
-          # Limit lookup to IPv4, as Redis doesn't yet do IPv6...
-          addr = ::Socket.getaddrinfo(host, nil, Socket::AF_INET)
-          sock = new(::Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
-          sockaddr = ::Socket.pack_sockaddr_in(port, addr[0][3])
+        def self.connect_addrinfo(addrinfo, port, timeout)
+          sock = new(::Socket.const_get(addrinfo[0]), Socket::SOCK_STREAM, 0)
+          sockaddr = ::Socket.pack_sockaddr_in(port, addrinfo[3])
 
           begin
             sock.connect_nonblock(sockaddr)
           rescue Errno::EINPROGRESS
-            if IO.select(nil, [sock], nil, timeout) == nil
-              raise TimeoutError
-            end
+            raise TimeoutError if IO.select(nil, [sock], nil, timeout).nil?
 
             begin
               sock.connect_nonblock(sockaddr)
@@ -124,12 +170,43 @@ class Redis
 
           sock
         end
+
+        def self.connect(host, port, timeout)
+          # Don't pass AI_ADDRCONFIG as flag to getaddrinfo(3)
+          #
+          # From the man page for getaddrinfo(3):
+          #
+          #   If hints.ai_flags includes the AI_ADDRCONFIG flag, then IPv4
+          #   addresses are returned in the list pointed to by res only if the
+          #   local system has at least one IPv4 address configured, and IPv6
+          #   addresses are returned only if the local system has at least one
+          #   IPv6 address configured. The loopback address is not considered
+          #   for this case as valid as a configured address.
+          #
+          # We do want the IPv6 loopback address to be returned if applicable,
+          # even if it is the only configured IPv6 address on the machine.
+          # Also see: https://github.com/redis/redis-rb/pull/394.
+          addrinfo = ::Socket.getaddrinfo(host, nil, Socket::AF_UNSPEC, Socket::SOCK_STREAM)
+
+          # From the man page for getaddrinfo(3):
+          #
+          #   Normally, the application should try using the addresses in the
+          #   order in which they are returned. The sorting function used
+          #   within getaddrinfo() is defined in RFC 3484 [...].
+          #
+          addrinfo.each_with_index do |ai, i|
+            begin
+              return connect_addrinfo(ai, port, timeout)
+            rescue SystemCallError
+              # Raise if this was our last attempt.
+              raise if addrinfo.length == i + 1
+            end
+          end
+        end
       end
 
       class UNIXSocket < ::Socket
-
-        # This class doesn't include the mixin to keep its behavior in sync
-        # with the JRuby implementation.
+        include SocketMixin
 
         def self.connect(path, timeout)
           sock = new(::Socket::AF_UNIX, Socket::SOCK_STREAM, 0)
@@ -138,9 +215,7 @@ class Redis
           begin
             sock.connect_nonblock(sockaddr)
           rescue Errno::EINPROGRESS
-            if IO.select(nil, [sock], nil, timeout) == nil
-              raise TimeoutError
-            end
+            raise TimeoutError if IO.select(nil, [sock], nil, timeout).nil?
 
             begin
               sock.connect_nonblock(sockaddr)
@@ -154,33 +229,125 @@ class Redis
 
     end
 
+    if defined?(OpenSSL)
+      class SSLSocket < ::OpenSSL::SSL::SSLSocket
+        include SocketMixin
+
+        def self.connect(host, port, timeout, ssl_params)
+          # Note: this is using Redis::Connection::TCPSocket
+          tcp_sock = TCPSocket.connect(host, port, timeout)
+
+          ctx = OpenSSL::SSL::SSLContext.new
+
+          # The provided parameters are merged into OpenSSL::SSL::SSLContext::DEFAULT_PARAMS
+          ctx.set_params(ssl_params || {})
+
+          ssl_sock = new(tcp_sock, ctx)
+          ssl_sock.hostname = host
+
+          begin
+            # Initiate the socket connection in the background. If it doesn't fail
+            # immediately it will raise an IO::WaitWritable (Errno::EINPROGRESS)
+            # indicating the connection is in progress.
+            # Unlike waiting for a tcp socket to connect, you can't time out ssl socket
+            # connections during the connect phase properly, because IO.select only partially works.
+            # Instead, you have to retry.
+            ssl_sock.connect_nonblock
+          rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
+            if IO.select([ssl_sock], nil, nil, timeout)
+              retry
+            else
+              raise TimeoutError
+            end
+          rescue IO::WaitWritable
+            if IO.select(nil, [ssl_sock], nil, timeout)
+              retry
+            else
+              raise TimeoutError
+            end
+          end
+
+          unless ctx.verify_mode == OpenSSL::SSL::VERIFY_NONE || (
+            ctx.respond_to?(:verify_hostname) &&
+            !ctx.verify_hostname
+          )
+            ssl_sock.post_connection_check(host)
+          end
+
+          ssl_sock
+        end
+      end
+    end
+
     class Ruby
       include Redis::Connection::CommandHelper
 
-      MINUS    = "-".freeze
-      PLUS     = "+".freeze
-      COLON    = ":".freeze
-      DOLLAR   = "$".freeze
-      ASTERISK = "*".freeze
+      MINUS    = "-"
+      PLUS     = "+"
+      COLON    = ":"
+      DOLLAR   = "$"
+      ASTERISK = "*"
 
       def self.connect(config)
         if config[:scheme] == "unix"
-          sock = UNIXSocket.connect(config[:path], config[:timeout])
+          raise ArgumentError, "SSL incompatible with unix sockets" if config[:ssl]
+
+          sock = UNIXSocket.connect(config[:path], config[:connect_timeout])
+        elsif config[:scheme] == "rediss" || config[:ssl]
+          sock = SSLSocket.connect(config[:host], config[:port], config[:connect_timeout], config[:ssl_params])
         else
-          sock = TCPSocket.connect(config[:host], config[:port], config[:timeout])
+          sock = TCPSocket.connect(config[:host], config[:port], config[:connect_timeout])
         end
 
         instance = new(sock)
-        instance.timeout = config[:timeout]
+        instance.timeout = config[:read_timeout]
+        instance.write_timeout = config[:write_timeout]
+        instance.set_tcp_keepalive config[:tcp_keepalive]
+        instance.set_tcp_nodelay if sock.is_a? TCPSocket
         instance
       end
 
+      if %i[SOL_SOCKET SO_KEEPALIVE SOL_TCP TCP_KEEPIDLE TCP_KEEPINTVL TCP_KEEPCNT].all? { |c| Socket.const_defined? c }
+        def set_tcp_keepalive(keepalive)
+          return unless keepalive.is_a?(Hash)
+
+          @sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE,  true)
+          @sock.setsockopt(Socket::SOL_TCP,    Socket::TCP_KEEPIDLE,  keepalive[:time])
+          @sock.setsockopt(Socket::SOL_TCP,    Socket::TCP_KEEPINTVL, keepalive[:intvl])
+          @sock.setsockopt(Socket::SOL_TCP,    Socket::TCP_KEEPCNT,   keepalive[:probes])
+        end
+
+        def get_tcp_keepalive
+          {
+            time: @sock.getsockopt(Socket::SOL_TCP, Socket::TCP_KEEPIDLE).int,
+            intvl: @sock.getsockopt(Socket::SOL_TCP, Socket::TCP_KEEPINTVL).int,
+            probes: @sock.getsockopt(Socket::SOL_TCP, Socket::TCP_KEEPCNT).int
+          }
+        end
+      else
+        def set_tcp_keepalive(keepalive); end
+
+        def get_tcp_keepalive
+          {
+          }
+        end
+      end
+
+      # disables Nagle's Algorithm, prevents multiple round trips with MULTI
+      if %i[IPPROTO_TCP TCP_NODELAY].all? { |c| Socket.const_defined? c }
+        def set_tcp_nodelay
+          @sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        end
+      else
+        def set_tcp_nodelay; end
+      end
+
       def initialize(sock)
         @sock = sock
       end
 
       def connected?
-        !! @sock
+        !!@sock
       end
 
       def disconnect
@@ -191,9 +358,11 @@ class Redis
       end
 
       def timeout=(timeout)
-        if @sock.respond_to?(:timeout=)
-          @sock.timeout = timeout
-        end
+        @sock.timeout = timeout if @sock.respond_to?(:timeout=)
+      end
+
+      def write_timeout=(timeout)
+        @sock.write_timeout = timeout
       end
 
       def write(command)
@@ -204,7 +373,6 @@ class Redis
         line = @sock.gets
         reply_type = line.slice!(0, 1)
         format_reply(reply_type, line)
-
       rescue Errno::EAGAIN
         raise TimeoutError
       end
@@ -216,7 +384,7 @@ class Redis
         when COLON    then format_integer_reply(line)
         when DOLLAR   then format_bulk_reply(line)
         when ASTERISK then format_multi_bulk_reply(line)
-        else raise ProtocolError.new(reply_type)
+        else raise ProtocolError, reply_type
         end
       end
 
@@ -235,6 +403,7 @@ class Redis
       def format_bulk_reply(line)
         bulklen = line.to_i
         return if bulklen == -1
+
         reply = encode(@sock.read(bulklen))
         @sock.read(2) # Discard CRLF.
         reply