redis 3.3.5 → 4.3.1

data/lib/redis/connection/synchrony.rb

@@ -1,9 +1,16 @@
-require "redis/connection/command_helper"
-require "redis/connection/registry"
-require "redis/errors"
+# frozen_string_literal: true
+
+require_relative "command_helper"
+require_relative "registry"
+require_relative "../errors"
 require "em-synchrony"
 require "hiredis/reader"
 
+Kernel.warn(
+  "The redis synchrony driver is deprecated and will be removed in redis-rb 5.0. " \
+  "We're looking for people to maintain it as a separate gem, see https://github.com/redis/redis-rb/issues/915"
+)
+
 class Redis
   module Connection
     class RedisClient < EventMachine::Connection
@@ -46,9 +53,7 @@ class Redis
 
       def read
         @req = EventMachine::DefaultDeferrable.new
-        if @timeout > 0
-          @req.timeout(@timeout, :timeout)
-        end
+        @req.timeout(@timeout, :timeout) if @timeout > 0
         EventMachine::Synchrony.sync @req
       end
 
@@ -72,7 +77,15 @@ class Redis
 
       def self.connect(config)
         if config[:scheme] == "unix"
-          conn = EventMachine.connect_unix_domain(config[:path], RedisClient)
+          begin
+            conn = EventMachine.connect_unix_domain(config[:path], RedisClient)
+          rescue RuntimeError => e
+            if e.message == "no connection"
+              raise Errno::ECONNREFUSED
+            else
+              raise e
+            end
+          end
         elsif config[:scheme] == "rediss" || config[:ssl]
           raise NotImplementedError, "SSL not supported by synchrony driver"
         else
@@ -97,7 +110,7 @@ class Redis
       end
 
       def connected?
-        @connection && @connection.connected?
+        @connection&.connected?
       end
 
       def timeout=(timeout)

data/lib/redis/distributed.rb

@@ -1,15 +1,17 @@
-require "redis/hash_ring"
+# frozen_string_literal: true
+
+require_relative "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,42 @@ 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
+        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
+      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.
@@ -196,11 +235,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 +274,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 +294,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 +316,16 @@ class Redis
       node_for(key).get(key)
     end
 
-    # Get the values of all the given keys.
+    # 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 +366,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 +384,7 @@ class Redis
       get(key)
     end
 
-    def []=(key,value)
+    def []=(key, value)
       set(key, value)
     end
 
@@ -371,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
@@ -390,14 +432,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 +447,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 +469,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
 
@@ -509,6 +547,16 @@ class Redis
       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 +609,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)
@@ -578,14 +627,14 @@ class Redis
     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)
+    def zrange(key, start, stop, **options)
+      node_for(key).zrange(key, start, stop, **options)
     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 +654,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.
@@ -627,16 +676,16 @@ class Redis
 
     # 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
 
     # 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
 
@@ -645,9 +694,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.
@@ -679,8 +728,8 @@ class Redis
     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 +768,7 @@ class Redis
     end
 
     def subscribed?
-      !! @subscribed_node
+      !!@subscribed_node
     end
 
     # Listen for messages published to the given channels.
@@ -737,7 +786,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 +803,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 +830,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 +912,7 @@ class Redis
       self.class.new(@node_configs, @default_options)
     end
 
-  protected
+    protected
 
     def on_each_node(command, *args)
       nodes.map do |node|