redis 4.1.0 → 4.2.0

data/lib/redis/connection/synchrony.rb

@@ -1,9 +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
@@ -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
 
@@ -105,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 @@
+# 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
 
@@ -33,9 +35,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 +146,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
 
@@ -170,8 +172,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.
@@ -204,11 +231,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
 
@@ -243,8 +270,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.
@@ -263,20 +290,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
 
@@ -335,7 +362,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
 
@@ -353,7 +380,7 @@ class Redis
       get(key)
     end
 
-    def []=(key,value)
+    def []=(key, value)
       set(key, value)
     end
 
@@ -401,13 +428,12 @@ class Redis
     end
 
     def _bpop(cmd, args)
-      options = {}
-
-      if args.last.is_a?(Hash)
+      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...
-        options[:timeout] = args.pop.to_int
+        args.pop.to_int
       end
 
       if args.size > 1
@@ -417,7 +443,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
 
@@ -435,15 +465,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
 
@@ -520,13 +544,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.
@@ -581,6 +605,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)
@@ -598,14 +623,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.
@@ -625,14 +650,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.
@@ -647,16 +672,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
 
@@ -665,9 +690,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.
@@ -739,7 +764,7 @@ class Redis
     end
 
     def subscribed?
-      !! @subscribed_node
+      !!@subscribed_node
     end
 
     # Listen for messages published to the given channels.
@@ -757,7 +782,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
 
@@ -773,7 +799,7 @@ class Redis
     end
 
     # Watch the given keys to determine execution of the MULTI/EXEC block.
-    def watch(*keys)
+    def watch(*_keys)
       raise CannotDistribute, :watch
     end
 
@@ -857,7 +883,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

data/lib/redis/hash_ring.rb

@@ -1,8 +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
@@ -10,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 = []
@@ -32,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
 
@@ -46,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
 
@@ -79,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

data/lib/redis/pipeline.rb

@@ -1,15 +1,23 @@
+# frozen_string_literal: true
+
 class Redis
   class Pipeline
     attr_accessor :db
+    attr_reader :client
 
     attr :futures
 
-    def initialize
+    def initialize(client)
+      @client = client.is_a?(Pipeline) ? client.client : client
       @with_reconnect = true
       @shutdown = false
       @futures = []
     end
 
+    def timeout
+      client.timeout
+    end
+
     def with_reconnect?
       @with_reconnect
     end
@@ -26,15 +34,19 @@ class Redis
       @futures.empty?
     end
 
-    def call(command, &block)
+    def call(command, timeout: nil, &block)
       # A pipeline that contains a shutdown should not raise ECONNRESET when
       # the connection is gone.
       @shutdown = true if command.first == :shutdown
-      future = Future.new(command, block)
+      future = Future.new(command, block, timeout)
       @futures << future
       future
     end
 
+    def call_with_timeout(command, timeout, &block)
+      call(command, timeout: timeout, &block)
+    end
+
     def call_pipeline(pipeline)
       @shutdown = true if pipeline.shutdown?
       @futures.concat(pipeline.futures)
@@ -43,10 +55,14 @@ class Redis
     end
 
     def commands
-      @futures.map { |f| f._command }
+      @futures.map(&:_command)
+    end
+
+    def timeouts
+      @futures.map(&:timeout)
     end
 
-    def with_reconnect(val=true)
+    def with_reconnect(val = true)
       @with_reconnect = false unless val
       yield
     end
@@ -78,7 +94,8 @@ class Redis
 
         if exec.size < futures.size
           # Some command wasn't recognized by Redis.
-          raise replies.detect { |r| r.is_a?(CommandError) }
+          command_error = replies.detect { |r| r.is_a?(CommandError) }
+          raise command_error
         end
 
         super(exec) do |reply|
@@ -89,6 +106,14 @@ class Redis
         end
       end
 
+      def timeouts
+        if empty?
+          []
+        else
+          [nil, *super, nil]
+        end
+      end
+
       def commands
         if empty?
           []
@@ -108,12 +133,25 @@ class Redis
   class Future < BasicObject
     FutureNotReady = ::Redis::FutureNotReady.new
 
-    def initialize(command, transformation)
+    attr_reader :timeout
+
+    def initialize(command, transformation, timeout)
       @command = command
       @transformation = transformation
+      @timeout = timeout
       @object = FutureNotReady
     end
 
+    def ==(_other)
+      message = +"The methods == and != are deprecated for Redis::Future and will be removed in 4.2.0"
+      message << " - You probably meant to call .value == or .value !="
+      message << " (#{::Kernel.caller(1, 1).first})\n"
+
+      ::Kernel.warn(message)
+
+      super
+    end
+
     def inspect
       "<Redis::Future #{@command.inspect}>"
     end
@@ -128,7 +166,7 @@ class Redis
     end
 
     def value
-      ::Kernel.raise(@object) if @object.kind_of?(::RuntimeError)
+      ::Kernel.raise(@object) if @object.is_a?(::RuntimeError)
       @object
     end