redis 4.1.2 → 4.2.2

data/lib/redis/cluster/slot.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 class Redis
   class Cluster
     # Keep slot and node key map for Redis Cluster Client
@@ -28,11 +26,20 @@ class Redis
         return nil unless exists?(slot)
         return find_node_key_of_master(slot) if replica_disabled?
 
-        @map[slot][:slaves].to_a.sample
+        @map[slot][:slaves].sample
       end
 
       def put(slot, node_key)
-        assign_node_key(@map, slot, node_key)
+        # Since we're sharing a hash for build_slot_node_key_map, duplicate it
+        # if it already exists instead of preserving as-is.
+        @map[slot] = @map[slot] ? @map[slot].dup : { master: nil, slaves: [] }
+
+        if master?(node_key)
+          @map[slot][:master] = node_key
+        elsif !@map[slot][:slaves].include?(node_key)
+          @map[slot][:slaves] << node_key
+        end
+
         nil
       end
 
@@ -50,19 +57,29 @@ class Redis
         @node_flags[node_key] == ROLE_SLAVE
       end
 
+      # available_slots is mapping of node_key to list of slot ranges
       def build_slot_node_key_map(available_slots)
-        available_slots.each_with_object({}) do |(node_key, slots), acc|
-          slots.each { |slot| assign_node_key(acc, slot, node_key) }
+        by_ranges = {}
+        available_slots.each do |node_key, slots_arr|
+          by_ranges[slots_arr] ||= { master: nil, slaves: [] }
+
+          if master?(node_key)
+            by_ranges[slots_arr][:master] = node_key
+          elsif !by_ranges[slots_arr][:slaves].include?(node_key)
+            by_ranges[slots_arr][:slaves] << node_key
+          end
         end
-      end
 
-      def assign_node_key(mappings, slot, node_key)
-        mappings[slot] ||= { master: nil, slaves: ::Set.new }
-        if master?(node_key)
-          mappings[slot][:master] = node_key
-        else
-          mappings[slot][:slaves].add(node_key)
+        by_slot = {}
+        by_ranges.each do |slots_arr, nodes|
+          slots_arr.each do |slots|
+            slots.each do |slot|
+              by_slot[slot] = nodes
+            end
+          end
         end
+
+        by_slot
       end
     end
   end

data/lib/redis/cluster/slot_loader.rb

@@ -13,7 +13,7 @@ class Redis
         info = {}
 
         nodes.each do |node|
-          info = Hash[*fetch_slot_info(node)]
+          info = fetch_slot_info(node)
           info.empty? ? next : break
         end
 
@@ -23,9 +23,10 @@ class Redis
       end
 
       def fetch_slot_info(node)
+        hash_with_default_arr = Hash.new { |h, k| h[k] = [] }
         node.call(%i[cluster slots])
-            .map { |arr| parse_slot_info(arr, default_ip: node.host) }
-            .flatten
+            .flat_map { |arr| parse_slot_info(arr, default_ip: node.host) }
+            .each_with_object(hash_with_default_arr) { |arr, h| h[arr[0]] << arr[1] }
       rescue CannotConnectError, ConnectionError, CommandError
         {} # can retry on another node
       end
@@ -34,7 +35,6 @@ class Redis
         first_slot, last_slot = arr[0..1]
         slot_range = (first_slot..last_slot).freeze
         arr[2..-1].map { |addr| [stringify_node_key(addr, default_ip), slot_range] }
-                  .flatten
       end
 
       def stringify_node_key(arr, default_ip)

data/lib/redis/connection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "connection/registry"
 
 # If a connection driver was required before this file, the array

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)
@@ -28,7 +29,7 @@ class Redis
         command.join(COMMAND_DELIMITER)
       end
 
-    protected
+      protected
 
       def encode(string)
         string.force_encoding(Encoding.default_external)

data/lib/redis/connection/hiredis.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "registry"
 require_relative "../errors"
 require "hiredis/connection"
@@ -6,7 +8,6 @@ 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,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "registry"
 require_relative "command_helper"
 require_relative "../errors"
@@ -13,8 +15,7 @@ end
 class Redis
   module Connection
     module SocketMixin
-
-      CRLF = "\r\n".freeze
+      CRLF = "\r\n"
 
       def initialize(*args)
         super(*args)
@@ -24,46 +25,32 @@ class Redis
       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
+        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)
       end
 
       def _read_from_socket(nbytes)
-
         begin
           read_nonblock(nbytes)
-
         rescue IO::WaitReadable
           if IO.select([self], nil, nil, @timeout)
             retry
@@ -77,7 +64,6 @@ class Redis
             raise Redis::TimeoutError
           end
         end
-
       rescue EOFError
         raise Errno::ECONNRESET
       end
@@ -85,7 +71,6 @@ class Redis
       def _write_to_socket(data)
         begin
           write_nonblock(data)
-
         rescue IO::WaitWritable
           if IO.select(nil, [self], nil, @write_timeout)
             retry
@@ -99,7 +84,6 @@ class Redis
             raise Redis::TimeoutError
           end
         end
-
       rescue EOFError
         raise Errno::ECONNRESET
       end
@@ -114,6 +98,7 @@ class Redis
 
           total_count += count
           return total_count if total_count >= length
+
           data = data.byteslice(count..-1)
         end
       end
@@ -124,7 +109,6 @@ class Redis
       require "timeout"
 
       class TCPSocket < ::TCPSocket
-
         include SocketMixin
 
         def self.connect(host, port, timeout)
@@ -140,7 +124,6 @@ class Redis
       if defined?(::UNIXSocket)
 
         class UNIXSocket < ::UNIXSocket
-
           include SocketMixin
 
           def self.connect(path, timeout)
@@ -158,7 +141,6 @@ class Redis
 
           def _read_from_socket(nbytes)
             readpartial(nbytes)
-
           rescue EOFError
             raise Errno::ECONNRESET
           end
@@ -169,19 +151,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 if IO.select(nil, [sock], nil, timeout).nil?
 
             begin
               sock.connect_nonblock(sockaddr)
@@ -220,14 +199,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)
@@ -237,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)
@@ -262,7 +238,9 @@ class Redis
           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
@@ -289,7 +267,10 @@ class Redis
             end
           end
 
-          unless ctx.verify_mode == OpenSSL::SSL::VERIFY_NONE
+          unless ctx.verify_mode == OpenSSL::SSL::VERIFY_NONE || (
+            ctx.respond_to?(:verify_hostname) &&
+            !ctx.verify_hostname
+          )
             ssl_sock.post_connection_check(host)
           end
 
@@ -301,15 +282,16 @@ 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]
           sock = SSLSocket.connect(config[:host], config[:port], config[:connect_timeout], config[:ssl_params])
@@ -321,10 +303,11 @@ class Redis
         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)
 
@@ -336,14 +319,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
           {
@@ -351,12 +333,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
@@ -367,9 +358,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)
@@ -384,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
@@ -396,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
 
@@ -415,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