redis 4.6.0 → 4.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e99f4e628112a227719d2000dc5b081893273cfbd51ae25bf00a8f6b6594061
-  data.tar.gz: 42a8e0cf75aebbc14cdf680b4bc1f7bbdec9e20b53f150c6443c01126960a959
+  metadata.gz: c93b88c9766f0ba965110f61ff1e5cb3adcf378a515a9cdb7c345ef56159f98a
+  data.tar.gz: 6fa82d53bef3b0be6a5d192a925dfbd1e7585e66a5313605e631a1cf8585bf95
 SHA512:
-  metadata.gz: 8bc57fe306c601f27d32df4940d5632e9e7d75529f6ac5d42732b21fe04452a4a1ab89567492c6fb7249ef4d69ebb2c0b7c985e18b0ef4f9ee6fb816c31bcbda
-  data.tar.gz: 42b2f8c584d6f96d0fc783d0b36af0fd9415d1dbd43ad8fe7a980688e52fbdb51645a07960d9cb3faacf6696c460cf38a013e290d0b58d4bbbb07626f18f15c7
+  metadata.gz: 1d2b5d59615cfdc2ec756c16560b88d3f968193d7ac1c827574b775b202f3f63b9d3ab9748c89cae5d82471063a1aded9f82557b86f850b0a58a180d404ee15c
+  data.tar.gz: 866c1968b84397450ca8882175240c345bf2dfb3a88fa4579d78c7ce8ee581226a0eb6007ac6de638dfc654eca15bf045e6f1860c187e5d736b196cac8b721c9

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Unreleased
 
+# 4.8.0
+
+* Introduce `sadd?` and `srem?` as boolean returning versions of `sadd` and `srem`.
+* Deprecate `sadd` and `srem` returning a boolean when called with a single argument.
+  To enable the redis 5.0 behavior you can set `Redis.sadd_returns_boolean = true`.
+* Deprecate passing `timeout` as a positional argument in blocking commands (`brpop`, `blop`, etc).
+
+# 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`.
@@ -37,7 +57,7 @@
 * `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 = false`.
+  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.

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

data/lib/redis/client.rb

@@ -150,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
@@ -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
 
@@ -464,7 +464,7 @@ class Redis
           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[:username] = CGI.unescape(uri.user) if uri.user && !uri.user.empty?
           defaults[:password] = CGI.unescape(uri.password) if uri.password && !uri.password.empty?

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_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/commands/keys.rb

@@ -69,18 +69,40 @@ class Redis
       #
       # @param [String] key
       # @param [Integer] seconds time to live
+      # @param [Hash] options
+      #   - `:nx => true`: Set expiry only when the key has no expiry.
+      #   - `:xx => true`: Set expiry only when the key has an existing expiry.
+      #   - `:gt => true`: Set expiry only when the new expiry is greater than current one.
+      #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
-      def expire(key, seconds)
-        send_command([:expire, key, seconds], &Boolify)
+      def expire(key, seconds, nx: nil, xx: nil, gt: nil, lt: nil)
+        args = [:expire, key, seconds]
+        args << "NX" if nx
+        args << "XX" if xx
+        args << "GT" if gt
+        args << "LT" if lt
+
+        send_command(args, &Boolify)
       end
 
       # Set the expiration for a key as a UNIX timestamp.
       #
       # @param [String] key
       # @param [Integer] unix_time expiry time specified as a UNIX timestamp
+      # @param [Hash] options
+      #   - `:nx => true`: Set expiry only when the key has no expiry.
+      #   - `:xx => true`: Set expiry only when the key has an existing expiry.
+      #   - `:gt => true`: Set expiry only when the new expiry is greater than current one.
+      #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
-      def expireat(key, unix_time)
-        send_command([:expireat, key, unix_time], &Boolify)
+      def expireat(key, unix_time, nx: nil, xx: nil, gt: nil, lt: nil)
+        args = [:expireat, key, unix_time]
+        args << "NX" if nx
+        args << "XX" if xx
+        args << "GT" if gt
+        args << "LT" if lt
+
+        send_command(args, &Boolify)
       end
 
       # Get the time to live (in seconds) for a key.
@@ -103,18 +125,40 @@ class Redis
       #
       # @param [String] key
       # @param [Integer] milliseconds time to live
+      # @param [Hash] options
+      #   - `:nx => true`: Set expiry only when the key has no expiry.
+      #   - `:xx => true`: Set expiry only when the key has an existing expiry.
+      #   - `:gt => true`: Set expiry only when the new expiry is greater than current one.
+      #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
-      def pexpire(key, milliseconds)
-        send_command([:pexpire, key, milliseconds], &Boolify)
+      def pexpire(key, milliseconds, nx: nil, xx: nil, gt: nil, lt: nil)
+        args = [:pexpire, key, milliseconds]
+        args << "NX" if nx
+        args << "XX" if xx
+        args << "GT" if gt
+        args << "LT" if lt
+
+        send_command(args, &Boolify)
       end
 
       # Set the expiration for a key as number of milliseconds from UNIX Epoch.
       #
       # @param [String] key
       # @param [Integer] ms_unix_time expiry time specified as number of milliseconds from UNIX Epoch.
+      # @param [Hash] options
+      #   - `:nx => true`: Set expiry only when the key has no expiry.
+      #   - `:xx => true`: Set expiry only when the key has an existing expiry.
+      #   - `:gt => true`: Set expiry only when the new expiry is greater than current one.
+      #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
-      def pexpireat(key, ms_unix_time)
-        send_command([:pexpireat, key, ms_unix_time], &Boolify)
+      def pexpireat(key, ms_unix_time, nx: nil, xx: nil, gt: nil, lt: nil)
+        args = [:pexpireat, key, ms_unix_time]
+        args << "NX" if nx
+        args << "XX" if xx
+        args << "GT" if gt
+        args << "LT" if lt
+
+        send_command(args, &Boolify)
       end
 
       # Get the time to live (in milliseconds) for a key.

data/lib/redis/commands/lists.rb

@@ -254,16 +254,17 @@ class Redis
           options = args.pop
           options[:timeout]
         elsif args.last.respond_to?(:to_int)
-          # Issue deprecation notice in obnoxious mode...
-          args.pop.to_int
+          last_arg = args.pop
+          ::Redis.deprecate!(
+            "Passing the timeout as a positional argument is deprecated, it should be passed as a keyword argument:\n" \
+            "  redis.#{cmd}(#{args.map(&:inspect).join(', ')}, timeout: #{last_arg.to_int})" \
+            "(called from: #{caller(2, 1).first})"
+          )
+          last_arg.to_int
         end
 
         timeout ||= 0
 
-        if args.size > 1
-          # Issue deprecation notice in obnoxious mode...
-        end
-
         keys = args.flatten
 
         command = [cmd, keys, timeout]

data/lib/redis/commands/sets.rb

@@ -20,15 +20,23 @@ class Redis
       #   array of members is specified, holding the number of members that were
       #   successfully added
       def sadd(key, member)
-        send_command([:sadd, key, member]) do |reply|
-          if member.is_a? Array
-            # Variadic: return integer
-            reply
-          else
-            # Single argument: return boolean
-            Boolify.call(reply)
-          end
+        block = if Redis.sadd_returns_boolean && !member.is_a?(Array)
+          ::Redis.deprecate!(
+            "Redis#sadd will always return an Integer in Redis 5.0.0. Use Redis#sadd? instead." \
+            "(called from: #{caller(1, 1).first})"
+          )
+          Boolify
         end
+        send_command([:sadd, key, member], &block)
+      end
+
+      # Add one or more members to a set.
+      #
+      # @param [String] key
+      # @param [String, Array<String>] member one member, or array of members
+      # @return [Boolean] Whether or not at least one member was added.
+      def sadd?(key, member)
+        send_command([:sadd, key, member], &Boolify)
       end
 
       # Remove one or more members from a set.
@@ -40,15 +48,23 @@ class Redis
       #   array of members is specified, holding the number of members that were
       #   successfully removed
       def srem(key, member)
-        send_command([:srem, key, member]) do |reply|
-          if member.is_a? Array
-            # Variadic: return integer
-            reply
-          else
-            # Single argument: return boolean
-            Boolify.call(reply)
-          end
+        block = if Redis.sadd_returns_boolean && !member.is_a?(Array)
+          ::Redis.deprecate!(
+            "Redis#sadd will always return an Integer in Redis 5.0.0. Use Redis#sadd? instead." \
+            "(called from: #{caller(1, 1).first})"
+          )
+          Boolify
         end
+        send_command([:srem, key, member], &block)
+      end
+
+      # Remove one or more members from a set.
+      #
+      # @param [String] key
+      # @param [String, Array<String>] member one member, or array of members
+      # @return [Boolean] `Boolean` Whether or not a member was removed.
+      def srem?(key, member)
+        send_command([:srem, key, member], &Boolify)
       end
 
       # Remove and return one or more random member from a set.

data/lib/redis/commands/sorted_sets.rb

@@ -60,8 +60,11 @@ class Redis
         command << "INCR" if incr
 
         if args.size == 1 && args[0].is_a?(Array)
+          members_to_add = args[0]
+          return 0 if members_to_add.empty?
+
           # Variadic: return float if INCR, integer if !INCR
-          send_command(command + args[0], &(incr ? Floatify : nil))
+          send_command(command + members_to_add, &(incr ? Floatify : nil))
         elsif args.size == 2
           # Single pair: return float if INCR, boolean if !INCR
           send_command(command + args, &(incr ? Floatify : Boolify))
@@ -102,6 +105,11 @@ class Redis
       #   - `Integer` when an array of pairs is specified, holding the number of
       #   members that were removed to the sorted set
       def zrem(key, member)
+        if member.is_a?(Array)
+          members_to_remove = member
+          return 0 if members_to_remove.empty?
+        end
+
         send_command([:zrem, key, member]) do |reply|
           if member.is_a? Array
             # Variadic: return integer

data/lib/redis/commands/transactions.rb

@@ -3,6 +3,53 @@
 class Redis
   module Commands
     module Transactions
+      # Mark the start of a transaction block.
+      #
+      # Passing a block is optional.
+      #
+      # @example With a block
+      #   redis.multi do |multi|
+      #     multi.set("key", "value")
+      #     multi.incr("counter")
+      #   end # => ["OK", 6]
+      #
+      # @example Without a block
+      #   redis.multi
+      #     # => "OK"
+      #   redis.set("key", "value")
+      #     # => "QUEUED"
+      #   redis.incr("counter")
+      #     # => "QUEUED"
+      #   redis.exec
+      #     # => ["OK", 6]
+      #
+      # @yield [multi] the commands that are called inside this block are cached
+      #   and written to the server upon returning from it
+      # @yieldparam [Redis] multi `self`
+      #
+      # @return [String, Array<...>]
+      #   - when a block is not given, `OK`
+      #   - when a block is given, an array with replies
+      #
+      # @see #watch
+      # @see #unwatch
+      def multi(&block) # :nodoc:
+        if block_given?
+          if block&.arity == 0
+            Pipeline.deprecation_warning("multi", Kernel.caller_locations(1, 5))
+          end
+
+          synchronize do |prior_client|
+            pipeline = Pipeline::Multi.new(prior_client)
+            pipelined_connection = PipelinedConnection.new(pipeline)
+            yield pipelined_connection
+            prior_client.call_pipeline(pipeline)
+          end
+        else
+          send_command([:multi])
+        end
+      end
+
       # Watch the given keys to determine execution of the MULTI/EXEC block.
       #
       # Using a block is optional, but is necessary for thread-safety.

data/lib/redis/commands.rb

@@ -41,10 +41,8 @@ class Redis
     # returning false.
     Boolify = lambda { |value|
       case value
-      when 1
-        true
-      when 0
-        false
+      when Integer
+        value > 0
       else
         value
       end

data/lib/redis/connection/ruby.rb

@@ -384,6 +384,12 @@ class Redis
         format_reply(reply_type, line)
       rescue Errno::EAGAIN
         raise TimeoutError
+      rescue OpenSSL::SSL::SSLError => ssl_error
+        if ssl_error.message.match?(/SSL_read: unexpected eof while reading/i)
+          raise EOFError, ssl_error.message
+        else
+          raise
+        end
       end
 
       def format_reply(reply_type, line)

data/lib/redis/distributed.rb

@@ -115,13 +115,13 @@ class Redis
     end
 
     # Set a key's time to live in seconds.
-    def expire(key, seconds)
-      node_for(key).expire(key, seconds)
+    def expire(key, seconds, **kwargs)
+      node_for(key).expire(key, seconds, **kwargs)
     end
 
     # Set the expiration for a key as a UNIX timestamp.
-    def expireat(key, unix_time)
-      node_for(key).expireat(key, unix_time)
+    def expireat(key, unix_time, **kwargs)
+      node_for(key).expireat(key, unix_time, **kwargs)
     end
 
     # Get the time to live (in seconds) for a key.
@@ -130,13 +130,13 @@ class Redis
     end
 
     # Set a key's time to live in milliseconds.
-    def pexpire(key, milliseconds)
-      node_for(key).pexpire(key, milliseconds)
+    def pexpire(key, milliseconds, **kwarg)
+      node_for(key).pexpire(key, milliseconds, **kwarg)
     end
 
     # Set the expiration for a key as number of milliseconds from UNIX Epoch.
-    def pexpireat(key, ms_unix_time)
-      node_for(key).pexpireat(key, ms_unix_time)
+    def pexpireat(key, ms_unix_time, **kwarg)
+      node_for(key).pexpireat(key, ms_unix_time, **kwarg)
     end
 
     # Get the time to live (in milliseconds) for a key.
@@ -464,12 +464,13 @@ class Redis
         options = args.pop
         options[:timeout]
       elsif args.last.respond_to?(:to_int)
-        # Issue deprecation notice in obnoxious mode...
-        args.pop.to_int
-      end
-
-      if args.size > 1
-        # Issue deprecation notice in obnoxious mode...
+        last_arg = args.pop
+        ::Redis.deprecate!(
+          "Passing the timeout as a positional argument is deprecated, it should be passed as a keyword argument:\n" \
+          "  redis.#{cmd}(#{args.map(&:inspect).join(', ')}, timeout: #{last_arg.to_int})" \
+          "(called from: #{caller(2, 1).first})"
+        )
+        last_arg.to_int
       end
 
       keys = args.flatten
@@ -543,11 +544,21 @@ class Redis
       node_for(key).sadd(key, member)
     end
 
+    # Add one or more members to a set.
+    def sadd?(key, member)
+      node_for(key).sadd?(key, member)
+    end
+
     # Remove one or more members from a set.
     def srem(key, member)
       node_for(key).srem(key, member)
     end
 
+    # Remove one or more members from a set.
+    def srem?(key, member)
+      node_for(key).srem?(key, member)
+    end
+
     # Remove and return a random member from a set.
     def spop(key, count = nil)
       node_for(key).spop(key, count)

data/lib/redis/errors.rb

@@ -45,6 +45,15 @@ class Redis
   end
 
   class Cluster
+    # Raised when client connected to redis as cluster mode
+    # and failed to fetch cluster state information by commands.
+    class InitialSetupError < BaseError
+      # @param errors [Array<Redis::BaseError>]
+      def initialize(errors)
+        super("Redis client could not fetch cluster information: #{errors.map(&:message).uniq.join(',')}")
+      end
+    end
+
     # Raised when client connected to redis as cluster mode
     # and some cluster subcommands were called.
     class OrchestrationCommandNotSupported < BaseError

data/lib/redis/pipeline.rb

@@ -22,6 +22,11 @@ class Redis
       yield self
     end
 
+    def call_pipeline(pipeline)
+      @pipeline.call_pipeline(pipeline)
+      nil
+    end
+
     private
 
     def synchronize
@@ -69,6 +74,7 @@ class Redis
     attr_reader :client
 
     attr :futures
+    alias materialized_futures futures
 
     def initialize(client)
       @client = client.is_a?(Pipeline) ? client.client : client
@@ -112,7 +118,7 @@ class Redis
 
     def call_pipeline(pipeline)
       @shutdown = true if pipeline.shutdown?
-      @futures.concat(pipeline.futures)
+      @futures.concat(pipeline.materialized_futures)
       @db = pipeline.db
       nil
     end
@@ -169,6 +175,18 @@ class Redis
         end
       end
 
+      def materialized_futures
+        if empty?
+          []
+        else
+          [
+            Future.new([:multi], nil, 0),
+            *futures,
+            MultiFuture.new(futures)
+          ]
+        end
+      end
+
       def timeouts
         if empty?
           []
@@ -271,4 +289,18 @@ class Redis
       Future
     end
   end
+
+  class MultiFuture < Future
+    def initialize(futures)
+      @futures = futures
+      @command = [:exec]
+    end
+
+    def _set(replies)
+      @futures.each_with_index do |future, index|
+        future._set(replies[index])
+      end
+      replies
+    end
+  end
 end

data/lib/redis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Redis
-  VERSION = '4.6.0'
+  VERSION = '4.8.0'
 end

data/lib/redis.rb

@@ -7,12 +7,13 @@ require "redis/commands"
 class Redis
   BASE_PATH = __dir__
   @exists_returns_integer = true
+  @sadd_returns_boolean = true
 
   Deprecated = Class.new(StandardError)
 
   class << self
     attr_reader :exists_returns_integer
-    attr_accessor :silence_deprecations, :raise_deprecations
+    attr_accessor :silence_deprecations, :raise_deprecations, :sadd_returns_boolean
 
     def exists_returns_integer=(value)
       unless value
@@ -37,7 +38,7 @@ class Redis
     end
 
     def current
-      deprecate!("`Redis.current=` is deprecated and will be removed in 5.0. (called from: #{caller(1, 1).first})")
+      deprecate!("`Redis.current` is deprecated and will be removed in 5.0. (called from: #{caller(1, 1).first})")
       @current ||= Redis.new
     end
 
@@ -74,6 +75,8 @@ class Redis
   # @option options [Symbol] :role (:master) Role to fetch via Sentinel, either `:master` or `:slave`
   # @option options [Array<String, Hash{Symbol => String, Integer}>] :cluster List of cluster nodes to contact
   # @option options [Boolean] :replica Whether to use readonly replica nodes in Redis Cluster or not
+  # @option options [String] :fixed_hostname Specify a FQDN if cluster mode enabled and
+  #   client has to connect nodes via single endpoint with SSL/TLS
   # @option options [Class] :connector Class of custom connector
   #
   # @return [Redis] a new client instance
@@ -109,6 +112,10 @@ class Redis
   end
   alias disconnect! close
 
+  def with
+    yield self
+  end
+
   # @deprecated Queues a command for pipelining.
   #
   # Commands in the queue are executed with the Redis#commit method.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis
 version: !ruby/object:Gem::Version
-  version: 4.6.0
+  version: 4.8.0
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -16,7 +16,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-02 00:00:00.000000000 Z
+date: 2022-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-synchrony
@@ -119,9 +119,9 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/redis/redis-rb/issues
   changelog_uri: https://github.com/redis/redis-rb/blob/master/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/redis/4.6.0
+  documentation_uri: https://www.rubydoc.info/gems/redis/4.8.0
   homepage_uri: https://github.com/redis/redis-rb
-  source_code_uri: https://github.com/redis/redis-rb/tree/v4.6.0
+  source_code_uri: https://github.com/redis/redis-rb/tree/v4.8.0
 post_install_message:
 rdoc_options: []
 require_paths: