redis 3.3.5 → 4.8.0

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 = []
@@ -25,7 +26,6 @@ class Redis
       @nodes << node
       @replicas.times do |i|
         key = Zlib.crc32("#{node.id}:#{i}")
-        raise "Node ID collision" if @ring.has_key?(key)
         @ring[key] = node
         @sorted_keys << key
       end
@@ -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,86 +47,43 @@ 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
 
-    class << self
-
-      # gem install RubyInline to use this code
-      # Native extension to perform the binary search within the hashring.
-      # There's a pure ruby version below so this is purely optional
-      # for performance.  In testing 20k gets and sets, the native
-      # binary search shaved about 12% off the runtime (9sec -> 8sec).
-      begin
-        require 'inline'
-        inline do |builder|
-          builder.c <<-EOM
-          int binary_search(VALUE ary, unsigned int r) {
-              int upper = RARRAY_LEN(ary) - 1;
-              int lower = 0;
-              int idx = 0;
-
-              while (lower <= upper) {
-                  idx = (lower + upper) / 2;
-
-                  VALUE continuumValue = RARRAY_PTR(ary)[idx];
-                  unsigned int l = NUM2UINT(continuumValue);
-                  if (l == r) {
-                      return idx;
-                  }
-                  else if (l > r) {
-                      upper = idx - 1;
-                  }
-                  else {
-                      lower = idx + 1;
-                  }
-              }
-              if (upper < 0) {
-                upper = RARRAY_LEN(ary) - 1;
-              }
-              return upper;
-          }
-          EOM
+    # Find the closest index in HashRing with value <= the given value
+    def self.binary_search(ary, value)
+      upper = ary.size - 1
+      lower = 0
+      idx = 0
+
+      while lower <= upper
+        idx = (lower + upper) / 2
+        comp = ary[idx] <=> value
+
+        if comp == 0
+          return idx
+        elsif comp > 0
+          upper = idx - 1
+        else
+          lower = idx + 1
         end
-      rescue Exception
-        # Find the closest index in HashRing with value <= the given value
-        def binary_search(ary, value, &block)
-          upper = ary.size - 1
-          lower = 0
-          idx = 0
-
-          while(lower <= upper) do
-            idx = (lower + upper) / 2
-            comp = ary[idx] <=> value
-
-            if comp == 0
-              return idx
-            elsif comp > 0
-              upper = idx - 1
-            else
-              lower = idx + 1
-            end
-          end
-
-          if upper < 0
-            upper = ary.size - 1
-          end
-          return upper
-        end
-
       end
-    end
 
+      upper = ary.size - 1 if upper < 0
+      upper
+    end
   end
 end

data/lib/redis/pipeline.rb

@@ -1,21 +1,92 @@
+# frozen_string_literal: true
+
+require "delegate"
+
 class Redis
-  unless defined?(::BasicObject)
-    class BasicObject
-      instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A(__|instance_eval)/ }
+  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
+    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
@@ -28,27 +99,39 @@ class Redis
       @shutdown
     end
 
-    def call(command, &block)
+    def empty?
+      @futures.empty?
+    end
+
+    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)
+      @futures.concat(pipeline.materialized_futures)
       @db = pipeline.db
       nil
     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
@@ -80,7 +163,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|
@@ -91,9 +175,63 @@ 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?
+          []
+        else
+          [nil, *super, nil]
+        end
+      end
+
       def commands
-        [[:multi]] + super + [[:exec]]
+        if empty?
+          []
+        else
+          [[:multi]] + super + [[:exec]]
+        end
+      end
+    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
 
@@ -106,12 +244,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 5.0.0"
+      message << " - You probably meant to call .value == or .value !="
+      message << " (#{::Kernel.caller(1, 1).first})\n"
+
+      ::Redis.deprecate!(message)
+
+      super
+    end
+
     def inspect
       "<Redis::Future #{@command.inspect}>"
     end
@@ -126,7 +277,7 @@ class Redis
     end
 
     def value
-      ::Kernel.raise(@object) if @object.kind_of?(::RuntimeError)
+      ::Kernel.raise(@object) if @object.is_a?(::RuntimeError)
       @object
     end
 
@@ -138,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/subscribe.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Redis
   class SubscribedClient
     def initialize(client)
@@ -32,24 +34,21 @@ class Redis
       call([:punsubscribe, *channels])
     end
 
-  protected
+    protected
 
     def subscription(start, stop, channels, block, timeout = 0)
       sub = Subscription.new(&block)
 
       unsubscribed = false
 
-      begin
-        @client.call_loop([start, *channels], timeout) do |line|
-          type, *rest = line
-          sub.callbacks[type].call(*rest)
-          unsubscribed = type == stop && rest.last == 0
-          break if unsubscribed
-        end
-      ensure
-        # No need to unsubscribe here. The real client closes the connection
-        # whenever an exception is raised (see #ensure_connected).
+      @client.call_loop([start, *channels], timeout) do |line|
+        type, *rest = line
+        sub.callbacks[type].call(*rest)
+        unsubscribed = type == stop && rest.last == 0
+        break if unsubscribed
       end
+      # No need to unsubscribe here. The real client closes the connection
+      # whenever an exception is raised (see #ensure_connected).
     end
   end
 
@@ -58,7 +57,7 @@ class Redis
 
     def initialize
       @callbacks = Hash.new do |hash, key|
-        hash[key] = lambda { |*_| }
+        hash[key] = ->(*_) {}
       end
 
       yield(self)

data/lib/redis/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Redis
-  VERSION = "3.3.5"
+  VERSION = '4.8.0'
 end