redis 3.3.5 → 4.7.0

data/lib/redis/client.rb

@@ -1,29 +1,38 @@
-require "redis/errors"
+# frozen_string_literal: true
+
 require "socket"
 require "cgi"
+require "redis/errors"
 
 class Redis
   class Client
-
+    # Defaults are also used for converting string keys to symbols.
     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,
-      :inherit_socket => false
-    }
-
-    def options
-      Marshal.load(Marshal.dump(@options))
-    end
+      url: -> { ENV["REDIS_URL"] },
+      scheme: "redis",
+      host: "127.0.0.1",
+      port: 6379,
+      path: nil,
+      read_timeout: nil,
+      write_timeout: nil,
+      connect_timeout: nil,
+      timeout: 5.0,
+      username: nil,
+      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,
+      logger: nil,
+      sentinels: nil,
+      role: nil
+    }.freeze
+
+    attr_reader :options, :connection, :command_map
 
     def scheme
       @options[:scheme]
@@ -53,6 +62,10 @@ class Redis
       @options[:read_timeout]
     end
 
+    def username
+      @options[:username]
+    end
+
     def password
       @options[:password]
     end
@@ -74,8 +87,6 @@ class Redis
     end
 
     attr_accessor :logger
-    attr_reader :connection
-    attr_reader :command_map
 
     def initialize(options = {})
       @options = _parse_options(options)
@@ -86,11 +97,14 @@ class Redis
 
       @pending_reads = 0
 
-      if options.include?(:sentinels)
-        @connector = Connector::Sentinel.new(@options)
-      else
-        @connector = Connector.new(@options)
-      end
+      @connector =
+        if !@options[:sentinels].nil?
+          Connector::Sentinel.new(@options)
+        elsif options.include?(:connector) && options[:connector].respond_to?(:new)
+          options.delete(:connector).new(@options)
+        else
+          Connector.new(@options)
+        end
     end
 
     def connect
@@ -99,7 +113,34 @@ class Redis
       # Don't try to reconnect when the connection is fresh
       with_reconnect(false) do
         establish_connection
-        call [:auth, password] if password
+        if password
+          if username
+            begin
+              call [:auth, username, password]
+            rescue CommandError => err # Likely on Redis < 6
+              case err.message
+              when /ERR wrong number of arguments for 'auth' command/
+                call [:auth, password]
+              when /WRONGPASS invalid username-password pair/
+                begin
+                  call [:auth, password]
+                rescue CommandError
+                  raise err
+                end
+                ::Redis.deprecate!(
+                  "[redis-rb] The Redis connection was configured with username #{username.inspect}, but" \
+                  " the provided password was for the default user. This will start failing in redis-rb 5.0.0."
+                )
+              else
+                raise
+              end
+            end
+          else
+            call [:auth, password]
+          end
+        end
+
+        call [:readonly] if @options[:readonly]
         call [:select, db] if db != 0
         call [:client, :setname, @options[:id]] if @options[:id]
         @connector.check(self)
@@ -109,7 +150,7 @@ class Redis
     end
 
     def id
-      @options[:id] || "redis://#{location}/#{db}"
+      @options[:id] || "#{@options[:ssl] ? 'rediss' : @options[:scheme]}://#{location}/#{db}"
     end
 
     def location
@@ -120,7 +161,7 @@ class Redis
       reply = process([command]) { read }
       raise reply if reply.is_a?(CommandError)
 
-      if block_given?
+      if block_given? && reply != 'QUEUED'
         yield reply
       else
         reply
@@ -152,13 +193,16 @@ class Redis
     end
 
     def call_pipeline(pipeline)
+      return [] if pipeline.futures.empty?
+
       with_reconnect pipeline.with_reconnect? do
         begin
-          pipeline.finish(call_pipelined(pipeline.commands)).tap do
+          pipeline.finish(call_pipelined(pipeline)).tap do
             self.db = pipeline.db if pipeline.db
           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.
@@ -167,8 +211,8 @@ class Redis
       end
     end
 
-    def call_pipelined(commands)
-      return [] if commands.empty?
+    def call_pipelined(pipeline)
+      return [] if pipeline.futures.empty?
 
       # The method #ensure_connected (called from #process) reconnects once on
       # I/O errors. To make an effort in making sure that commands are not
@@ -178,6 +222,8 @@ class Redis
       # already successfully executed commands. To circumvent this, don't retry
       # after the first reply has been read successfully.
 
+      commands = pipeline.commands
+
       result = Array.new(commands.size)
       reconnect = @reconnect
 
@@ -185,13 +231,14 @@ class Redis
         exception = nil
 
         process(commands) do
-          result[0] = read
-
-          @reconnect = false
-
-          (commands.size - 1).times do |i|
-            reply = read
-            result[i + 1] = reply
+          pipeline.timeouts.each_with_index do |timeout, i|
+            reply = if timeout
+              with_socket_timeout(timeout) { read }
+            else
+              read
+            end
+            result[i] = reply
+            @reconnect = false
             exception = reply if exception.nil? && reply.is_a?(CommandError)
           end
         end
@@ -204,7 +251,8 @@ class Redis
       result
     end
 
-    def call_with_timeout(command, timeout, &blk)
+    def call_with_timeout(command, extra_timeout, &blk)
+      timeout = extra_timeout == 0 ? 0 : self.timeout + extra_timeout
       with_socket_timeout(timeout) do
         call(command, &blk)
       end
@@ -234,12 +282,13 @@ class Redis
     end
 
     def connected?
-      !! (connection && connection.connected?)
+      !!(connection && connection.connected?)
     end
 
     def disconnect
       connection.disconnect if connected?
     end
+    alias close disconnect
 
     def reconnect
       disconnect
@@ -274,12 +323,15 @@ class Redis
 
     def with_socket_timeout(timeout)
       connect unless connected?
+      original = @options[:read_timeout]
 
       begin
         connection.timeout = timeout
+        @options[:read_timeout] = timeout # for reconnection
         yield
       ensure
         connection.timeout = self.timeout if connected?
+        @options[:read_timeout] = original
       end
     end
 
@@ -287,30 +339,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 }
@@ -336,13 +385,17 @@ class Redis
       @connection = @options[:driver].connect(@options)
       @pending_reads = 0
     rescue TimeoutError,
+           SocketError,
+           Errno::EADDRNOTAVAIL,
            Errno::ECONNREFUSED,
            Errno::EHOSTDOWN,
            Errno::EHOSTUNREACH,
            Errno::ENETUNREACH,
-           Errno::ETIMEDOUT
+           Errno::ENOENT,
+           Errno::ETIMEDOUT,
+           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
@@ -356,9 +409,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
@@ -369,6 +422,10 @@ class Redis
         disconnect
 
         if attempts <= @options[:reconnect_attempts] && @reconnect
+          sleep_t = [(@options[:reconnect_delay] * 2**(attempts - 1)),
+                     @options[:reconnect_delay_max]].min
+
+          Kernel.sleep(sleep_t)
           retry
         else
           raise
@@ -385,17 +442,16 @@ class Redis
       defaults = DEFAULTS.dup
       options = options.dup
 
-      defaults.keys.each do |key|
+      defaults.each_key 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] || defaults[:url]
+      url = options[:url]
+      url = defaults[:url] if url.nil?
 
       # Override defaults from URL if given
       if url
@@ -403,13 +459,15 @@ class Redis
 
         uri = URI(url)
 
-        if uri.scheme == "unix"
-          defaults[:path]   = uri.path
-        elsif uri.scheme == "redis" || uri.scheme == "rediss"
+        case uri.scheme
+        when "unix"
+          defaults[:path] = uri.path
+        when "redis", "rediss"
           defaults[:scheme]   = uri.scheme
-          defaults[:host]     = uri.host if uri.host
+          defaults[:host]     = uri.host.sub(/\A\[(.*)\]\z/, '\1') if uri.host
           defaults[:port]     = uri.port if uri.port
-          defaults[:password] = CGI.unescape(uri.password) if uri.password
+          defaults[:username] = CGI.unescape(uri.user) if uri.user && !uri.user.empty?
+          defaults[:password] = CGI.unescape(uri.password) if uri.password && !uri.password.empty?
           defaults[:db]       = uri.path[1..-1].to_i if uri.path
           defaults[:role] = :master
         else
@@ -420,7 +478,7 @@ class Redis
       end
 
       # Use default when option is not specified or nil
-      defaults.keys.each do |key|
+      defaults.each_key do |key|
         options[key] = defaults[key] if options[key].nil?
       end
 
@@ -435,7 +493,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]
@@ -445,12 +503,16 @@ class Redis
       options[:read_timeout]    = Float(options[:read_timeout])
       options[:write_timeout]   = Float(options[:write_timeout])
 
+      options[:reconnect_attempts] = options[:reconnect_attempts].to_i
+      options[:reconnect_delay] = options[:reconnect_delay].to_f
+      options[:reconnect_delay_max] = options[:reconnect_delay_max].to_f
+
       options[:db] = options[:db].to_i
       options[:driver] = _parse_driver(options[:driver]) || Connection.drivers.last
 
       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
@@ -458,13 +520,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
 
@@ -476,13 +538,18 @@ 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 "redis/connection/#{driver}"
-          driver = Connection.const_get(driver.capitalize)
+          require_relative "connection/#{driver}"
         rescue LoadError, NameError
-          raise RuntimeError, "Cannot load driver #{driver.inspect}"
+          begin
+            require "redis/connection/#{driver}"
+          rescue LoadError, NameError => error
+            raise "Cannot load driver #{driver.inspect}: #{error.message}"
+          end
         end
+
+        driver = Connection.const_get(driver.capitalize)
       end
 
       driver
@@ -497,18 +564,16 @@ class Redis
         @options
       end
 
-      def check(client)
-      end
+      def check(client); end
 
       class Sentinel < Connector
         def initialize(options)
           super(options)
 
-          @options[:password] = DEFAULTS.fetch(:password)
           @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
 
@@ -531,13 +596,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
@@ -545,10 +610,12 @@ class Redis
         def sentinel_detect
           @sentinels.each do |sentinel|
             client = Client.new(@options.merge({
-              :host => sentinel[:host],
-              :port => sentinel[:port],
-              :reconnect_attempts => 0,
-            }))
+                                                 host: sentinel[:host] || sentinel["host"],
+                                                 port: sentinel[:port] || sentinel["port"],
+                                                 username: sentinel[:username] || sentinel["username"],
+                                                 password: sentinel[:password] || sentinel["password"],
+                                                 reconnect_attempts: 0
+                                               }))
 
             begin
               if result = yield(client)
@@ -570,7 +637,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
@@ -578,9 +645,19 @@ class Redis
         def resolve_slave
           sentinel_detect do |client|
             if reply = client.call(["sentinel", "slaves", @master])
-              slave = Hash[*reply.sample]
-
-              {:host => slave.fetch("ip"), :port => slave.fetch("port")}
+              slaves = reply.map { |s| s.each_slice(2).to_h }
+              slaves.each { |s| s['flags'] = s.fetch('flags').split(',') }
+              slaves.reject! { |s| s.fetch('flags').include?('s_down') }
+
+              if slaves.empty?
+                raise CannotConnectError, 'No slaves available.'
+              else
+                slave = slaves.sample
+                {
+                  host: slave.fetch('ip'),
+                  port: slave.fetch('port')
+                }
+              end
             end
           end
         end

data/lib/redis/cluster/command.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative '../errors'
+
+class Redis
+  class Cluster
+    # Keep details about Redis commands for Redis Cluster Client.
+    # @see https://redis.io/commands/command
+    class Command
+      def initialize(details)
+        @details = pick_details(details)
+      end
+
+      def extract_first_key(command)
+        i = determine_first_key_position(command)
+        return '' if i == 0
+
+        key = command[i].to_s
+        hash_tag = extract_hash_tag(key)
+        hash_tag.empty? ? key : hash_tag
+      end
+
+      def should_send_to_master?(command)
+        dig_details(command, :write)
+      end
+
+      def should_send_to_slave?(command)
+        dig_details(command, :readonly)
+      end
+
+      private
+
+      def pick_details(details)
+        details.transform_values do |detail|
+          {
+            first_key_position: detail[:first],
+            write: detail[:flags].include?('write'),
+            readonly: detail[:flags].include?('readonly')
+          }
+        end
+      end
+
+      def dig_details(command, key)
+        name = command.first.to_s
+        return unless @details.key?(name)
+
+        @details.fetch(name).fetch(key)
+      end
+
+      def determine_first_key_position(command)
+        case command.first.to_s.downcase
+        when 'eval', 'evalsha', 'migrate', 'zinterstore', 'zunionstore' then 3
+        when 'object' then 2
+        when 'memory'
+          command[1].to_s.casecmp('usage').zero? ? 2 : 0
+        when 'xread', 'xreadgroup'
+          determine_optional_key_position(command, 'streams')
+        else
+          dig_details(command, :first_key_position).to_i
+        end
+      end
+
+      def determine_optional_key_position(command, option_name)
+        idx = command.map(&:to_s).map(&:downcase).index(option_name)
+        idx.nil? ? 0 : idx + 1
+      end
+
+      # @see https://redis.io/topics/cluster-spec#keys-hash-tags Keys hash tags
+      def extract_hash_tag(key)
+        s = key.index('{')
+        e = key.index('}', s.to_i + 1)
+
+        return '' if s.nil? || e.nil?
+
+        key[s + 1..e - 1]
+      end
+    end
+  end
+end

data/lib/redis/cluster/command_loader.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'redis/errors'
+
+class Redis
+  class Cluster
+    # Load details about Redis commands for Redis Cluster Client
+    # @see https://redis.io/commands/command
+    module CommandLoader
+      module_function
+
+      def load(nodes)
+        errors = nodes.map do |node|
+          begin
+            return fetch_command_details(node)
+          rescue CannotConnectError, ConnectionError, CommandError => error
+            error
+          end
+        end
+
+        raise InitialSetupError, errors
+      end
+
+      def fetch_command_details(node)
+        node.call(%i[command]).map do |reply|
+          [reply[0], { arity: reply[1], flags: reply[2], first: reply[3], last: reply[4], step: reply[5] }]
+        end.to_h
+      end
+
+      private_class_method :fetch_command_details
+    end
+  end
+end