redis 4.5.1 → 4.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a7232fef186e6d6a11a90d8dd9aa7c71114f017e0afe9378999a96c9e6b4e05
-  data.tar.gz: 689f176b87909bf61eb60e57d1eb795198162a7e039104c80facf36880964bda
+  metadata.gz: 185ccbe36adc1e1561474af65d0e0b8d246e9c161757c9218f5ac7b6c1d24bb9
+  data.tar.gz: 03a4203747503b971551500ea40f996cb9620e5d9a693231d7a63944a9f73bf8
 SHA512:
-  metadata.gz: 22b11dee92e298b46bb94a707156d3dbf9afb83c8e9e8cbf82cf366d582a7c1b7295d7f09a0fec01965245f4800c2482c0559d646f46ff1c6bba6423ab398ba9
-  data.tar.gz: 9a74ba29c8cb3d7634a44c78e30018a048e19cca66c7fad6a226722183f66546bebb370c92ecdf20522bb35ee72a09b2fda64891ff6d94db1702375bd1ba6b46
+  metadata.gz: 3354c910dcf3feb76b7f4ed7adb5bcce4f1cfc3ef7c58347897ba4705337a89052d2db67a8a71765f34e16f01a7ab2c8894bba60a3a89e1f36b6487f3fe0089b
+  data.tar.gz: 0b23396f9ecf62dd952536b94107a7748bb5ee225e7c7ac1da36e813e7fffc588c5939abe1800fc440e173acc54a9ac3649037b62b3ff59aa946ffc9a3e11180

data/CHANGELOG.md

@@ -1,5 +1,69 @@
 # Unreleased
 
+# 4.7.1
+
+* Gracefully handle OpenSSL 3.0 EOF Errors (`OpenSSL::SSL::SSLError: SSL_read: unexpected eof while reading`). See #1106
+  This happens frequently on heroku-22.
+
+# 4.7.0
+
+* Support single endpoint architecture with SSL/TLS in cluster mode. See #1086.
+* `zrem` and `zadd` act as noop when provided an empty list of keys. See #1097.
+* Support IPv6 URLs.
+* Add `Redis#with` for better compatibility with `connection_pool` usage.
+* Fix the block form of `multi` called inside `pipelined`. Previously the `MUTLI/EXEC` wouldn't be sent. See #1073.
+
+# 4.6.0
+
+* Deprecate `Redis.current`.
+* Deprecate calling commands on `Redis` inside `Redis#pipelined`. See #1059.
+  ```ruby
+  redis.pipelined do
+    redis.get("key")
+  end
+  ```
+
+  should be replaced by:
+
+  ```ruby
+  redis.pipelined do |pipeline|
+    pipeline.get("key")
+  end
+  ```
+* Deprecate calling commands on `Redis` inside `Redis#multi`. See #1059.
+  ```ruby
+  redis.multi do
+    redis.get("key")
+  end
+  ```
+
+  should be replaced by:
+
+  ```ruby
+  redis.multi do |transaction|
+    transaction.get("key")
+  end
+  ```
+* Deprecate `Redis#queue` and `Redis#commit`. See #1059.
+
+* Fix `zpopmax` and `zpopmin` when called inside a pipeline. See #1055.
+* `Redis#synchronize` is now private like it should always have been.
+
+* Add `Redis.silence_deprecations=` to turn off deprecation warnings.
+  If you don't wish to see warnings yet, you can set `Redis.silence_deprecations = true`.
+  It is however heavily recommended to fix them instead when possible.
+* Add `Redis.raise_deprecations=` to turn deprecation warnings into errors.
+  This makes it easier to identitify the source of deprecated APIs usage.
+  It is recommended to set `Redis.raise_deprecations = true` in development and test environments.
+* Add new options to ZRANGE. See #1053.
+* Add ZRANGESTORE command. See #1053.
+* Add SCAN support for `Redis::Cluster`. See #1049.
+* Add COPY command. See #1053. See #1048.
+* Add ZDIFFSTORE command. See #1046.
+* Add ZDIFF command. See #1044.
+* Add ZUNION command. See #1042.
+* Add HRANDFIELD command. See #1040.
+
 # 4.5.1
 
 * Restore the accidential auth behavior of redis-rb 4.3.0 with a warning. If provided with the `default` user's password, but a wrong username,

data/README.md

@@ -155,6 +155,21 @@ redis.mget('{key}1', '{key}2')
 * The client support permanent node failures, and will reroute requests to promoted slaves.
 * The client supports `MOVED` and `ASK` redirections transparently.
 
+## Cluster mode with SSL/TLS
+Since Redis can return FQDN of nodes in reply to client since `7.*` with CLUSTER commands, we can use cluster feature with SSL/TLS connection like this:
+
+```ruby
+Redis.new(cluster: %w[rediss://foo.example.com:6379])
+```
+
+On the other hand, in Redis versions prior to `6.*`, you can specify options like the following if cluster mode is enabled and client has to connect to nodes via single endpoint with SSL/TLS.
+
+```ruby
+Redis.new(cluster: %w[rediss://foo-endpoint.example.com:6379], fixed_hostname: 'foo-endpoint.example.com')
+```
+
+In case of the above architecture, if you don't pass the `fixed_hostname` option to the client and servers return IP addresses of nodes, the client may fail to verify certificates.
+
 ## Storing objects
 
 Redis "string" types can be used to store serialized Ruby objects, for
@@ -184,9 +199,9 @@ commands to Redis and gathers their replies. These replies are returned
 by the `#pipelined` method.
 
 ```ruby
-redis.pipelined do
-  redis.set "foo", "bar"
-  redis.incr "baz"
+redis.pipelined do |pipeline|
+  pipeline.set "foo", "bar"
+  pipeline.incr "baz"
 end
 # => ["OK", 1]
 ```
@@ -200,9 +215,9 @@ the regular pipeline, the replies to the commands are returned by the
 `#multi` method.
 
 ```ruby
-redis.multi do
-  redis.set "foo", "bar"
-  redis.incr "baz"
+redis.multi do |transaction|
+  transaction.set "foo", "bar"
+  transaction.incr "baz"
 end
 # => ["OK", 1]
 ```
@@ -210,15 +225,15 @@ end
 ### Futures
 
 Replies to commands in a pipeline can be accessed via the *futures* they
-emit (since redis-rb 3.0). All calls inside a pipeline block return a
+emit (since redis-rb 3.0). All calls on the pipeline object return a
 `Future` object, which responds to the `#value` method. When the
 pipeline has successfully executed, all futures are assigned their
 respective replies and can be used.
 
 ```ruby
-redis.pipelined do
-  @set = redis.set "foo", "bar"
-  @incr = redis.incr "baz"
+redis.pipelined do |pipeline|
+  @set = pipeline.set "foo", "bar"
+  @incr = pipeline.incr "baz"
 end
 
 @set.value

data/lib/redis/client.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "errors"
 require "socket"
 require "cgi"
+require "redis/errors"
 
 class Redis
   class Client
@@ -32,7 +32,7 @@ class Redis
       role: nil
     }.freeze
 
-    attr_reader :options
+    attr_reader :options, :connection, :command_map
 
     def scheme
       @options[:scheme]
@@ -87,8 +87,6 @@ class Redis
     end
 
     attr_accessor :logger
-    attr_reader :connection
-    attr_reader :command_map
 
     def initialize(options = {})
       @options = _parse_options(options)
@@ -120,17 +118,18 @@ class Redis
             begin
               call [:auth, username, password]
             rescue CommandError => err # Likely on Redis < 6
-              if err.message.match?(/ERR wrong number of arguments for \'auth\' command/)
+              case err.message
+              when /ERR wrong number of arguments for 'auth' command/
                 call [:auth, password]
-              elsif err.message.match?(/WRONGPASS invalid username-password pair/)
+              when /WRONGPASS invalid username-password pair/
                 begin
                   call [:auth, password]
                 rescue CommandError
                   raise err
                 end
-                ::Kernel.warn(
+                ::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 4.6."
+                  " the provided password was for the default user. This will start failing in redis-rb 5.0.0."
                 )
               else
                 raise
@@ -151,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
@@ -252,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
@@ -302,7 +302,7 @@ class Redis
       e2 = TimeoutError.new("Connection timed out")
       e2.set_backtrace(e1.backtrace)
       raise e2
-    rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF, Errno::EINVAL => e
+    rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF, Errno::EINVAL, EOFError => e
       raise ConnectionError, "Connection lost (%s)" % [e.class.name.split("::").last]
     end
 
@@ -442,7 +442,7 @@ class Redis
       defaults = DEFAULTS.dup
       options = options.dup
 
-      defaults.keys.each do |key|
+      defaults.each_key do |key|
         # Fill in defaults if needed
         defaults[key] = defaults[key].call if defaults[key].respond_to?(:call)
 
@@ -459,11 +459,12 @@ class Redis
 
         uri = URI(url)
 
-        if uri.scheme == "unix"
+        case uri.scheme
+        when "unix"
           defaults[:path] = uri.path
-        elsif uri.scheme == "redis" || uri.scheme == "rediss"
+        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[:username] = CGI.unescape(uri.user) if uri.user && !uri.user.empty?
           defaults[:password] = CGI.unescape(uri.password) if uri.password && !uri.password.empty?
@@ -477,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
 

data/lib/redis/cluster/command.rb

@@ -31,13 +31,13 @@ class Redis
       private
 
       def pick_details(details)
-        details.map do |command, detail|
-          [command, {
+        details.transform_values do |detail|
+          {
             first_key_position: detail[:first],
             write: detail[:flags].include?('write'),
             readonly: detail[:flags].include?('readonly')
-          }]
-        end.to_h
+          }
+        end
       end
 
       def dig_details(command, key)
@@ -53,8 +53,6 @@ class Redis
         when 'object' then 2
         when 'memory'
           command[1].to_s.casecmp('usage').zero? ? 2 : 0
-        when 'scan', 'sscan', 'hscan', 'zscan'
-          determine_optional_key_position(command, 'match')
         when 'xread', 'xreadgroup'
           determine_optional_key_position(command, 'streams')
         else

data/lib/redis/cluster/command_loader.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../errors'
+require 'redis/errors'
 
 class Redis
   class Cluster
@@ -10,15 +10,15 @@ class Redis
       module_function
 
       def load(nodes)
-        nodes.each do |node|
+        errors = nodes.map do |node|
           begin
             return fetch_command_details(node)
-          rescue CannotConnectError, ConnectionError, CommandError
-            next # can retry on another node
+          rescue CannotConnectError, ConnectionError, CommandError => error
+            error
           end
         end
 
-        raise CannotConnectError, 'Redis client could not connect to any cluster nodes'
+        raise InitialSetupError, errors
       end
 
       def fetch_command_details(node)

data/lib/redis/cluster/node.rb

@@ -58,6 +58,18 @@ class Redis
         try_map { |_, client| client.process(commands, &block) }.values
       end
 
+      def scale_reading_clients
+        reading_clients = []
+
+        @clients.each do |node_key, client|
+          next unless replica_disabled? ? master?(node_key) : slave?(node_key)
+
+          reading_clients << client
+        end
+
+        reading_clients
+      end
+
       private
 
       def replica_disabled?

data/lib/redis/cluster/node_loader.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../errors'
+require 'redis/errors'
 
 class Redis
   class Cluster
@@ -9,16 +9,15 @@ class Redis
       module_function
 
       def load_flags(nodes)
-        info = {}
-
-        nodes.each do |node|
-          info = fetch_node_info(node)
-          info.empty? ? next : break
+        errors = nodes.map do |node|
+          begin
+            return fetch_node_info(node)
+          rescue CannotConnectError, ConnectionError, CommandError => error
+            error
+          end
         end
 
-        return info unless info.empty?
-
-        raise CannotConnectError, 'Redis client could not connect to any cluster nodes'
+        raise InitialSetupError, errors
       end
 
       def fetch_node_info(node)
@@ -27,8 +26,6 @@ class Redis
             .map { |str| str.split(' ') }
             .map { |arr| [arr[1].split('@').first, (arr[2].split(',') & %w[master slave]).first] }
             .to_h
-      rescue CannotConnectError, ConnectionError, CommandError
-        {} # can retry on another node
       end
 
       private_class_method :fetch_node_info

data/lib/redis/cluster/option.rb

@@ -17,6 +17,7 @@ class Redis
         node_addrs = options.delete(:cluster)
         @node_opts = build_node_options(node_addrs)
         @replica = options.delete(:replica) == true
+        @fixed_hostname = options.delete(:fixed_hostname)
         add_common_node_option_if_needed(options, @node_opts, :scheme)
         add_common_node_option_if_needed(options, @node_opts, :username)
         add_common_node_option_if_needed(options, @node_opts, :password)
@@ -24,8 +25,12 @@ class Redis
       end
 
       def per_node_key
-        @node_opts.map { |opt| [NodeKey.build_from_host_port(opt[:host], opt[:port]), @options.merge(opt)] }
-                  .to_h
+        @node_opts.map do |opt|
+          node_key = NodeKey.build_from_host_port(opt[:host], opt[:port])
+          options = @options.merge(opt)
+          options = options.merge(host: @fixed_hostname) if @fixed_hostname && !@fixed_hostname.empty?
+          [node_key, options]
+        end.to_h
       end
 
       def use_replica?
@@ -64,8 +69,10 @@ class Redis
         raise InvalidClientOptionError, "Invalid uri scheme #{addr}" unless VALID_SCHEMES.include?(uri.scheme)
 
         db = uri.path.split('/')[1]&.to_i
+        username = uri.user ? URI.decode_www_form_component(uri.user) : nil
+        password = uri.password ? URI.decode_www_form_component(uri.password) : nil
 
-        { scheme: uri.scheme, username: uri.user, password: uri.password, host: uri.host, port: uri.port, db: db }
+        { scheme: uri.scheme, username: username, password: password, host: uri.host, port: uri.port, db: db }
           .reject { |_, v| v.nil? || v == '' }
       rescue URI::InvalidURIError => err
         raise InvalidClientOptionError, err.message

data/lib/redis/cluster/slot_loader.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../errors'
-require_relative 'node_key'
+require 'redis/errors'
+require 'redis/cluster/node_key'
 
 class Redis
   class Cluster
@@ -10,16 +10,15 @@ class Redis
       module_function
 
       def load(nodes)
-        info = {}
-
-        nodes.each do |node|
-          info = fetch_slot_info(node)
-          info.empty? ? next : break
+        errors = nodes.map do |node|
+          begin
+            return fetch_slot_info(node)
+          rescue CannotConnectError, ConnectionError, CommandError => error
+            error
+          end
         end
 
-        return info unless info.empty?
-
-        raise CannotConnectError, 'Redis client could not connect to any cluster nodes'
+        raise InitialSetupError, errors
       end
 
       def fetch_slot_info(node)
@@ -27,8 +26,6 @@ class Redis
         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] }
-      rescue CannotConnectError, ConnectionError, CommandError
-        {} # can retry on another node
       end
 
       def parse_slot_info(arr, default_ip:)

data/lib/redis/cluster.rb

@@ -137,6 +137,7 @@ class Redis
       when 'wait'     then @node.call_master(command, &block).reduce(:+)
       when 'keys'     then @node.call_slave(command, &block).flatten.sort
       when 'dbsize'   then @node.call_slave(command, &block).reduce(:+)
+      when 'scan'     then _scan(command, &block)
       when 'lastsave' then @node.call_all(command, &block).sort
       when 'role'     then @node.call_all(command, &block)
       when 'config'   then send_config_command(command, &block)
@@ -238,6 +239,29 @@ class Redis
       raise
     end
 
+    def _scan(command, &block)
+      input_cursor = Integer(command[1])
+
+      client_index = input_cursor % 256
+      raw_cursor = input_cursor >> 8
+
+      clients = @node.scale_reading_clients
+
+      client = clients[client_index]
+      return ['0', []] unless client
+
+      command[1] = raw_cursor.to_s
+
+      result_cursor, result_keys = client.call(command, &block)
+      result_cursor = Integer(result_cursor)
+
+      if result_cursor == 0
+        client_index += 1
+      end
+
+      [((result_cursor << 8) + client_index).to_s, result_keys]
+    end
+
     def assign_redirection_node(err_msg)
       _, slot, node_key = err_msg.split(' ')
       slot = slot.to_i

data/lib/redis/commands/bitmaps.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class Redis
+  module Commands
+    module Bitmaps
+      # Sets or clears the bit at offset in the string value stored at key.
+      #
+      # @param [String] key
+      # @param [Integer] offset bit offset
+      # @param [Integer] value bit value `0` or `1`
+      # @return [Integer] the original bit value stored at `offset`
+      def setbit(key, offset, value)
+        send_command([:setbit, key, offset, value])
+      end
+
+      # Returns the bit value at offset in the string value stored at key.
+      #
+      # @param [String] key
+      # @param [Integer] offset bit offset
+      # @return [Integer] `0` or `1`
+      def getbit(key, offset)
+        send_command([:getbit, key, offset])
+      end
+
+      # Count the number of set bits in a range of the string value stored at key.
+      #
+      # @param [String] key
+      # @param [Integer] start start index
+      # @param [Integer] stop stop index
+      # @return [Integer] the number of bits set to 1
+      def bitcount(key, start = 0, stop = -1)
+        send_command([:bitcount, key, start, stop])
+      end
+
+      # Perform a bitwise operation between strings and store the resulting string in a key.
+      #
+      # @param [String] operation e.g. `and`, `or`, `xor`, `not`
+      # @param [String] destkey destination key
+      # @param [String, Array<String>] keys one or more source keys to perform `operation`
+      # @return [Integer] the length of the string stored in `destkey`
+      def bitop(operation, destkey, *keys)
+        send_command([:bitop, operation, destkey, *keys])
+      end
+
+      # Return the position of the first bit set to 1 or 0 in a string.
+      #
+      # @param [String] key
+      # @param [Integer] bit whether to look for the first 1 or 0 bit
+      # @param [Integer] start start index
+      # @param [Integer] stop stop index
+      # @return [Integer] the position of the first 1/0 bit.
+      #                  -1 if looking for 1 and it is not found or start and stop are given.
+      def bitpos(key, bit, start = nil, stop = nil)
+        raise(ArgumentError, 'stop parameter specified without start parameter') if stop && !start
+
+        command = [:bitpos, key, bit]
+        command << start if start
+        command << stop if stop
+        send_command(command)
+      end
+    end
+  end
+end

data/lib/redis/commands/cluster.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Redis
+  module Commands
+    module Cluster
+      # Sends `CLUSTER *` command to random node and returns its reply.
+      #
+      # @see https://redis.io/commands#cluster Reference of cluster command
+      #
+      # @param subcommand [String, Symbol] the subcommand of cluster command
+      #   e.g. `:slots`, `:nodes`, `:slaves`, `:info`
+      #
+      # @return [Object] depends on the subcommand
+      def cluster(subcommand, *args)
+        subcommand = subcommand.to_s.downcase
+        block = case subcommand
+        when 'slots'
+          HashifyClusterSlots
+        when 'nodes'
+          HashifyClusterNodes
+        when 'slaves'
+          HashifyClusterSlaves
+        when 'info'
+          HashifyInfo
+        else
+          Noop
+        end
+
+        # @see https://github.com/antirez/redis/blob/unstable/src/redis-trib.rb#L127 raw reply expected
+        block = Noop unless @cluster_mode
+
+        send_command([:cluster, subcommand] + args, &block)
+      end
+
+      # Sends `ASKING` command to random node and returns its reply.
+      #
+      # @see https://redis.io/topics/cluster-spec#ask-redirection ASK redirection
+      #
+      # @return [String] `'OK'`
+      def asking
+        send_command(%i[asking])
+      end
+    end
+  end
+end

data/lib/redis/commands/connection.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class Redis
+  module Commands
+    module Connection
+      # Authenticate to the server.
+      #
+      # @param [Array<String>] args includes both username and password
+      #   or only password
+      # @return [String] `OK`
+      # @see https://redis.io/commands/auth AUTH command
+      def auth(*args)
+        send_command([:auth, *args])
+      end
+
+      # Ping the server.
+      #
+      # @param [optional, String] message
+      # @return [String] `PONG`
+      def ping(message = nil)
+        send_command([:ping, message].compact)
+      end
+
+      # Echo the given string.
+      #
+      # @param [String] value
+      # @return [String]
+      def echo(value)
+        send_command([:echo, value])
+      end
+
+      # Change the selected database for the current connection.
+      #
+      # @param [Integer] db zero-based index of the DB to use (0 to 15)
+      # @return [String] `OK`
+      def select(db)
+        synchronize do |client|
+          client.db = db
+          client.call([:select, db])
+        end
+      end
+
+      # Close the connection.
+      #
+      # @return [String] `OK`
+      def quit
+        synchronize do |client|
+          begin
+            client.call([:quit])
+          rescue ConnectionError
+          ensure
+            client.disconnect
+          end
+        end
+      end
+    end
+  end
+end