redis 3.3.5 → 4.7.0

data/lib/redis/distributed.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 require "redis/hash_ring"
 
 class Redis
   class Distributed
-
     class CannotDistribute < RuntimeError
       def initialize(command)
         @command = command
       end
 
       def message
-        "#{@command.to_s.upcase} cannot be used in Redis::Distributed because the keys involved need to be on the same server or because we cannot guarantee that the operation will be atomic."
+        "#{@command.to_s.upcase} cannot be used in Redis::Distributed because the keys involved need " \
+          "to be on the same server or because we cannot guarantee that the operation will be atomic."
       end
     end
 
@@ -22,10 +24,14 @@ class Redis
       @default_options = options.dup
       node_configs.each { |node_config| add_node(node_config) }
       @subscribed_node = nil
+      @watch_key = nil
     end
 
     def node_for(key)
-      @ring.get_node(key_tag(key.to_s) || key.to_s)
+      key = key_tag(key.to_s) || key.to_s
+      raise CannotDistribute, :watch if @watch_key && @watch_key != key
+
+      @ring.get_node(key)
     end
 
     def nodes
@@ -33,9 +39,9 @@ class Redis
     end
 
     def add_node(options)
-      options = { :url => options } if options.is_a?(String)
+      options = { url: options } if options.is_a?(String)
       options = @default_options.merge(options)
-      @ring.add_node Redis.new( options )
+      @ring.add_node Redis.new(options)
     end
 
     # Change the selected database for the current connection.
@@ -144,12 +150,12 @@ class Redis
     end
 
     # Create a key using the serialized value, previously obtained using DUMP.
-    def restore(key, ttl, serialized_value)
-      node_for(key).restore(key, ttl, serialized_value)
+    def restore(key, ttl, serialized_value, **options)
+      node_for(key).restore(key, ttl, serialized_value, **options)
     end
 
     # Transfer a key from the connected instance to another instance.
-    def migrate(key, options)
+    def migrate(_key, _options)
       raise CannotDistribute, :migrate
     end
 
@@ -161,9 +167,38 @@ class Redis
       end
     end
 
+    # Unlink keys.
+    def unlink(*args)
+      keys_per_node = args.group_by { |key| node_for(key) }
+      keys_per_node.inject(0) do |sum, (node, keys)|
+        sum + node.unlink(*keys)
+      end
+    end
+
     # Determine if a key exists.
-    def exists(key)
-      node_for(key).exists(key)
+    def exists(*args)
+      if !Redis.exists_returns_integer && args.size == 1
+        ::Redis.deprecate!(
+          "`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"
+        )
+        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
+      end
+    end
+
+    # Determine if any of the keys exists.
+    def exists?(*args)
+      keys_per_node = args.group_by { |key| node_for(key) }
+      keys_per_node.each do |node, keys|
+        return true if node.exists?(*keys)
+      end
+      false
     end
 
     # Find all keys matching the given pattern.
@@ -176,6 +211,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
@@ -196,11 +238,11 @@ class Redis
     end
 
     # Sort the elements in a list, set or sorted set.
-    def sort(key, options = {})
+    def sort(key, **options)
       keys = [key, options[:by], options[:store], *Array(options[:get])].compact
 
       ensure_same_node(:sort, keys) do |node|
-        node.sort(key, options)
+        node.sort(key, **options)
       end
     end
 
@@ -235,8 +277,8 @@ class Redis
     end
 
     # Set the string value of a key.
-    def set(key, value, options = {})
-      node_for(key).set(key, value, options)
+    def set(key, value, **options)
+      node_for(key).set(key, value, **options)
     end
 
     # Set the time to live in seconds of a key.
@@ -255,20 +297,20 @@ class Redis
     end
 
     # Set multiple keys to multiple values.
-    def mset(*args)
+    def mset(*_args)
       raise CannotDistribute, :mset
     end
 
-    def mapped_mset(hash)
+    def mapped_mset(_hash)
       raise CannotDistribute, :mapped_mset
     end
 
     # Set multiple keys to multiple values, only if none of the keys exist.
-    def msetnx(*args)
+    def msetnx(*_args)
       raise CannotDistribute, :msetnx
     end
 
-    def mapped_msetnx(hash)
+    def mapped_msetnx(_hash)
       raise CannotDistribute, :mapped_msetnx
     end
 
@@ -277,13 +319,26 @@ class Redis
       node_for(key).get(key)
     end
 
-    # Get the values of all the given keys.
+    # 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)
-      raise CannotDistribute, :mget
+      mapped_mget(*keys).values_at(*keys)
     end
 
+    # Get the values of all the given keys as a Hash.
     def mapped_mget(*keys)
-      raise CannotDistribute, :mapped_mget
+      keys.group_by { |k| node_for k }.inject({}) do |results, (node, subkeys)|
+        results.merge! node.mapped_mget(*subkeys)
+      end
     end
 
     # Overwrite part of a string at key starting at the specified offset.
@@ -324,7 +379,7 @@ class Redis
     end
 
     # Return the position of the first bit set to 1 or 0 in a string.
-    def bitpos(key, bit, start=nil, stop=nil)
+    def bitpos(key, bit, start = nil, stop = nil)
       node_for(key).bitpos(key, bit, start, stop)
     end
 
@@ -342,7 +397,7 @@ class Redis
       get(key)
     end
 
-    def []=(key,value)
+    def []=(key, value)
       set(key, value)
     end
 
@@ -351,6 +406,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)
@@ -371,14 +441,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
@@ -390,14 +460,12 @@ class Redis
     end
 
     def _bpop(cmd, args)
-      options = {}
-
-      case args.last
-      when Hash
+      timeout = if args.last.is_a?(Hash)
         options = args.pop
-      when Integer
+        options[:timeout]
+      elsif args.last.respond_to?(:to_int)
         # Issue deprecation notice in obnoxious mode...
-        options[:timeout] = args.pop
+        args.pop.to_int
       end
 
       if args.size > 1
@@ -407,7 +475,11 @@ class Redis
       keys = args.flatten
 
       ensure_same_node(cmd, keys) do |node|
-        node.__send__(cmd, keys, options)
+        if timeout
+          node.__send__(cmd, keys, timeout: timeout)
+        else
+          node.__send__(cmd, keys)
+        end
       end
     end
 
@@ -425,15 +497,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, options = {})
-      case options
-      when Integer
-        # Issue deprecation notice in obnoxious mode...
-        options = { :timeout => options }
-      end
-
+    def brpoplpush(source, destination, deprecated_timeout = 0, **options)
       ensure_same_node(:brpoplpush, [source, destination]) do |node|
-        node.brpoplpush(source, destination, options)
+        node.brpoplpush(source, destination, deprecated_timeout, **options)
       end
     end
 
@@ -504,11 +570,26 @@ 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)
     end
 
+    # Scan a set
+    def sscan(key, cursor, **options)
+      node_for(key).sscan(key, cursor, **options)
+    end
+
+    # Scan a set and return an enumerator
+    def sscan_each(key, **options, &block)
+      node_for(key).sscan_each(key, **options, &block)
+    end
+
     # Subtract multiple sets.
     def sdiff(*keys)
       ensure_same_node(:sdiff, keys) do |node|
@@ -561,6 +642,7 @@ class Redis
     def zadd(key, *args)
       node_for(key).zadd(key, *args)
     end
+    ruby2_keywords(:zadd) if respond_to?(:ruby2_keywords, true)
 
     # Increment the score of a member in a sorted set.
     def zincrby(key, increment, member)
@@ -577,15 +659,33 @@ class Redis
       node_for(key).zscore(key, member)
     end
 
-    # Return a range of members in a sorted set, by index.
-    def zrange(key, start, stop, options = {})
-      node_for(key).zrange(key, start, stop, options)
+    # 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
+
+    # 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 = {})
-      node_for(key).zrevrange(key, start, stop, options)
+    def zrevrange(key, start, stop, **options)
+      node_for(key).zrevrange(key, start, stop, **options)
     end
 
     # Determine the index of a member in a sorted set.
@@ -605,14 +705,14 @@ class Redis
     end
 
     # Return a range of members in a sorted set, by score.
-    def zrangebyscore(key, min, max, options = {})
-      node_for(key).zrangebyscore(key, min, max, options)
+    def zrangebyscore(key, min, max, **options)
+      node_for(key).zrangebyscore(key, min, max, **options)
     end
 
     # Return a range of members in a sorted set, by score, with scores ordered
     # from high to low.
-    def zrevrangebyscore(key, max, min, options = {})
-      node_for(key).zrevrangebyscore(key, max, min, options)
+    def zrevrangebyscore(key, max, min, **options)
+      node_for(key).zrevrangebyscore(key, max, min, **options)
     end
 
     # Remove all members in a sorted set within the given scores.
@@ -625,18 +725,47 @@ 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 = {})
+    def zinterstore(destination, keys, **options)
       ensure_same_node(:zinterstore, [destination] + keys) do |node|
-        node.zinterstore(destination, keys, options)
+        node.zinterstore(destination, keys, **options)
+      end
+    end
+
+    # Return the union of multiple sorted sets.
+    def zunion(*keys, **options)
+      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 = {})
+    def zunionstore(destination, keys, **options)
       ensure_same_node(:zunionstore, [destination] + keys) do |node|
-        node.zunionstore(destination, keys, options)
+        node.zunionstore(destination, keys, **options)
+      end
+    end
+
+    # Return the difference between the first and all successive input sorted sets.
+    def zdiff(*keys, **options)
+      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)
+      ensure_same_node(:zdiffstore, [destination] + keys) do |node|
+        node.zdiffstore(destination, keys, **options)
       end
     end
 
@@ -645,9 +774,9 @@ class Redis
       node_for(key).hlen(key)
     end
 
-    # Set the string value of a hash field.
-    def hset(key, field, value)
-      node_for(key).hset(key, field, value)
+    # Set multiple hash fields to multiple values.
+    def hset(key, *attrs)
+      node_for(key).hset(key, *attrs)
     end
 
     # Set the value of a hash field, only if the field does not exist.
@@ -678,9 +807,13 @@ class Redis
       Hash[*fields.zip(hmget(key, *fields)).flatten]
     end
 
+    def hrandfield(key, count = nil, **options)
+      node_for(key).hrandfield(key, count, **options)
+    end
+
     # Delete one or more hash fields.
-    def hdel(key, field)
-      node_for(key).hdel(key, field)
+    def hdel(key, *fields)
+      node_for(key).hdel(key, *fields)
     end
 
     # Determine if a hash field exists.
@@ -719,7 +852,7 @@ class Redis
     end
 
     def subscribed?
-      !! @subscribed_node
+      !!@subscribed_node
     end
 
     # Listen for messages published to the given channels.
@@ -737,7 +870,8 @@ class Redis
 
     # Stop listening for messages posted to the given channels.
     def unsubscribe(*channels)
-      raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
+      raise "Can't unsubscribe if not subscribed." unless subscribed?
+
       @subscribed_node.unsubscribe(*channels)
     end
 
@@ -753,13 +887,26 @@ class Redis
     end
 
     # Watch the given keys to determine execution of the MULTI/EXEC block.
-    def watch(*keys)
-      raise CannotDistribute, :watch
+    def watch(*keys, &block)
+      ensure_same_node(:watch, keys) do |node|
+        @watch_key = key_tag(keys.first) || keys.first.to_s
+
+        begin
+          node.watch(*keys, &block)
+        rescue StandardError
+          @watch_key = nil
+          raise
+        end
+      end
     end
 
     # Forget about all watched keys.
     def unwatch
-      raise CannotDistribute, :unwatch
+      raise CannotDistribute, :unwatch unless @watch_key
+
+      result = node_for(@watch_key).unwatch
+      @watch_key = nil
+      result
     end
 
     def pipelined
@@ -767,18 +914,30 @@ class Redis
     end
 
     # Mark the start of a transaction block.
-    def multi
-      raise CannotDistribute, :multi
+    def multi(&block)
+      raise CannotDistribute, :multi unless @watch_key
+
+      result = node_for(@watch_key).multi(&block)
+      @watch_key = nil if block_given?
+      result
     end
 
     # Execute all commands issued after MULTI.
     def exec
-      raise CannotDistribute, :exec
+      raise CannotDistribute, :exec unless @watch_key
+
+      result = node_for(@watch_key).exec
+      @watch_key = nil
+      result
     end
 
     # Discard all commands issued after MULTI.
     def discard
-      raise CannotDistribute, :discard
+      raise CannotDistribute, :discard unless @watch_key
+
+      result = node_for(@watch_key).discard
+      @watch_key = nil
+      result
     end
 
     # Control remote script registry.
@@ -837,7 +996,7 @@ class Redis
       self.class.new(@node_configs, @default_options)
     end
 
-  protected
+    protected
 
     def on_each_node(command, *args)
       nodes.map do |node|

data/lib/redis/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Redis
   # Base error for all redis-rb errors.
   class BaseError < RuntimeError
@@ -37,4 +39,59 @@ class Redis
   # Raised when the connection was inherited by a child process.
   class InheritedError < BaseConnectionError
   end
+
+  # Raised when client options are invalid.
+  class InvalidClientOptionError < BaseError
+  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
+      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
+  end
 end