redis 4.1.1 → 4.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: fba6921160b00d34cc11548defceaaee4fc9c181
-  data.tar.gz: e5eac2ace205355e4890084cc96fe98c651e8d30
+SHA256:
+  metadata.gz: 862e8133262fead707e4ca317b29d0e35425e3a7861ea1a52033bc91ba61bf6d
+  data.tar.gz: 5b2b32250d783fe58b0af54cc386f2568241644a0badc0b7247bb29b1ac94a93
 SHA512:
-  metadata.gz: 5e88bba869f876bc046935479283f108b46107ab00e7ab60487ca524977635dbdc9b0dcfd037a9b057e43765975c26cdc3a0ceea95aefacf608041a18b50f14e
-  data.tar.gz: 91360e891b269c8ecb962414f29d023ace19af98e929d7f7680590dcb8520a87deb6c2a47ba27da0ea16eb47ee90d4c8bdf2be894a40c00820f9c07479188cc2
+  metadata.gz: 2aab289f4f22b2f3a804ca7b0da4cf95e352a8d246611490d8d803edebbbc7e7c299355cd0b90e6f3ac8bc0d11e9bf3792a328c95847d32e1d984729afe66ed2
+  data.tar.gz: d9ec8ba4d314d099e909cdddf6dfb4c3c14b853b46f45c4909ac3ba10fb1880bd9a7b0465257fa91f9a4ea6c9f82723c16c177810ac15c89fab3790d7af31ad0

data/CHANGELOG.md

@@ -1,5 +1,74 @@
 # Unreleased
 
+# 4.2.5
+
+* Optimize the ruby connector write buffering. See #964.
+
+# 4.2.4
+
+* Fix bytesize calculations in the ruby connector, and work on a copy of the buffer. Fix #961, #962.
+
+# 4.2.3
+
+* Use io/wait instead of IO.select in the ruby connector. See #960.
+* Use exception free non blocking IOs in the ruby connector. See #926.
+* Prevent corruption of the client when an interrupt happen during inside a pipeline block. See #945.
+
+# 4.2.2
+
+* Fix `WATCH` support for `Redis::Distributed`. See #941.
+* Fix handling of empty stream responses. See #905, #929.
+
+# 4.2.1
+
+* Fix `exists?` returning an actual boolean when called with multiple keys. See #918.
+* Setting `Redis.exists_returns_integer = false` disables warning message about new behaviour. See #920.
+
+# 4.2.0
+
+* Convert commands to accept keyword arguments rather than option hashes. This both help catching typos, and reduce needless allocations.
+* Deprecate the synchrony driver. It will be removed in 5.0 and hopefully maintained as a separate gem. See #915.
+* Make `Redis#exists` variadic, will return an Integer if called with multiple keys.
+* Add `Redis#exists?` to get a Boolean if any of the keys exists.
+* `Redis#exists` when called with a single key will warn that future versions will return an Integer.
+  Set `Redis.exists_returns_integer = true` to opt-in to the new behavior.
+* Support `keepttl` ooption in `set`. See #913.
+* Optimized initialization of Redis::Cluster. See #912.
+* Accept sentinel options even with string key. See #599.
+* Verify TLS connections by default. See #900.
+* Make `Redis#hset` variadic. It now returns an integer, not a boolean. See #910.
+
+# 4.1.4
+
+* Alias `Redis#disconnect` as `#close`. See #901.
+* Handle clusters with multiple slot ranges. See #894.
+* Fix password authentication to a redis cluster. See #889.
+* Handle recursive MOVED responses. See #882.
+* Increase buffer size in the ruby connector. See #880.
+* Fix thread safety of `Redis.queue`. See #878.
+* Deprecate `Redis::Future#==` as it's likely to be a mistake. See #876.
+* Support `KEEPTTL` option for SET command. See #913.
+
+# 4.1.3
+
+* Fix the client hanging forever when connecting with SSL to a non-SSL server. See #835.
+
+# 4.1.2
+
+* Fix several authentication problems with sentinel. See #850 and #856.
+* Explicitly drop Ruby 2.2 support.
+
+
+# 4.1.1
+
+* Fix error handling in multi blocks. See #754.
+* Fix geoadd to accept arrays like georadius and georadiusbymember. See #841.
+* Fix georadius command failing when long == lat. See #841.
+* Fix timeout error in xread block: 0. See #837.
+* Fix incompatibility issue with redis-objects. See #834.
+* Properly handle Errno::EADDRNOTAVAIL on connect.
+* Fix password authentication to sentinel instances. See #813.
+
 # 4.1.0
 
 * Add Redis Cluster support. See #716.

data/README.md

@@ -1,8 +1,9 @@
-# redis-rb [![Build Status][travis-image]][travis-link] [![Inline docs][inchpages-image]][inchpages-link]
+# redis-rb [![Build Status][travis-image]][travis-link] [![Inline docs][inchpages-image]][inchpages-link] ![](https://github.com/redis/redis-rb/workflows/Test/badge.svg?branch=master)
 
 A Ruby client that tries to match [Redis][redis-home]' API one-to-one, while still
 providing an idiomatic interface.
 
+See [RubyDoc.info][rubydoc] for the API docs of the latest published gem.
 
 ## Getting started
 
@@ -34,6 +35,9 @@ You can also specify connection options as a [`redis://` URL][redis-url]:
 redis = Redis.new(url: "redis://:p4ssw0rd@10.0.1.1:6380/15")
 ```
 
+The client expects passwords with special chracters to be URL-encoded (i.e.
+`CGI.escape(password)`).
+
 By default, the client will try to read the `REDIS_URL` environment variable
 and use that as URL to connect to. The above statement is therefore equivalent
 to setting this environment variable and calling `Redis.new` without arguments.
@@ -95,6 +99,15 @@ but a few so that if one is down the client will try the next one. The client
 is able to remember the last Sentinel that was able to reply correctly and will
 use it for the next requests.
 
+If you want to [authenticate](https://redis.io/topics/sentinel#configuring-sentinel-instances-with-authentication) Sentinel itself, you must specify the `password` option per instance.
+
+```ruby
+SENTINELS = [{ host: '127.0.0.1', port: 26380, password: 'mysecret' },
+             { host: '127.0.0.1', port: 26381, password: 'mysecret' }]
+
+redis = Redis.new(host: 'mymaster', sentinels: SENTINELS, role: :master)
+```
+
 ## Cluster support
 
 `redis-rb` supports [clustering](https://redis.io/topics/cluster-spec).
@@ -133,12 +146,13 @@ redis.mget('{key}1', '{key}2')
 ```
 
 * The client automatically reconnects after a failover occurred, but the caller is responsible for handling errors while it is happening.
+* The client support permanent node failures, and will reroute requests to promoted slaves.
 * The client supports `MOVED` and `ASK` redirections transparently.
 
 ## Storing objects
 
-Redis only stores strings as values. If you want to store an object, you
-can use a serialization mechanism such as JSON:
+Redis "string" types can be used to store serialized Ruby objects, for
+example with JSON:
 
 ```ruby
 require "json"
@@ -251,6 +265,7 @@ All timeout values are specified in seconds.
 When using pub/sub, you can subscribe to a channel using a timeout as well:
 
 ```ruby
+redis = Redis.new(reconnect_attempts: 0)
 redis.subscribe_with_timeout(5, "news") do |on|
   on.message do |channel, message|
     # ...
@@ -312,7 +327,7 @@ This library supports natively terminating client side SSL/TLS connections
 when talking to Redis via a server-side proxy such as [stunnel], [hitch],
 or [ghostunnel].
 
-To enable SSL support, pass the `:ssl => :true` option when configuring the
+To enable SSL support, pass the `:ssl => true` option when configuring the
 Redis client, or pass in `:url => "rediss://..."` (like HTTPS for Redis).
 You will also need to pass in an `:ssl_params => { ... }` hash used to
 configure the `OpenSSL::SSL::SSLContext` object used for the connection:
@@ -427,6 +442,10 @@ redis = Redis.new(:driver => :synchrony)
 This library is tested against recent Ruby and Redis versions.
 Check [Travis][travis-link] for the exact versions supported.
 
+## See Also
+
+- [async-redis](https://github.com/socketry/async-redis) — An [async](https://github.com/socketry/async) compatible Redis client.
+
 ## Contributors
 
 Several people contributed to redis-rb, but we would like to especially
@@ -437,7 +456,7 @@ client and evangelized Redis in Rubyland. Thank you, Ezra.
 ## Contributing
 
 [Fork the project](https://github.com/redis/redis-rb) and send pull
-requests. You can also ask for help at `#redis-rb` on Freenode.
+requests.
 
 
 [inchpages-image]: https://inch-ci.org/github/redis/redis-rb.svg

data/lib/redis/client.rb

@@ -6,24 +6,30 @@ require "cgi"
 
 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,
-      :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,
+      read_timeout: nil,
+      write_timeout: nil,
+      connect_timeout: 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,
+      logger: nil,
+      sentinels: nil,
+      role: nil
+    }.freeze
 
     attr_reader :options
 
@@ -89,7 +95,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 +172,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,12 +251,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
@@ -300,30 +308,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 }
@@ -357,9 +362,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
@@ -373,9 +378,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
@@ -386,7 +391,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)
@@ -408,16 +413,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
@@ -426,7 +429,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
@@ -457,7 +460,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]
@@ -476,7 +479,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
@@ -484,13 +487,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
 
@@ -502,14 +505,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
 
@@ -528,8 +531,7 @@ class Redis
         @options
       end
 
-      def check(client)
-      end
+      def check(client); end
 
       class Sentinel < Connector
         def initialize(options)
@@ -538,7 +540,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
 
@@ -561,13 +563,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
@@ -575,10 +577,11 @@ 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"],
+                                                 password: sentinel[:password] || sentinel["password"],
+                                                 reconnect_attempts: 0
+                                               }))
 
             begin
               if result = yield(client)
@@ -595,17 +598,12 @@ class Redis
           end
 
           raise CannotConnectError, "No sentinels available."
-        rescue Redis::CommandError => err
-          # this feature is only available starting with Redis 5.0.1
-          raise unless err.message.start_with?('ERR unknown command `auth`')
-          @options[:password] = DEFAULTS.fetch(:password)
-          retry
         end
 
         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
@@ -623,7 +621,7 @@ class Redis
                 slave = slaves.sample
                 {
                   host: slave.fetch('ip'),
-                  port: slave.fetch('port'),
+                  port: slave.fetch('port')
                 }
               end
             end

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/node_key.rb

@@ -6,17 +6,13 @@ class Redis
     # It is different from node id.
     # Node id is internal identifying code in Redis Cluster.
     module NodeKey
-      DEFAULT_SCHEME = 'redis'
-      SECURE_SCHEME = 'rediss'
       DELIMITER = ':'
 
       module_function
 
-      def to_node_urls(node_keys, secure:)
-        scheme = secure ? SECURE_SCHEME : DEFAULT_SCHEME
-        node_keys
-          .map { |k| k.split(DELIMITER) }
-          .map { |k| URI::Generic.build(scheme: scheme, host: k[0], port: k[1].to_i).to_s }
+      def optionize(node_key)
+        host, port = split(node_key)
+        { host: host, port: port }
       end
 
       def split(node_key)

data/lib/redis/cluster/option.rb

@@ -15,36 +15,35 @@ class Redis
       def initialize(options)
         options = options.dup
         node_addrs = options.delete(:cluster)
-        @node_uris = build_node_uris(node_addrs)
+        @node_opts = build_node_options(node_addrs)
         @replica = options.delete(:replica) == true
+        add_common_node_option_if_needed(options, @node_opts, :scheme)
+        add_common_node_option_if_needed(options, @node_opts, :password)
         @options = options
       end
 
       def per_node_key
-        @node_uris.map { |uri| [NodeKey.build_from_uri(uri), @options.merge(url: uri.to_s)] }
+        @node_opts.map { |opt| [NodeKey.build_from_host_port(opt[:host], opt[:port]), @options.merge(opt)] }
                   .to_h
       end
 
-      def secure?
-        @node_uris.any? { |uri| uri.scheme == SECURE_SCHEME } || @options[:ssl_params] || false
-      end
-
       def use_replica?
         @replica
       end
 
       def update_node(addrs)
-        @node_uris = build_node_uris(addrs)
+        @node_opts = build_node_options(addrs)
       end
 
       def add_node(host, port)
-        @node_uris << parse_node_hash(host: host, port: port)
+        @node_opts << { host: host, port: port }
       end
 
       private
 
-      def build_node_uris(addrs)
+      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
 
@@ -53,7 +52,7 @@ class Redis
         when String
           parse_node_url(addr)
         when Hash
-          parse_node_hash(addr)
+          parse_node_option(addr)
         else
           raise InvalidClientOptionError, 'Redis option of `cluster` must includes String or Hash'
         end
@@ -62,15 +61,29 @@ class Redis
       def parse_node_url(addr)
         uri = URI(addr)
         raise InvalidClientOptionError, "Invalid uri scheme #{addr}" unless VALID_SCHEMES.include?(uri.scheme)
-        uri
+
+        db = uri.path.split('/')[1]&.to_i
+        { scheme: uri.scheme, password: uri.password, host: uri.host, port: uri.port, db: db }.reject { |_, v| v.nil? }
       rescue URI::InvalidURIError => err
         raise InvalidClientOptionError, err.message
       end
 
-      def parse_node_hash(addr)
+      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?)
-        URI::Generic.build(scheme: DEFAULT_SCHEME, host: addr[:host], port: addr[:port].to_i)
+        if addr.values_at(:host, :port).any?(&:nil?)
+          raise InvalidClientOptionError, 'Redis option of `cluster` must includes `:host` and `:port` keys'
+        end
+
+        addr
+      end
+
+      # Redis cluster node returns only host and port information.
+      # So we should complement additional information such as:
+      #   scheme, password and so on.
+      def add_common_node_option_if_needed(options, node_opts, key)
+        return options if options[key].nil? && node_opts.first[key].nil?
+
+        options[key] ||= node_opts.first[key]
       end
     end
   end