redis 4.2.5 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 862e8133262fead707e4ca317b29d0e35425e3a7861ea1a52033bc91ba61bf6d
-  data.tar.gz: 5b2b32250d783fe58b0af54cc386f2568241644a0badc0b7247bb29b1ac94a93
+  metadata.gz: d5ff2ee4b6a6f2b087ac26bf96a3c1769cf42f70ea90008361157f7ef04cdb14
+  data.tar.gz: f2c24654294c4fa81a5cff4ddb545bc59e6f85b64ee61273278cb1e286a4edb8
 SHA512:
-  metadata.gz: 2aab289f4f22b2f3a804ca7b0da4cf95e352a8d246611490d8d803edebbbc7e7c299355cd0b90e6f3ac8bc0d11e9bf3792a328c95847d32e1d984729afe66ed2
-  data.tar.gz: d9ec8ba4d314d099e909cdddf6dfb4c3c14b853b46f45c4909ac3ba10fb1880bd9a7b0465257fa91f9a4ea6c9f82723c16c177810ac15c89fab3790d7af31ad0
+  metadata.gz: 0d88c6621659a178dca04d3ca62f25520f5f1a846b6300f93fb008966551fb4795a3e6c37810f99ea18f77a6292b955fa180ae3e06f8c90df7e6a3ca27087ae1
+  data.tar.gz: 1427cc268e867872388f214184d23a5c6062104fcb9d1e50d6026dd9daf6e51b9833866fee9fcf80c7a64e4de705295de8399d8e8ac22fa890bf358bd63ff707

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Unreleased
 
+# 4.4.0
+
+* Redis cluster: fix cross-slot validation in pipelines. Fix ##1019.
+* Add support for `XAUTOCLAIM`. See #1018.
+* Properly issue `READONLY` when reconnecting to replicas. Fix #1017.
+* Make `del` a noop if passed an empty list of keys. See #998.
+* Add support for `ZINTER`. See #995.
+
+# 4.3.1
+
+* Fix password authentication against redis server 5 and older.
+
+# 4.3.0
+
+* Add the TYPE argument to scan and scan_each. See #985.
+* Support AUTH command for ACL. See #967.
+
 # 4.2.5
 
 * Optimize the ruby connector write buffering. See #964.

data/README.md

@@ -1,4 +1,4 @@
-# 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)
+# redis-rb [![Build Status][gh-actions-image]][gh-actions-link] [![Inline docs][inchpages-image]][inchpages-link]
 
 A Ruby client that tries to match [Redis][redis-home]' API one-to-one, while still
 providing an idiomatic interface.
@@ -54,6 +54,12 @@ To connect to a password protected Redis instance, use:
 redis = Redis.new(password: "mysecret")
 ```
 
+To connect a Redis instance using [ACL](https://redis.io/topics/acl), use:
+
+```ruby
+redis = Redis.new(username: 'myname', password: 'mysecret')
+```
+
 The Redis class exports methods that are named identical to the commands
 they execute. The arguments these methods accept are often identical to
 the arguments specified on the [Redis website][redis-commands]. For
@@ -440,7 +446,7 @@ redis = Redis.new(:driver => :synchrony)
 ## Testing
 
 This library is tested against recent Ruby and Redis versions.
-Check [Travis][travis-link] for the exact versions supported.
+Check [Github Actions][gh-actions-link] for the exact versions supported.
 
 ## See Also
 
@@ -459,12 +465,11 @@ client and evangelized Redis in Rubyland. Thank you, Ezra.
 requests.
 
 
-[inchpages-image]: https://inch-ci.org/github/redis/redis-rb.svg
-[inchpages-link]:  https://inch-ci.org/github/redis/redis-rb
-[redis-commands]:  https://redis.io/commands
-[redis-home]:      https://redis.io
-[redis-url]:       http://www.iana.org/assignments/uri-schemes/prov/redis
-[travis-home]:     https://travis-ci.org/
-[travis-image]:    https://secure.travis-ci.org/redis/redis-rb.svg?branch=master
-[travis-link]:     https://travis-ci.org/redis/redis-rb
-[rubydoc]:         http://www.rubydoc.info/gems/redis
+[inchpages-image]:  https://inch-ci.org/github/redis/redis-rb.svg
+[inchpages-link]:   https://inch-ci.org/github/redis/redis-rb
+[redis-commands]:   https://redis.io/commands
+[redis-home]:       https://redis.io
+[redis-url]:        http://www.iana.org/assignments/uri-schemes/prov/redis
+[gh-actions-image]: https://github.com/redis/redis-rb/workflows/Test/badge.svg
+[gh-actions-link]:  https://github.com/redis/redis-rb/actions
+[rubydoc]:          http://www.rubydoc.info/gems/redis

data/lib/redis/client.rb

@@ -17,6 +17,7 @@ class Redis
       write_timeout: nil,
       connect_timeout: nil,
       timeout: 5.0,
+      username: nil,
       password: nil,
       db: 0,
       driver: nil,
@@ -61,6 +62,10 @@ class Redis
       @options[:read_timeout]
     end
 
+    def username
+      @options[:username]
+    end
+
     def password
       @options[:password]
     end
@@ -110,7 +115,19 @@ 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 # Likely on Redis < 6
+              call [:auth, password]
+            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)
@@ -131,7 +148,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
@@ -434,7 +451,8 @@ class Redis
           defaults[:scheme]   = uri.scheme
           defaults[:host]     = uri.host 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
@@ -510,7 +528,7 @@ class Redis
           require_relative "connection/#{driver}"
         rescue LoadError, NameError
           begin
-            require "connection/#{driver}"
+            require "redis/connection/#{driver}"
           rescue LoadError, NameError => error
             raise "Cannot load driver #{driver.inspect}: #{error.message}"
           end
@@ -579,6 +597,7 @@ class Redis
             client = Client.new(@options.merge({
                                                  host: sentinel[:host] || sentinel["host"],
                                                  port: sentinel[:port] || sentinel["port"],
+                                                 username: sentinel[:username] || sentinel["username"],
                                                  password: sentinel[:password] || sentinel["password"],
                                                  reconnect_attempts: 0
                                                }))

data/lib/redis/cluster/node.rb

@@ -76,8 +76,9 @@ class Redis
         clients = options.map do |node_key, option|
           next if replica_disabled? && slave?(node_key)
 
+          option = option.merge(readonly: true) if slave?(node_key)
+
           client = Client.new(option)
-          client.call(%i[readonly]) if slave?(node_key)
           [node_key, client]
         end
 

data/lib/redis/cluster/option.rb

@@ -18,6 +18,7 @@ class Redis
         @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, :username)
         add_common_node_option_if_needed(options, @node_opts, :password)
         @options = options
       end
@@ -63,7 +64,9 @@ class Redis
         raise InvalidClientOptionError, "Invalid uri scheme #{addr}" unless VALID_SCHEMES.include?(uri.scheme)
 
         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? }
+
+        { scheme: uri.scheme, username: uri.user, password: uri.password, host: uri.host, port: uri.port, db: db }
+          .reject { |_, v| v.nil? || v == '' }
       rescue URI::InvalidURIError => err
         raise InvalidClientOptionError, err.message
       end
@@ -79,7 +82,7 @@ class Redis
 
       # Redis cluster node returns only host and port information.
       # So we should complement additional information such as:
-      #   scheme, password and so on.
+      #   scheme, username, 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?
 

data/lib/redis/cluster.rb

@@ -78,11 +78,13 @@ class Redis
     end
 
     def call_pipeline(pipeline)
-      node_keys, command_keys = extract_keys_in_pipeline(pipeline)
-      raise CrossSlotPipeliningError, command_keys if node_keys.size > 1
+      node_keys = pipeline.commands.map { |cmd| find_node_key(cmd, primary_only: true) }.compact.uniq
+      if node_keys.size > 1
+        raise(CrossSlotPipeliningError,
+              pipeline.commands.map { |cmd| @command.extract_first_key(cmd) }.reject(&:empty?).uniq)
+      end
 
-      node = find_node(node_keys.first)
-      try_send(node, :call_pipeline, pipeline)
+      try_send(find_node(node_keys.first), :call_pipeline, pipeline)
     end
 
     def call_with_timeout(command, timeout, &block)
@@ -128,7 +130,7 @@ class Redis
     def send_command(command, &block)
       cmd = command.first.to_s.downcase
       case cmd
-      when 'auth', 'bgrewriteaof', 'bgsave', 'quit', 'save'
+      when 'acl', 'auth', 'bgrewriteaof', 'bgsave', 'quit', 'save'
         @node.call_all(command, &block).first
       when 'flushall', 'flushdb'
         @node.call_master(command, &block).first
@@ -253,14 +255,14 @@ class Redis
       find_node(node_key)
     end
 
-    def find_node_key(command)
+    def find_node_key(command, primary_only: false)
       key = @command.extract_first_key(command)
       return if key.empty?
 
       slot = KeySlotConverter.convert(key)
       return unless @slot.exists?(slot)
 
-      if @command.should_send_to_master?(command)
+      if @command.should_send_to_master?(command) || primary_only
         @slot.find_node_key_of_master(slot)
       else
         @slot.find_node_key_of_slave(slot)
@@ -285,11 +287,5 @@ class Redis
       @node.map(&:disconnect)
       @node, @slot = fetch_cluster_info!(@option)
     end
-
-    def extract_keys_in_pipeline(pipeline)
-      node_keys = pipeline.commands.map { |cmd| find_node_key(cmd) }.compact.uniq
-      command_keys = pipeline.commands.map { |cmd| @command.extract_first_key(cmd) }.reject(&:empty?)
-      [node_keys, command_keys]
-    end
   end
 end

data/lib/redis/distributed.rb

@@ -413,14 +413,14 @@ class Redis
       node_for(key).rpushx(key, value)
     end
 
-    # Remove and get the first element in a list.
-    def lpop(key)
-      node_for(key).lpop(key)
+    # Remove and get the first elements in a list.
+    def lpop(key, count = nil)
+      node_for(key).lpop(key, count)
     end
 
-    # Remove and get the last element in a list.
-    def rpop(key)
-      node_for(key).rpop(key)
+    # Remove and get the last elements in a list.
+    def rpop(key, count = nil)
+      node_for(key).rpop(key, count)
     end
 
     # Remove the last element in a list, append it to another list and return
@@ -674,6 +674,13 @@ class Redis
       node_for(key).zcount(key, min, max)
     end
 
+    # Get the intersection of multiple sorted sets
+    def zinter(*keys, **options)
+      ensure_same_node(:zinter, keys) do |node|
+        node.zinter(*keys, **options)
+      end
+    end
+
     # Intersect multiple sorted sets and store the resulting sorted set in a new
     # key.
     def zinterstore(destination, keys, **options)

data/lib/redis/version.rb

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

data/lib/redis.rb

@@ -39,6 +39,7 @@ class Redis
   # @option options [String] :path path to server socket (overrides host and port)
   # @option options [Float] :timeout (5.0) timeout in seconds
   # @option options [Float] :connect_timeout (same as timeout) timeout for initial connect in seconds
+  # @option options [String] :username Username to authenticate against server
   # @option options [String] :password Password to authenticate against server
   # @option options [Integer] :db (0) Database to select after initial connect
   # @option options [Symbol] :driver Driver to use, currently supported: `:ruby`, `:hiredis`, `:synchrony`
@@ -143,12 +144,13 @@ class Redis
 
   # Authenticate to the server.
   #
-  # @param [String] password must match the password specified in the
-  #   `requirepass` directive in the configuration file
+  # @param [Array<String>] args includes both username and password
+  #   or only password
   # @return [String] `OK`
-  def auth(password)
+  # @see https://redis.io/commands/auth AUTH command
+  def auth(*args)
     synchronize do |client|
-      client.call([:auth, password])
+      client.call([:auth, *args])
     end
   end
 
@@ -553,6 +555,9 @@ class Redis
   # @param [String, Array<String>] keys
   # @return [Integer] number of keys that were deleted
   def del(*keys)
+    keys.flatten!(1)
+    return 0 if keys.empty?
+
     synchronize do |client|
       client.call([:del] + keys)
     end
@@ -1170,23 +1175,29 @@ class Redis
     end
   end
 
-  # Remove and get the first element in a list.
+  # Remove and get the first elements in a list.
   #
   # @param [String] key
-  # @return [String]
-  def lpop(key)
+  # @param [Integer] count number of elements to remove
+  # @return [String, Array<String>] the values of the first elements
+  def lpop(key, count = nil)
     synchronize do |client|
-      client.call([:lpop, key])
+      command = [:lpop, key]
+      command << count if count
+      client.call(command)
     end
   end
 
-  # Remove and get the last element in a list.
+  # Remove and get the last elements in a list.
   #
   # @param [String] key
-  # @return [String]
-  def rpop(key)
+  # @param [Integer] count number of elements to remove
+  # @return [String, Array<String>] the values of the last elements
+  def rpop(key, count = nil)
     synchronize do |client|
-      client.call([:rpop, key])
+      command = [:rpop, key]
+      command << count if count
+      client.call(command)
     end
   end
 
@@ -2054,6 +2065,45 @@ class Redis
     end
   end
 
+  # Return the intersection of multiple sorted sets
+  #
+  # @example Retrieve the intersection of `2*zsetA` and `1*zsetB`
+  #   redis.zinter("zsetA", "zsetB", :weights => [2.0, 1.0])
+  #     # => ["v1", "v2"]
+  # @example Retrieve the intersection of `2*zsetA` and `1*zsetB`, and their scores
+  #   redis.zinter("zsetA", "zsetB", :weights => [2.0, 1.0], :with_scores => true)
+  #     # => [["v1", 3.0], ["v2", 6.0]]
+  #
+  # @param [String, Array<String>] keys one or more keys to intersect
+  # @param [Hash] options
+  #   - `:weights => [Float, Float, ...]`: weights to associate with source
+  #   sorted sets
+  #   - `:aggregate => String`: aggregate function to use (sum, min, max, ...)
+  #   - `:with_scores => true`: include scores in output
+  #
+  # @return [Array<String>, Array<[String, Float]>]
+  #   - when `:with_scores` is not specified, an array of members
+  #   - when `:with_scores` is specified, an array with `[member, score]` pairs
+  def zinter(*keys, weights: nil, aggregate: nil, with_scores: false)
+    args = [:zinter, keys.size, *keys]
+
+    if weights
+      args << "WEIGHTS"
+      args.concat(weights)
+    end
+
+    args << "AGGREGATE" << aggregate if aggregate
+
+    if with_scores
+      args << "WITHSCORES"
+      block = FloatifyPairs
+    end
+
+    synchronize do |client|
+      client.call(args, &block)
+    end
+  end
+
   # Intersect multiple sorted sets and store the resulting sorted set in a new
   # key.
   #
@@ -2636,12 +2686,13 @@ class Redis
     _eval(:evalsha, args)
   end
 
-  def _scan(command, cursor, args, match: nil, count: nil, &block)
+  def _scan(command, cursor, args, match: nil, count: nil, type: nil, &block)
     # SSCAN/ZSCAN/HSCAN already prepend the key to +args+.
 
     args << cursor
     args << "MATCH" << match if match
     args << "COUNT" << count if count
+    args << "TYPE" << type if type
 
     synchronize do |client|
       client.call([command] + args, &block)
@@ -2656,11 +2707,15 @@ class Redis
   # @example Retrieve a batch of keys matching a pattern
   #   redis.scan(4, :match => "key:1?")
   #     # => ["92", ["key:13", "key:18"]]
+  # @example Retrieve a batch of keys of a certain type
+  #   redis.scan(92, :type => "zset")
+  #     # => ["173", ["sortedset:14", "sortedset:78"]]
   #
   # @param [String, Integer] cursor the cursor of the iteration
   # @param [Hash] options
   #   - `:match => String`: only return keys matching the pattern
   #   - `:count => Integer`: return count keys at most per iteration
+  #   - `:type => String`: return keys only of the given type
   #
   # @return [String, Array<String>] the next cursor and all found keys
   def scan(cursor, **options)
@@ -2676,10 +2731,15 @@ class Redis
   #   redis.scan_each(:match => "key:1?") {|key| puts key}
   #     # => key:13
   #     # => key:18
+  # @example Execute block for each key of a type
+  #   redis.scan_each(:type => "hash") {|key| puts redis.type(key)}
+  #     # => "hash"
+  #     # => "hash"
   #
   # @param [Hash] options
   #   - `:match => String`: only return keys matching the pattern
   #   - `:count => Integer`: return count keys at most per iteration
+  #   - `:type => String`: return keys only of the given type
   #
   # @return [Enumerator] an enumerator for all found keys
   def scan_each(**options, &block)
@@ -3220,6 +3280,38 @@ class Redis
     synchronize { |client| client.call(args, &blk) }
   end
 
+  # Transfers ownership of pending stream entries that match the specified criteria.
+  #
+  # @example Claim next pending message stuck > 5 minutes  and mark as retry
+  #   redis.xautoclaim('mystream', 'mygroup', 'consumer1', 3600000, '0-0')
+  # @example Claim 50 next pending messages stuck > 5 minutes  and mark as retry
+  #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, '0-0', count: 50)
+  # @example Claim next pending message stuck > 5 minutes and don't mark as retry
+  #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, '0-0', justid: true)
+  # @example Claim next pending message after this id stuck > 5 minutes  and mark as retry
+  #   redis.xautoclaim('mystream', 'mygroup', 'consumer1', 3600000, '1641321233-0')
+  #
+  # @param key           [String]        the stream key
+  # @param group         [String]        the consumer group name
+  # @param consumer      [String]        the consumer name
+  # @param min_idle_time [Integer]       the number of milliseconds
+  # @param start         [String]        entry id to start scanning from or 0-0 for everything
+  # @param count         [Integer]       number of messages to claim (default 1)
+  # @param justid        [Boolean]       whether to fetch just an array of entry ids or not.
+  #                                      Does not increment retry count when true
+  #
+  # @return [Hash{String => Hash}] the entries successfully claimed
+  # @return [Array<String>]        the entry ids successfully claimed if justid option is `true`
+  def xautoclaim(key, group, consumer, min_idle_time, start, count: nil, justid: false)
+    args = [:xautoclaim, key, group, consumer, min_idle_time, start]
+    if count
+      args << 'COUNT' << count.to_s
+    end
+    args << 'JUSTID' if justid
+    blk = justid ? HashifyStreamAutoclaimJustId : HashifyStreamAutoclaim
+    synchronize { |client| client.call(args, &blk) }
+  end
+
   # Fetches not acknowledging pending entries
   #
   # @example With key and group
@@ -3430,6 +3522,20 @@ class Redis
     end
   }
 
+  HashifyStreamAutoclaim = lambda { |reply|
+    {
+      'next' => reply[0],
+      'entries' => reply[1].map { |entry| [entry[0], entry[1].each_slice(2).to_h] }
+    }
+  }
+
+  HashifyStreamAutoclaimJustId = lambda { |reply|
+    {
+      'next' => reply[0],
+      'entries' => reply[1]
+    }
+  }
+
   HashifyStreamPendings = lambda { |reply|
     {
       'size' => reply[0],

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis
 version: !ruby/object:Gem::Version
-  version: 4.2.5
+  version: 4.4.0
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -16,7 +16,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-20 00:00:00.000000000 Z
+date: 2021-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-synchrony
@@ -102,9 +102,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.2.5
+  documentation_uri: https://www.rubydoc.info/gems/redis/4.4.0
   homepage_uri: https://github.com/redis/redis-rb
-  source_code_uri: https://github.com/redis/redis-rb/tree/v4.2.5
+  source_code_uri: https://github.com/redis/redis-rb/tree/v4.4.0
 post_install_message:
 rdoc_options: []
 require_paths: