redis 4.4.0 → 4.8.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
@@ -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.
@@ -178,15 +178,11 @@ 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, " \
+        ::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"
-
-        if defined?(::Warning)
-          ::Warning.warn(message)
-        else
-          warn(message)
-        end
+        )
         exists?(*args)
       else
         keys_per_node = args.group_by { |key| node_for(key) }
@@ -215,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
@@ -316,6 +319,16 @@ 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)
       mapped_mget(*keys).values_at(*keys)
@@ -393,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)
@@ -436,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
@@ -515,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)
@@ -542,6 +581,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)
@@ -626,11 +670,29 @@ 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
+
+    # 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)
@@ -689,6 +751,13 @@ class Redis
       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)
       ensure_same_node(:zunionstore, [destination] + keys) do |node|
@@ -696,6 +765,21 @@ class Redis
       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
+
     # Get the number of fields in a hash.
     def hlen(key)
       node_for(key).hlen(key)
@@ -734,6 +818,10 @@ 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, *fields)
       node_for(key).hdel(key, *fields)

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

@@ -1,11 +1,80 @@
 # frozen_string_literal: true
 
+require "delegate"
+
 class Redis
+  class PipelinedConnection
+    def initialize(pipeline)
+      @pipeline = pipeline
+    end
+
+    include Commands
+
+    def db
+      @pipeline.db
+    end
+
+    def db=(db)
+      @pipeline.db = db
+    end
+
+    def pipelined
+      yield self
+    end
+
+    def call_pipeline(pipeline)
+      @pipeline.call_pipeline(pipeline)
+      nil
+    end
+
+    private
+
+    def synchronize
+      yield self
+    end
+
+    def send_command(command, &block)
+      @pipeline.call(command, &block)
+    end
+
+    def send_blocking_command(command, timeout, &block)
+      @pipeline.call_with_timeout(command, timeout, &block)
+    end
+  end
+
   class Pipeline
+    REDIS_INTERNAL_PATH = File.expand_path("..", __dir__).freeze
+    # Redis use MonitorMixin#synchronize and this class use DelegateClass which we want to filter out.
+    # Both are in the stdlib so we can simply filter the entire stdlib out.
+    STDLIB_PATH = File.expand_path("..", MonitorMixin.instance_method(:synchronize).source_location.first).freeze
+
+    class << self
+      def deprecation_warning(method, caller_locations) # :nodoc:
+        callsite = caller_locations.find { |l| !l.path.start_with?(REDIS_INTERNAL_PATH, STDLIB_PATH) }
+        callsite ||= caller_locations.last # The caller_locations should be large enough, but just in case.
+        ::Redis.deprecate! <<~MESSAGE
+          Pipelining commands on a Redis instance is deprecated and will be removed in Redis 5.0.0.
+
+          redis.#{method} do
+            redis.get("key")
+          end
+
+          should be replaced by
+
+          redis.#{method} do |pipeline|
+            pipeline.get("key")
+          end
+
+          (called from #{callsite}}
+        MESSAGE
+      end
+    end
+
     attr_accessor :db
     attr_reader :client
 
     attr :futures
+    alias materialized_futures futures
 
     def initialize(client)
       @client = client.is_a?(Pipeline) ? client.client : client
@@ -49,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
@@ -106,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?
           []
@@ -124,6 +205,36 @@ class Redis
     end
   end
 
+  class DeprecatedPipeline < DelegateClass(Pipeline)
+    def initialize(pipeline)
+      super(pipeline)
+      @deprecation_displayed = false
+    end
+
+    def __getobj__
+      unless @deprecation_displayed
+        Pipeline.deprecation_warning("pipelined", Kernel.caller_locations(1, 10))
+        @deprecation_displayed = true
+      end
+      @delegate_dc_obj
+    end
+  end
+
+  class DeprecatedMulti < DelegateClass(Pipeline::Multi)
+    def initialize(pipeline)
+      super(pipeline)
+      @deprecation_displayed = false
+    end
+
+    def __getobj__
+      unless @deprecation_displayed
+        Pipeline.deprecation_warning("multi", Kernel.caller_locations(1, 10))
+        @deprecation_displayed = true
+      end
+      @delegate_dc_obj
+    end
+  end
+
   class FutureNotReady < RuntimeError
     def initialize
       super("Value will be available once the pipeline executes.")
@@ -143,11 +254,11 @@ class Redis
     end
 
     def ==(_other)
-      message = +"The methods == and != are deprecated for Redis::Future and will be removed in 4.2.0"
+      message = +"The methods == and != are deprecated for Redis::Future and will be removed in 5.0.0"
       message << " - You probably meant to call .value == or .value !="
       message << " (#{::Kernel.caller(1, 1).first})\n"
 
-      ::Kernel.warn(message)
+      ::Redis.deprecate!(message)
 
       super
     end
@@ -178,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.4.0'
+  VERSION = '4.8.1'
 end