redis 3.3.5 → 4.5.1

data/lib/redis/connection/command_helper.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 class Redis
   module Connection
     module CommandHelper
-
       COMMAND_DELIMITER = "\r\n"
 
       def build_command(args)
@@ -11,11 +12,13 @@ class Redis
           if i.is_a? Array
             i.each do |j|
               j = j.to_s
+              j = j.encoding == Encoding::BINARY ? j : j.b
               command << "$#{j.bytesize}"
               command << j
             end
           else
             i = i.to_s
+            i = i.encoding == Encoding::BINARY ? i : i.b
             command << "$#{i.bytesize}"
             command << i
           end
@@ -28,16 +31,10 @@ class Redis
         command.join(COMMAND_DELIMITER)
       end
 
-    protected
+      protected
 
-      if defined?(Encoding::default_external)
-        def encode(string)
-          string.force_encoding(Encoding::default_external)
-        end
-      else
-        def encode(string)
-          string
-        end
+      def encode(string)
+        string.force_encoding(Encoding.default_external)
       end
     end
   end

data/lib/redis/connection/hiredis.rb

@@ -1,12 +1,13 @@
-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
@@ -31,7 +32,7 @@ class Redis
       end
 
       def connected?
-        @connection && @connection.connected?
+        @connection&.connected?
       end
 
       def timeout=(timeout)
@@ -57,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,6 +1,8 @@
-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"
 
@@ -10,130 +12,88 @@ rescue LoadError
   # Not all systems have OpenSSL support
 end
 
-if RUBY_VERSION < "1.9.3"
-  class String
-    # Ruby 1.8.7 does not have byteslice, but it handles encodings differently anyway.
-    # We can simply slice the string, which is a byte array there.
-    def byteslice(*args)
-      slice(*args)
-    end
-  end
-end
-
 class Redis
   module Connection
     module SocketMixin
-
-      CRLF = "\r\n".freeze
-
-      # Exceptions raised during non-blocking I/O ops that require retrying the op
-      if RUBY_VERSION >= "1.9.3"
-        NBIO_READ_EXCEPTIONS = [IO::WaitReadable]
-        NBIO_WRITE_EXCEPTIONS = [IO::WaitWritable]
-      else
-        NBIO_READ_EXCEPTIONS = [Errno::EWOULDBLOCK, Errno::EAGAIN]
-        NBIO_WRITE_EXCEPTIONS = [Errno::EWOULDBLOCK, Errno::EAGAIN]
-      end
+      CRLF = "\r\n"
 
       def initialize(*args)
         super(*args)
 
         @timeout = @write_timeout = nil
-        @buffer = ""
+        @buffer = "".b
       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)
-        if timeout && timeout > 0
-          @write_timeout = timeout
-        else
-          @write_timeout = nil
-        end
+        @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
+        buffer = String.new(capacity: nbytes, encoding: Encoding::ASCII_8BIT)
+        result << _read_from_socket(nbytes - result.bytesize, buffer) 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)
       end
 
-      def _read_from_socket(nbytes)
-
-        begin
-          read_nonblock(nbytes)
-
-        rescue *NBIO_READ_EXCEPTIONS
-          if IO.select([self], nil, nil, @timeout)
-            retry
-          else
-            raise Redis::TimeoutError
-          end
-        rescue *NBIO_WRITE_EXCEPTIONS
-          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 *NBIO_WRITE_EXCEPTIONS
-          if IO.select(nil, [self], nil, @write_timeout)
-            retry
-          else
-            raise Redis::TimeoutError
-          end
-        rescue *NBIO_READ_EXCEPTIONS
-          if IO.select([self], nil, nil, @write_timeout)
-            retry
-          else
-            raise Redis::TimeoutError
+      def _read_from_socket(nbytes, buffer = nil)
+        loop do
+          case chunk = read_nonblock(nbytes, buffer, exception: false)
+          when :wait_readable
+            unless wait_readable(@timeout)
+              raise Redis::TimeoutError
+            end
+          when :wait_writable
+            unless wait_writable(@timeout)
+              raise Redis::TimeoutError
+            end
+          when nil
+            raise Errno::ECONNRESET
+          when String
+            return chunk
           end
         end
-
-      rescue EOFError
-        raise Errno::ECONNRESET
       end
 
-      def write(data)
-        return super(data) unless @write_timeout
+      def write(buffer)
+        return super(buffer) unless @write_timeout
 
-        length = data.bytesize
-        total_count = 0
+        bytes_to_write = buffer.bytesize
+        total_bytes_written = 0
         loop do
-          count = _write_to_socket(data)
+          case bytes_written = write_nonblock(buffer, exception: false)
+          when :wait_readable
+            unless wait_readable(@write_timeout)
+              raise Redis::TimeoutError
+            end
+          when :wait_writable
+            unless wait_writable(@write_timeout)
+              raise Redis::TimeoutError
+            end
+          when nil
+            raise Errno::ECONNRESET
+          when Integer
+            total_bytes_written += bytes_written
+
+            if total_bytes_written >= bytes_to_write
+              return total_bytes_written
+            end
 
-          total_count += count
-          return total_count if total_count >= length
-          data = data.byteslice(count..-1)
+            buffer = buffer.byteslice(bytes_written..-1)
+          end
         end
       end
     end
@@ -143,7 +103,6 @@ class Redis
       require "timeout"
 
       class TCPSocket < ::TCPSocket
-
         include SocketMixin
 
         def self.connect(host, port, timeout)
@@ -159,7 +118,6 @@ class Redis
       if defined?(::UNIXSocket)
 
         class UNIXSocket < ::UNIXSocket
-
           include SocketMixin
 
           def self.connect(path, timeout)
@@ -171,13 +129,12 @@ class Redis
             raise TimeoutError
           end
 
-          # JRuby raises Errno::EAGAIN on #read_nonblock even when IO.select
+          # JRuby raises Errno::EAGAIN on #read_nonblock even when it
           # 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
@@ -188,19 +145,16 @@ class Redis
     else
 
       class TCPSocket < ::Socket
-
         include SocketMixin
 
-        def self.connect_addrinfo(ai, port, timeout)
-          sock = new(::Socket.const_get(ai[0]), Socket::SOCK_STREAM, 0)
-          sockaddr = ::Socket.pack_sockaddr_in(port, ai[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 unless sock.wait_writable(timeout)
 
             begin
               sock.connect_nonblock(sockaddr)
@@ -239,14 +193,13 @@ class Redis
               return connect_addrinfo(ai, port, timeout)
             rescue SystemCallError
               # Raise if this was our last attempt.
-              raise if addrinfo.length == i+1
+              raise if addrinfo.length == i + 1
             end
           end
         end
       end
 
       class UNIXSocket < ::Socket
-
         include SocketMixin
 
         def self.connect(path, timeout)
@@ -256,9 +209,7 @@ class Redis
           begin
             sock.connect_nonblock(sockaddr)
           rescue Errno::EINPROGRESS
-            if IO.select(nil, [sock], nil, timeout) == nil
-              raise TimeoutError
-            end
+            raise TimeoutError unless sock.wait_writable(timeout)
 
             begin
               sock.connect_nonblock(sockaddr)
@@ -276,17 +227,58 @@ class Redis
       class SSLSocket < ::OpenSSL::SSL::SSLSocket
         include SocketMixin
 
+        unless method_defined?(:wait_readable)
+          def wait_readable(timeout = nil)
+            to_io.wait_readable(timeout)
+          end
+        end
+
+        unless method_defined?(:wait_writable)
+          def wait_writable(timeout = nil)
+            to_io.wait_writable(timeout)
+          end
+        end
+
         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
-          ctx.set_params(ssl_params) if ssl_params && !ssl_params.empty?
+
+          # 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
-          ssl_sock.connect
-          ssl_sock.post_connection_check(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 ssl_sock.wait_readable(timeout)
+              retry
+            else
+              raise TimeoutError
+            end
+          rescue IO::WaitWritable
+            if ssl_sock.wait_writable(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
@@ -296,31 +288,32 @@ class Redis
     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"
           raise ArgumentError, "SSL incompatible with unix sockets" if config[:ssl]
+
           sock = UNIXSocket.connect(config[:path], config[:connect_timeout])
         elsif config[:scheme] == "rediss" || config[:ssl]
-          raise ArgumentError, "This library does not support SSL on Ruby < 1.9" if RUBY_VERSION < "1.9.3"
           sock = SSLSocket.connect(config[:host], config[:port], config[:connect_timeout], config[:ssl_params])
         else
           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 [:SOL_SOCKET, :SO_KEEPALIVE, :SOL_TCP, :TCP_KEEPIDLE, :TCP_KEEPINTVL, :TCP_KEEPCNT].all?{|c| Socket.const_defined? c}
+      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)
 
@@ -332,14 +325,13 @@ class Redis
 
         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,
+            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 set_tcp_keepalive(keepalive); end
 
         def get_tcp_keepalive
           {
@@ -347,12 +339,21 @@ class Redis
         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
@@ -363,9 +364,7 @@ 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)
@@ -380,7 +379,6 @@ class Redis
         line = @sock.gets
         reply_type = line.slice!(0, 1)
         format_reply(reply_type, line)
-
       rescue Errno::EAGAIN
         raise TimeoutError
       end
@@ -392,7 +390,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
 
@@ -411,6 +409,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

data/lib/redis/connection/synchrony.rb

@@ -1,9 +1,16 @@
-require "redis/connection/command_helper"
-require "redis/connection/registry"
-require "redis/errors"
+# frozen_string_literal: true
+
+require_relative "command_helper"
+require_relative "registry"
+require_relative "../errors"
 require "em-synchrony"
 require "hiredis/reader"
 
+Kernel.warn(
+  "The redis synchrony driver is deprecated and will be removed in redis-rb 5.0. " \
+  "We're looking for people to maintain it as a separate gem, see https://github.com/redis/redis-rb/issues/915"
+)
+
 class Redis
   module Connection
     class RedisClient < EventMachine::Connection
@@ -46,9 +53,7 @@ class Redis
 
       def read
         @req = EventMachine::DefaultDeferrable.new
-        if @timeout > 0
-          @req.timeout(@timeout, :timeout)
-        end
+        @req.timeout(@timeout, :timeout) if @timeout > 0
         EventMachine::Synchrony.sync @req
       end
 
@@ -72,7 +77,15 @@ class Redis
 
       def self.connect(config)
         if config[:scheme] == "unix"
-          conn = EventMachine.connect_unix_domain(config[:path], RedisClient)
+          begin
+            conn = EventMachine.connect_unix_domain(config[:path], RedisClient)
+          rescue RuntimeError => e
+            if e.message == "no connection"
+              raise Errno::ECONNREFUSED
+            else
+              raise e
+            end
+          end
         elsif config[:scheme] == "rediss" || config[:ssl]
           raise NotImplementedError, "SSL not supported by synchrony driver"
         else
@@ -97,7 +110,7 @@ class Redis
       end
 
       def connected?
-        @connection && @connection.connected?
+        @connection&.connected?
       end
 
       def timeout=(timeout)

data/lib/redis/connection.rb

@@ -1,4 +1,6 @@
-require "redis/connection/registry"
+# frozen_string_literal: true
+
+require_relative "connection/registry"
 
 # If a connection driver was required before this file, the array
 # Redis::Connection.drivers will contain one or more classes. The last driver
@@ -6,4 +8,4 @@ require "redis/connection/registry"
 # the plain Ruby driver as our default. Another driver can be required at a
 # later point in time, causing it to be the last element of the #drivers array
 # and therefore be chosen by default.
-require "redis/connection/ruby" if Redis::Connection.drivers.empty?
+require_relative "connection/ruby" if Redis::Connection.drivers.empty?