redis 4.1.4 → 4.4.0

data/lib/redis/connection/synchrony.rb

@@ -1,10 +1,16 @@
 # 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
@@ -47,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
 
@@ -106,7 +110,7 @@ class Redis
       end
 
       def connected?
-        @connection && @connection.connected?
+        @connection&.connected?
       end
 
       def timeout=(timeout)

data/lib/redis/distributed.rb

@@ -1,16 +1,17 @@
 # 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
 
@@ -23,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
@@ -34,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.
@@ -145,12 +150,12 @@ class Redis
     end
 
     # Create a key using the serialized value, previously obtained using DUMP.
-    def restore(key, ttl, serialized_value, options = {})
-      node_for(key).restore(key, ttl, serialized_value, options)
+    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
 
@@ -171,8 +176,33 @@ class Redis
     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.
@@ -205,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
 
@@ -244,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.
@@ -264,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
 
@@ -336,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
 
@@ -354,7 +384,7 @@ class Redis
       get(key)
     end
 
-    def []=(key,value)
+    def []=(key, value)
       set(key, value)
     end
 
@@ -383,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
@@ -439,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
 
@@ -524,13 +548,13 @@ class Redis
     end
 
     # Scan a set
-    def sscan(key, cursor, options={})
-      node_for(key).sscan(key, cursor, options)
+    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)
+    def sscan_each(key, **options, &block)
+      node_for(key).sscan_each(key, **options, &block)
     end
 
     # Subtract multiple sets.
@@ -585,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)
@@ -602,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.
@@ -629,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.
@@ -649,18 +674,25 @@ 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
 
     # 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
 
@@ -669,9 +701,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.
@@ -743,7 +775,7 @@ class Redis
     end
 
     def subscribed?
-      !! @subscribed_node
+      !!@subscribed_node
     end
 
     # Listen for messages published to the given channels.
@@ -761,7 +793,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
 
@@ -777,13 +810,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
@@ -791,18 +837,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.
@@ -861,7 +919,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,4 +1,5 @@
 # frozen_string_literal: true
+
 class Redis
   # Base error for all redis-rb errors.
   class BaseError < RuntimeError

data/lib/redis/hash_ring.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
+
 require 'zlib'
 
 class Redis
   class HashRing
-
     POINTS_PER_SERVER = 160 # this is the default in libmemcached
 
     attr_reader :ring, :sorted_keys, :replicas, :nodes
@@ -11,7 +11,7 @@ class Redis
     # nodes is a list of objects that have a proper to_s representation.
     # replicas indicates how many virtual points should be used pr. node,
     # replicas are required to improve the distribution.
-    def initialize(nodes=[], replicas=POINTS_PER_SERVER)
+    def initialize(nodes = [], replicas = POINTS_PER_SERVER)
       @replicas = replicas
       @ring = {}
       @nodes = []
@@ -33,11 +33,11 @@ class Redis
     end
 
     def remove_node(node)
-      @nodes.reject!{|n| n.id == node.id}
+      @nodes.reject! { |n| n.id == node.id }
       @replicas.times do |i|
         key = Zlib.crc32("#{node.id}:#{i}")
         @ring.delete(key)
-        @sorted_keys.reject! {|k| k == key}
+        @sorted_keys.reject! { |k| k == key }
       end
     end
 
@@ -47,27 +47,29 @@ class Redis
     end
 
     def get_node_pos(key)
-      return [nil,nil] if @ring.size == 0
+      return [nil, nil] if @ring.empty?
+
       crc = Zlib.crc32(key)
       idx = HashRing.binary_search(@sorted_keys, crc)
-      return [@ring[@sorted_keys[idx]], idx]
+      [@ring[@sorted_keys[idx]], idx]
     end
 
     def iter_nodes(key)
-      return [nil,nil] if @ring.size == 0
+      return [nil, nil] if @ring.empty?
+
       _, pos = get_node_pos(key)
       @ring.size.times do |n|
-        yield @ring[@sorted_keys[(pos+n) % @ring.size]]
+        yield @ring[@sorted_keys[(pos + n) % @ring.size]]
       end
     end
 
     # Find the closest index in HashRing with value <= the given value
-    def self.binary_search(ary, value, &block)
+    def self.binary_search(ary, value)
       upper = ary.size - 1
       lower = 0
       idx = 0
 
-      while(lower <= upper) do
+      while lower <= upper
         idx = (lower + upper) / 2
         comp = ary[idx] <=> value
 
@@ -80,10 +82,8 @@ class Redis
         end
       end
 
-      if upper < 0
-        upper = ary.size - 1
-      end
-      return upper
+      upper = ary.size - 1 if upper < 0
+      upper
     end
   end
 end