redis 4.3.1 → 5.4.1

data/lib/redis/distributed.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "hash_ring"
+require "redis/hash_ring"
 
 class Redis
   class Distributed
@@ -20,7 +20,7 @@ class Redis
     def initialize(node_configs, options = {})
       @tag = options[:tag] || /^\{(.+?)\}/
       @ring = options[:ring] || HashRing.new
-      @node_configs = node_configs.dup
+      @node_configs = node_configs.map(&:dup)
       @default_options = options.dup
       node_configs.each { |node_config| add_node(node_config) }
       @subscribed_node = nil
@@ -41,6 +41,8 @@ class Redis
     def add_node(options)
       options = { url: options } if options.is_a?(String)
       options = @default_options.merge(options)
+      options.delete(:tag)
+      options.delete(:ring)
       @ring.add_node Redis.new(options)
     end
 
@@ -64,6 +66,10 @@ class Redis
       on_each_node :quit
     end
 
+    def close
+      on_each_node :close
+    end
+
     # Asynchronously save the dataset to disk.
     def bgsave
       on_each_node :bgsave
@@ -115,13 +121,18 @@ 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 expiration for a key as a UNIX timestamp.
+    def expiretime(key)
+      node_for(key).expiretime(key)
     end
 
     # Get the time to live (in seconds) for a key.
@@ -130,13 +141,18 @@ 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 expiration for a key as number of milliseconds from UNIX Epoch.
+    def pexpiretime(key)
+      node_for(key).pexpiretime(key)
     end
 
     # Get the time to live (in milliseconds) for a key.
@@ -161,6 +177,7 @@ class Redis
 
     # Delete a key.
     def del(*args)
+      args.flatten!(1)
       keys_per_node = args.group_by { |key| node_for(key) }
       keys_per_node.inject(0) do |sum, (node, keys)|
         sum + node.del(*keys)
@@ -169,6 +186,7 @@ class Redis
 
     # Unlink keys.
     def unlink(*args)
+      args.flatten!(1)
       keys_per_node = args.group_by { |key| node_for(key) }
       keys_per_node.inject(0) do |sum, (node, keys)|
         sum + node.unlink(*keys)
@@ -177,27 +195,16 @@ class Redis
 
     # Determine if a key exists.
     def exists(*args)
-      if !Redis.exists_returns_integer && args.size == 1
-        message = "`Redis#exists(key)` will return an Integer in redis-rb 4.3, if you want to keep the old behavior, " \
-          "use `exists?` instead. To opt-in to the new behavior now you can set Redis.exists_returns_integer = true. " \
-          "(#{::Kernel.caller(1, 1).first})\n"
-
-        if defined?(::Warning)
-          ::Warning.warn(message)
-        else
-          warn(message)
-        end
-        exists?(*args)
-      else
-        keys_per_node = args.group_by { |key| node_for(key) }
-        keys_per_node.inject(0) do |sum, (node, keys)|
-          sum + node._exists(*keys)
-        end
+      args.flatten!(1)
+      keys_per_node = args.group_by { |key| node_for(key) }
+      keys_per_node.inject(0) do |sum, (node, keys)|
+        sum + node.exists(*keys)
       end
     end
 
     # Determine if any of the keys exists.
     def exists?(*args)
+      args.flatten!(1)
       keys_per_node = args.group_by { |key| node_for(key) }
       keys_per_node.each do |node, keys|
         return true if node.exists?(*keys)
@@ -215,6 +222,13 @@ class Redis
       node_for(key).move(key, db)
     end
 
+    # Copy a value from one key to another.
+    def copy(source, destination, **options)
+      ensure_same_node(:copy, [source, destination]) do |node|
+        node.copy(source, destination, **options)
+      end
+    end
+
     # Return a random key from the keyspace.
     def randomkey
       raise CannotDistribute, :randomkey
@@ -294,7 +308,7 @@ class Redis
     end
 
     # Set multiple keys to multiple values.
-    def mset(*_args)
+    def mset(*)
       raise CannotDistribute, :mset
     end
 
@@ -303,7 +317,7 @@ class Redis
     end
 
     # Set multiple keys to multiple values, only if none of the keys exist.
-    def msetnx(*_args)
+    def msetnx(*)
       raise CannotDistribute, :msetnx
     end
 
@@ -316,13 +330,25 @@ class Redis
       node_for(key).get(key)
     end
 
+    # Get the value of a key and delete it.
+    def getdel(key)
+      node_for(key).getdel(key)
+    end
+
+    # Get the value of a key and sets its time to live based on options.
+    def getex(key, **options)
+      node_for(key).getex(key, **options)
+    end
+
     # Get the values of all the given keys as an Array.
     def mget(*keys)
+      keys.flatten!(1)
       mapped_mget(*keys).values_at(*keys)
     end
 
     # Get the values of all the given keys as a Hash.
     def mapped_mget(*keys)
+      keys.flatten!(1)
       keys.group_by { |k| node_for k }.inject({}) do |results, (node, subkeys)|
         results.merge! node.mapped_mget(*subkeys)
       end
@@ -354,20 +380,21 @@ class Redis
     end
 
     # Count the number of set bits in a range of the string value stored at key.
-    def bitcount(key, start = 0, stop = -1)
-      node_for(key).bitcount(key, start, stop)
+    def bitcount(key, start = 0, stop = -1, scale: nil)
+      node_for(key).bitcount(key, start, stop, scale: scale)
     end
 
     # Perform a bitwise operation between strings and store the resulting string in a key.
     def bitop(operation, destkey, *keys)
+      keys.flatten!(1)
       ensure_same_node(:bitop, [destkey] + keys) do |node|
-        node.bitop(operation, destkey, *keys)
+        node.bitop(operation, destkey, keys)
       end
     end
 
     # Return the position of the first bit set to 1 or 0 in a string.
-    def bitpos(key, bit, start = nil, stop = nil)
-      node_for(key).bitpos(key, bit, start, stop)
+    def bitpos(key, bit, start = nil, stop = nil, scale: nil)
+      node_for(key).bitpos(key, bit, start, stop, scale: scale)
     end
 
     # Set the string value of a key and return its old value.
@@ -393,6 +420,21 @@ class Redis
       node_for(key).llen(key)
     end
 
+    # Remove the first/last element in a list, append/prepend it to another list and return it.
+    def lmove(source, destination, where_source, where_destination)
+      ensure_same_node(:lmove, [source, destination]) do |node|
+        node.lmove(source, destination, where_source, where_destination)
+      end
+    end
+
+    # Remove the first/last element in a list and append/prepend it
+    # to another list and return it, or block until one is available.
+    def blmove(source, destination, where_source, where_destination, timeout: 0)
+      ensure_same_node(:lmove, [source, destination]) do |node|
+        node.blmove(source, destination, where_source, where_destination, timeout: timeout)
+      end
+    end
+
     # Prepend one or more values to a list.
     def lpush(key, value)
       node_for(key).lpush(key, value)
@@ -435,22 +477,15 @@ class Redis
       timeout = if args.last.is_a?(Hash)
         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...
       end
 
-      keys = args.flatten
+      args.flatten!(1)
 
-      ensure_same_node(cmd, keys) do |node|
+      ensure_same_node(cmd, args) do |node|
         if timeout
-          node.__send__(cmd, keys, timeout: timeout)
+          node.__send__(cmd, args, timeout: timeout)
         else
-          node.__send__(cmd, keys)
+          node.__send__(cmd, args)
         end
       end
     end
@@ -461,6 +496,18 @@ class Redis
       _bpop(:blpop, args)
     end
 
+    def bzpopmax(*args)
+      _bpop(:bzpopmax, args) do |reply|
+        reply.is_a?(Array) ? [reply[0], reply[1], Floatify.call(reply[2])] : reply
+      end
+    end
+
+    def bzpopmin(*args)
+      _bpop(:bzpopmin, args) do |reply|
+        reply.is_a?(Array) ? [reply[0], reply[1], Floatify.call(reply[2])] : reply
+      end
+    end
+
     # Remove and get the last element in a list, or block until one is
     # available.
     def brpop(*args)
@@ -469,9 +516,9 @@ class Redis
 
     # Pop a value from a list, push it to another list and return it; or block
     # until one is available.
-    def brpoplpush(source, destination, deprecated_timeout = 0, **options)
+    def brpoplpush(source, destination, **options)
       ensure_same_node(:brpoplpush, [source, destination]) do |node|
-        node.brpoplpush(source, destination, deprecated_timeout, **options)
+        node.brpoplpush(source, destination, **options)
       end
     end
 
@@ -505,19 +552,43 @@ class Redis
       node_for(key).ltrim(key, start, stop)
     end
 
+    # Iterate over keys, blocking and removing elements from the first non empty liist found.
+    def blmpop(timeout, *keys, modifier: "LEFT", count: nil)
+      ensure_same_node(:blmpop, keys) do |node|
+        node.blmpop(timeout, *keys, modifier: modifier, count: count)
+      end
+    end
+
+    # Iterate over keys, removing elements from the first non list found.
+    def lmpop(*keys, modifier: "LEFT", count: nil)
+      ensure_same_node(:lmpop, keys) do |node|
+        node.lmpop(*keys, modifier: modifier, count: count)
+      end
+    end
+
     # Get the number of members in a set.
     def scard(key)
       node_for(key).scard(key)
     end
 
     # Add one or more members to a set.
-    def sadd(key, member)
-      node_for(key).sadd(key, member)
+    def sadd(key, *members)
+      node_for(key).sadd(key, *members)
+    end
+
+    # Add one or more members to a set.
+    def sadd?(key, *members)
+      node_for(key).sadd?(key, *members)
     end
 
     # Remove one or more members from a set.
-    def srem(key, member)
-      node_for(key).srem(key, member)
+    def srem(key, *members)
+      node_for(key).srem(key, *members)
+    end
+
+    # Remove one or more members from a set.
+    def srem?(key, *members)
+      node_for(key).srem?(key, *members)
     end
 
     # Remove and return a random member from a set.
@@ -542,6 +613,11 @@ class Redis
       node_for(key).sismember(key, member)
     end
 
+    # Determine if multiple values are members of a set.
+    def smismember(key, *members)
+      node_for(key).smismember(key, *members)
+    end
+
     # Get all the members in a set.
     def smembers(key)
       node_for(key).smembers(key)
@@ -559,43 +635,49 @@ class Redis
 
     # Subtract multiple sets.
     def sdiff(*keys)
+      keys.flatten!(1)
       ensure_same_node(:sdiff, keys) do |node|
-        node.sdiff(*keys)
+        node.sdiff(keys)
       end
     end
 
     # Subtract multiple sets and store the resulting set in a key.
     def sdiffstore(destination, *keys)
-      ensure_same_node(:sdiffstore, [destination] + keys) do |node|
-        node.sdiffstore(destination, *keys)
+      keys.flatten!(1)
+      ensure_same_node(:sdiffstore, [destination].concat(keys)) do |node|
+        node.sdiffstore(destination, keys)
       end
     end
 
     # Intersect multiple sets.
     def sinter(*keys)
+      keys.flatten!(1)
       ensure_same_node(:sinter, keys) do |node|
-        node.sinter(*keys)
+        node.sinter(keys)
       end
     end
 
     # Intersect multiple sets and store the resulting set in a key.
     def sinterstore(destination, *keys)
-      ensure_same_node(:sinterstore, [destination] + keys) do |node|
-        node.sinterstore(destination, *keys)
+      keys.flatten!(1)
+      ensure_same_node(:sinterstore, [destination].concat(keys)) do |node|
+        node.sinterstore(destination, keys)
       end
     end
 
     # Add multiple sets.
     def sunion(*keys)
+      keys.flatten!(1)
       ensure_same_node(:sunion, keys) do |node|
-        node.sunion(*keys)
+        node.sunion(keys)
       end
     end
 
     # Add multiple sets and store the resulting set in a key.
     def sunionstore(destination, *keys)
-      ensure_same_node(:sunionstore, [destination] + keys) do |node|
-        node.sunionstore(destination, *keys)
+      keys.flatten!(1)
+      ensure_same_node(:sunionstore, [destination].concat(keys)) do |node|
+        node.sunionstore(destination, keys)
       end
     end
 
@@ -626,11 +708,43 @@ class Redis
       node_for(key).zscore(key, member)
     end
 
-    # Return a range of members in a sorted set, by index.
+    # Get one or more random members from a sorted set.
+    def zrandmember(key, count = nil, **options)
+      node_for(key).zrandmember(key, count, **options)
+    end
+
+    # Get the scores associated with the given members in a sorted set.
+    def zmscore(key, *members)
+      node_for(key).zmscore(key, *members)
+    end
+
+    # Iterate over keys, blocking and removing members from the first non empty sorted set found.
+    def bzmpop(timeout, *keys, modifier: "MIN", count: nil)
+      ensure_same_node(:bzmpop, keys) do |node|
+        node.bzmpop(timeout, *keys, modifier: modifier, count: count)
+      end
+    end
+
+    # Iterate over keys, removing members from the first non empty sorted set found.
+    def zmpop(*keys, modifier: "MIN", count: nil)
+      ensure_same_node(:zmpop, keys) do |node|
+        node.zmpop(*keys, modifier: modifier, count: count)
+      end
+    end
+
+    # Return a range of members in a sorted set, by index, score or lexicographical ordering.
     def zrange(key, start, stop, **options)
       node_for(key).zrange(key, start, stop, **options)
     end
 
+    # Select a range of members in a sorted set, by index, score or lexicographical ordering
+    # and store the resulting sorted set in a new key.
+    def zrangestore(dest_key, src_key, start, stop, **options)
+      ensure_same_node(:zrangestore, [dest_key, src_key]) do |node|
+        node.zrangestore(dest_key, src_key, start, stop, **options)
+      end
+    end
+
     # Return a range of members in a sorted set, by index, with scores ordered
     # from high to low.
     def zrevrange(key, start, stop, **options)
@@ -638,14 +752,14 @@ class Redis
     end
 
     # Determine the index of a member in a sorted set.
-    def zrank(key, member)
-      node_for(key).zrank(key, member)
+    def zrank(key, member, **options)
+      node_for(key).zrank(key, member, **options)
     end
 
     # Determine the index of a member in a sorted set, with scores ordered from
     # high to low.
-    def zrevrank(key, member)
-      node_for(key).zrevrank(key, member)
+    def zrevrank(key, member, **options)
+      node_for(key).zrevrank(key, member, **options)
     end
 
     # Remove all members in a sorted set within the given indexes.
@@ -674,21 +788,56 @@ class Redis
       node_for(key).zcount(key, min, max)
     end
 
+    # Get the intersection of multiple sorted sets
+    def zinter(*keys, **options)
+      keys.flatten!(1)
+      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)
-      ensure_same_node(:zinterstore, [destination] + keys) do |node|
+    def zinterstore(destination, *keys, **options)
+      keys.flatten!(1)
+      ensure_same_node(:zinterstore, [destination].concat(keys)) do |node|
         node.zinterstore(destination, keys, **options)
       end
     end
 
+    # Return the union of multiple sorted sets.
+    def zunion(*keys, **options)
+      keys.flatten!(1)
+      ensure_same_node(:zunion, keys) do |node|
+        node.zunion(keys, **options)
+      end
+    end
+
     # Add multiple sorted sets and store the resulting sorted set in a new key.
-    def zunionstore(destination, keys, **options)
-      ensure_same_node(:zunionstore, [destination] + keys) do |node|
+    def zunionstore(destination, *keys, **options)
+      keys.flatten!(1)
+      ensure_same_node(:zunionstore, [destination].concat(keys)) do |node|
         node.zunionstore(destination, keys, **options)
       end
     end
 
+    # Return the difference between the first and all successive input sorted sets.
+    def zdiff(*keys, **options)
+      keys.flatten!(1)
+      ensure_same_node(:zdiff, keys) do |node|
+        node.zdiff(keys, **options)
+      end
+    end
+
+    # Compute the difference between the first and all successive input sorted sets
+    # and store the resulting sorted set in a new key.
+    def zdiffstore(destination, *keys, **options)
+      keys.flatten!(1)
+      ensure_same_node(:zdiffstore, [destination] + keys) do |node|
+        node.zdiffstore(destination, keys, **options)
+      end
+    end
+
     # Get the number of fields in a hash.
     def hlen(key)
       node_for(key).hlen(key)
@@ -710,7 +859,7 @@ class Redis
     end
 
     def mapped_hmset(key, hash)
-      node_for(key).hmset(key, *hash.to_a.flatten)
+      node_for(key).hmset(key, hash)
     end
 
     # Get the value of a hash field.
@@ -720,16 +869,23 @@ class Redis
 
     # Get the values of all the given hash fields.
     def hmget(key, *fields)
-      node_for(key).hmget(key, *fields)
+      fields.flatten!(1)
+      node_for(key).hmget(key, fields)
     end
 
     def mapped_hmget(key, *fields)
-      Hash[*fields.zip(hmget(key, *fields)).flatten]
+      fields.flatten!(1)
+      node_for(key).mapped_hmget(key, fields)
+    end
+
+    def hrandfield(key, count = nil, **options)
+      node_for(key).hrandfield(key, count, **options)
     end
 
     # Delete one or more hash fields.
     def hdel(key, *fields)
-      node_for(key).hdel(key, *fields)
+      fields.flatten!(1)
+      node_for(key).hdel(key, fields)
     end
 
     # Determine if a hash field exists.
@@ -786,18 +942,22 @@ class Redis
 
     # Stop listening for messages posted to the given channels.
     def unsubscribe(*channels)
-      raise "Can't unsubscribe if not subscribed." unless subscribed?
+      raise SubscriptionError, "Can't unsubscribe if not subscribed." unless subscribed?
 
       @subscribed_node.unsubscribe(*channels)
     end
 
     # Listen for messages published to channels matching the given patterns.
+    # See the [Redis Server PSUBSCRIBE documentation](https://redis.io/docs/latest/commands/psubscribe/)
+    # for further details
     def psubscribe(*channels, &block)
       raise NotImplementedError
     end
 
     # Stop listening for messages posted to channels matching the given
     # patterns.
+    # See the [Redis Server PUNSUBSCRIBE documentation](https://redis.io/docs/latest/commands/punsubscribe/)
+    # for further details
     def punsubscribe(*channels)
       raise NotImplementedError
     end
@@ -833,9 +993,7 @@ class Redis
     def multi(&block)
       raise CannotDistribute, :multi unless @watch_key
 
-      result = node_for(@watch_key).multi(&block)
-      @watch_key = nil if block_given?
-      result
+      node_for(@watch_key).multi(&block)
     end
 
     # Execute all commands issued after MULTI.
@@ -925,7 +1083,8 @@ class Redis
     end
 
     def key_tag(key)
-      key.to_s[@tag, 1] if @tag
+      key = key.to_s
+      key[@tag, 1] if key.match?(@tag)
     end
 
     def ensure_same_node(command, keys)

data/lib/redis/errors.rb

@@ -2,7 +2,7 @@
 
 class Redis
   # Base error for all redis-rb errors.
-  class BaseError < RuntimeError
+  class BaseError < StandardError
   end
 
   # Raised by the connection when a protocol error occurs.
@@ -20,6 +20,20 @@ class Redis
   class CommandError < BaseError
   end
 
+  class PermissionError < CommandError
+  end
+
+  class WrongTypeError < CommandError
+  end
+
+  class OutOfMemoryError < CommandError
+  end
+
+  if defined?(RedisClient::NoScriptError)
+    class NoScriptError < CommandError
+    end
+  end
+
   # Base error for connection related errors.
   class BaseConnectionError < BaseError
   end
@@ -40,49 +54,14 @@ class Redis
   class InheritedError < BaseConnectionError
   end
 
+  # Generally raised during Redis failover scenarios
+  class ReadOnlyError < BaseConnectionError
+  end
+
   # Raised when client options are invalid.
   class InvalidClientOptionError < BaseError
   end
 
-  class Cluster
-    # Raised when client connected to redis as cluster mode
-    # and some cluster subcommands were called.
-    class OrchestrationCommandNotSupported < BaseError
-      def initialize(command, subcommand = '')
-        str = [command, subcommand].map(&:to_s).reject(&:empty?).join(' ').upcase
-        msg = "#{str} command should be used with care "\
-              'only by applications orchestrating Redis Cluster, like redis-trib, '\
-              'and the command if used out of the right context can leave the cluster '\
-              'in a wrong state or cause data loss.'
-        super(msg)
-      end
-    end
-
-    # Raised when error occurs on any node of cluster.
-    class CommandErrorCollection < BaseError
-      attr_reader :errors
-
-      # @param errors [Hash{String => Redis::CommandError}]
-      # @param error_message [String]
-      def initialize(errors, error_message = 'Command errors were replied on any node')
-        @errors = errors
-        super(error_message)
-      end
-    end
-
-    # Raised when cluster client can't select node.
-    class AmbiguousNodeError < BaseError
-      def initialize(command)
-        super("Cluster client doesn't know which node the #{command} command should be sent to.")
-      end
-    end
-
-    # Raised when commands in pipelining include cross slot keys.
-    class CrossSlotPipeliningError < BaseError
-      def initialize(keys)
-        super("Cluster client couldn't send pipelining to single node. "\
-              "The commands include cross slot keys. #{keys}")
-      end
-    end
+  class SubscriptionError < BaseError
   end
 end