redis 4.1.4 → 4.2.0

data/lib/redis/client.rb

@@ -6,24 +6,25 @@ require "cgi"
 
 class Redis
   class Client
-
     DEFAULTS = {
-      :url => lambda { ENV["REDIS_URL"] },
-      :scheme => "redis",
-      :host => "127.0.0.1",
-      :port => 6379,
-      :path => nil,
-      :timeout => 5.0,
-      :password => nil,
-      :db => 0,
-      :driver => nil,
-      :id => nil,
-      :tcp_keepalive => 0,
-      :reconnect_attempts => 1,
-      :reconnect_delay => 0,
-      :reconnect_delay_max => 0.5,
-      :inherit_socket => false
-    }
+      url: -> { ENV["REDIS_URL"] },
+      scheme: "redis",
+      host: "127.0.0.1",
+      port: 6379,
+      path: nil,
+      timeout: 5.0,
+      password: nil,
+      db: 0,
+      driver: nil,
+      id: nil,
+      tcp_keepalive: 0,
+      reconnect_attempts: 1,
+      reconnect_delay: 0,
+      reconnect_delay_max: 0.5,
+      inherit_socket: false,
+      sentinels: nil,
+      role: nil
+    }.freeze
 
     attr_reader :options
 
@@ -89,7 +90,7 @@ class Redis
       @pending_reads = 0
 
       @connector =
-        if options.include?(:sentinels)
+        if !@options[:sentinels].nil?
           Connector::Sentinel.new(@options)
         elsif options.include?(:connector) && options[:connector].respond_to?(:new)
           options.delete(:connector).new(@options)
@@ -166,6 +167,7 @@ class Redis
           end
         rescue ConnectionError => e
           return nil if pipeline.shutdown?
+
           # Assume the pipeline was sent in one piece, but execution of
           # SHUTDOWN caused none of the replies for commands that were executed
           # prior to it from coming back around.
@@ -244,13 +246,13 @@ class Redis
     end
 
     def connected?
-      !! (connection && connection.connected?)
+      !!(connection && connection.connected?)
     end
 
     def disconnect
       connection.disconnect if connected?
     end
-    alias_method :close, :disconnect
+    alias close disconnect
 
     def reconnect
       disconnect
@@ -301,30 +303,27 @@ class Redis
       with_socket_timeout(0, &blk)
     end
 
-    def with_reconnect(val=true)
-      begin
-        original, @reconnect = @reconnect, val
-        yield
-      ensure
-        @reconnect = original
-      end
+    def with_reconnect(val = true)
+      original, @reconnect = @reconnect, val
+      yield
+    ensure
+      @reconnect = original
     end
 
     def without_reconnect(&blk)
       with_reconnect(false, &blk)
     end
 
-  protected
+    protected
 
     def logging(commands)
-      return yield unless @logger && @logger.debug?
+      return yield unless @logger&.debug?
 
       begin
         commands.each do |name, *args|
           logged_args = args.map do |a|
-            case
-            when a.respond_to?(:inspect) then a.inspect
-            when a.respond_to?(:to_s)    then a.to_s
+            if a.respond_to?(:inspect) then a.inspect
+            elsif a.respond_to?(:to_s) then a.to_s
             else
               # handle poorly-behaved descendants of BasicObject
               klass = a.instance_exec { (class << self; self end).superclass }
@@ -358,9 +357,9 @@ class Redis
            Errno::ENETUNREACH,
            Errno::ENOENT,
            Errno::ETIMEDOUT,
-           Errno::EINVAL
+           Errno::EINVAL => error
 
-      raise CannotConnectError, "Error connecting to Redis on #{location} (#{$!.class})"
+      raise CannotConnectError, "Error connecting to Redis on #{location} (#{error.class})"
     end
 
     def ensure_connected
@@ -374,9 +373,9 @@ class Redis
         if connected?
           unless inherit_socket? || Process.pid == @pid
             raise InheritedError,
-              "Tried to use a connection from a child process without reconnecting. " +
-              "You need to reconnect to Redis after forking " +
-              "or set :inherit_socket to true."
+                  "Tried to use a connection from a child process without reconnecting. " \
+                  "You need to reconnect to Redis after forking " \
+                  "or set :inherit_socket to true."
           end
         else
           connect
@@ -387,7 +386,7 @@ class Redis
         disconnect
 
         if attempts <= @options[:reconnect_attempts] && @reconnect
-          sleep_t = [(@options[:reconnect_delay] * 2**(attempts-1)),
+          sleep_t = [(@options[:reconnect_delay] * 2**(attempts - 1)),
                      @options[:reconnect_delay_max]].min
 
           Kernel.sleep(sleep_t)
@@ -409,16 +408,14 @@ class Redis
 
       defaults.keys.each do |key|
         # Fill in defaults if needed
-        if defaults[key].respond_to?(:call)
-          defaults[key] = defaults[key].call
-        end
+        defaults[key] = defaults[key].call if defaults[key].respond_to?(:call)
 
         # Symbolize only keys that are needed
-        options[key] = options[key.to_s] if options.has_key?(key.to_s)
+        options[key] = options[key.to_s] if options.key?(key.to_s)
       end
 
       url = options[:url]
-      url = defaults[:url] if url == nil
+      url = defaults[:url] if url.nil?
 
       # Override defaults from URL if given
       if url
@@ -427,7 +424,7 @@ class Redis
         uri = URI(url)
 
         if uri.scheme == "unix"
-          defaults[:path]   = uri.path
+          defaults[:path] = uri.path
         elsif uri.scheme == "redis" || uri.scheme == "rediss"
           defaults[:scheme]   = uri.scheme
           defaults[:host]     = uri.host if uri.host
@@ -458,7 +455,7 @@ class Redis
         options[:port] = options[:port].to_i
       end
 
-      if options.has_key?(:timeout)
+      if options.key?(:timeout)
         options[:connect_timeout] ||= options[:timeout]
         options[:read_timeout]    ||= options[:timeout]
         options[:write_timeout]   ||= options[:timeout]
@@ -477,7 +474,7 @@ class Redis
 
       case options[:tcp_keepalive]
       when Hash
-        [:time, :intvl, :probes].each do |key|
+        %i[time intvl probes].each do |key|
           unless options[:tcp_keepalive][key].is_a?(Integer)
             raise "Expected the #{key.inspect} key in :tcp_keepalive to be an Integer"
           end
@@ -485,13 +482,13 @@ class Redis
 
       when Integer
         if options[:tcp_keepalive] >= 60
-          options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 20, :intvl => 10, :probes => 2}
+          options[:tcp_keepalive] = { time: options[:tcp_keepalive] - 20, intvl: 10, probes: 2 }
 
         elsif options[:tcp_keepalive] >= 30
-          options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 10, :intvl => 5, :probes => 2}
+          options[:tcp_keepalive] = { time: options[:tcp_keepalive] - 10, intvl: 5, probes: 2 }
 
         elsif options[:tcp_keepalive] >= 5
-          options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 2, :intvl => 2, :probes => 1}
+          options[:tcp_keepalive] = { time: options[:tcp_keepalive] - 2, intvl: 2, probes: 1 }
         end
       end
 
@@ -503,14 +500,14 @@ class Redis
     def _parse_driver(driver)
       driver = driver.to_s if driver.is_a?(Symbol)
 
-      if driver.kind_of?(String)
+      if driver.is_a?(String)
         begin
           require_relative "connection/#{driver}"
-        rescue LoadError, NameError => e
+        rescue LoadError, NameError
           begin
             require "connection/#{driver}"
-          rescue LoadError, NameError => e
-            raise RuntimeError, "Cannot load driver #{driver.inspect}: #{e.message}"
+          rescue LoadError, NameError => error
+            raise "Cannot load driver #{driver.inspect}: #{error.message}"
           end
         end
 
@@ -529,8 +526,7 @@ class Redis
         @options
       end
 
-      def check(client)
-      end
+      def check(client); end
 
       class Sentinel < Connector
         def initialize(options)
@@ -539,7 +535,7 @@ class Redis
           @options[:db] = DEFAULTS.fetch(:db)
 
           @sentinels = @options.delete(:sentinels).dup
-          @role = @options.fetch(:role, "master").to_s
+          @role = (@options[:role] || "master").to_s
           @master = @options[:host]
         end
 
@@ -562,13 +558,13 @@ class Redis
 
         def resolve
           result = case @role
-                   when "master"
-                     resolve_master
-                   when "slave"
-                     resolve_slave
-                   else
-                     raise ArgumentError, "Unknown instance role #{@role}"
-                   end
+          when "master"
+            resolve_master
+          when "slave"
+            resolve_slave
+          else
+            raise ArgumentError, "Unknown instance role #{@role}"
+          end
 
           result || (raise ConnectionError, "Unable to fetch #{@role} via Sentinel.")
         end
@@ -576,11 +572,11 @@ class Redis
         def sentinel_detect
           @sentinels.each do |sentinel|
             client = Client.new(@options.merge({
-              :host => sentinel[:host],
-              :port => sentinel[:port],
-              password: sentinel[:password],
-              :reconnect_attempts => 0,
-            }))
+                                                 host: sentinel[:host] || sentinel["host"],
+                                                 port: sentinel[:port] || sentinel["port"],
+                                                 password: sentinel[:password] || sentinel["password"],
+                                                 reconnect_attempts: 0
+                                               }))
 
             begin
               if result = yield(client)
@@ -602,7 +598,7 @@ class Redis
         def resolve_master
           sentinel_detect do |client|
             if reply = client.call(["sentinel", "get-master-addr-by-name", @master])
-              {:host => reply[0], :port => reply[1]}
+              { host: reply[0], port: reply[1] }
             end
           end
         end
@@ -620,7 +616,7 @@ class Redis
                 slave = slaves.sample
                 {
                   host: slave.fetch('ip'),
-                  port: slave.fetch('port'),
+                  port: slave.fetch('port')
                 }
               end
             end

data/lib/redis/cluster.rb

@@ -80,6 +80,7 @@ class Redis
     def call_pipeline(pipeline)
       node_keys, command_keys = extract_keys_in_pipeline(pipeline)
       raise CrossSlotPipeliningError, command_keys if node_keys.size > 1
+
       node = find_node(node_keys.first)
       try_send(node, :call_pipeline, pipeline)
     end
@@ -216,11 +217,13 @@ class Redis
     rescue CommandError => err
       if err.message.start_with?('MOVED')
         raise if retry_count <= 0
+
         node = assign_redirection_node(err.message)
         retry_count -= 1
         retry
       elsif err.message.start_with?('ASK')
         raise if retry_count <= 0
+
         node = assign_asking_node(err.message)
         node.call(%i[asking])
         retry_count -= 1
@@ -266,6 +269,7 @@ class Redis
 
     def find_node(node_key)
       return @node.sample if node_key.nil?
+
       @node.find_by(node_key)
     rescue Node::ReloadNeeded
       update_cluster_info!(node_key)

data/lib/redis/cluster/node.rb

@@ -39,6 +39,7 @@ class Redis
       def call_master(command, &block)
         try_map do |node_key, client|
           next if slave?(node_key)
+
           client.call(command, &block)
         end.values
       end
@@ -48,6 +49,7 @@ class Redis
 
         try_map do |node_key, client|
           next if master?(node_key)
+
           client.call(command, &block)
         end.values
       end
@@ -97,6 +99,7 @@ class Redis
         end
 
         return results if errors.empty?
+
         raise CommandErrorCollection, errors
       end
     end

data/lib/redis/cluster/option.rb

@@ -43,6 +43,7 @@ class Redis
 
       def build_node_options(addrs)
         raise InvalidClientOptionError, 'Redis option of `cluster` must be an Array' unless addrs.is_a?(Array)
+
         addrs.map { |addr| parse_node_addr(addr) }
       end
 
@@ -69,7 +70,9 @@ class Redis
 
       def parse_node_option(addr)
         addr = addr.map { |k, v| [k.to_sym, v] }.to_h
-        raise InvalidClientOptionError, 'Redis option of `cluster` must includes `:host` and `:port` keys' if addr.values_at(:host, :port).any?(&:nil?)
+        if addr.values_at(:host, :port).any?(&:nil?)
+          raise InvalidClientOptionError, 'Redis option of `cluster` must includes `:host` and `:port` keys'
+        end
 
         addr
       end

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
 
@@ -52,20 +59,27 @@ class Redis
 
       # 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_arr), acc|
-          slots_arr.each do |slots|
-            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

@@ -25,9 +25,8 @@ class Redis
       def fetch_slot_info(node)
         hash_with_default_arr = Hash.new { |h, k| h[k] = [] }
         node.call(%i[cluster slots])
-          .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] }
-
+            .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