redis 4.3.1 → 5.4.1

data/lib/redis/hash_ring.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'zlib'
+require 'digest/md5'
 
 class Redis
   class HashRing
@@ -25,7 +26,7 @@ class Redis
     def add_node(node)
       @nodes << node
       @replicas.times do |i|
-        key = Zlib.crc32("#{node.id}:#{i}")
+        key = server_hash_for("#{node.id}:#{i}")
         @ring[key] = node
         @sorted_keys << key
       end
@@ -35,7 +36,7 @@ class Redis
     def remove_node(node)
       @nodes.reject! { |n| n.id == node.id }
       @replicas.times do |i|
-        key = Zlib.crc32("#{node.id}:#{i}")
+        key = server_hash_for("#{node.id}:#{i}")
         @ring.delete(key)
         @sorted_keys.reject! { |k| k == key }
       end
@@ -43,47 +44,46 @@ class Redis
 
     # get the node in the hash ring for this key
     def get_node(key)
-      get_node_pos(key)[0]
-    end
-
-    def get_node_pos(key)
-      return [nil, nil] if @ring.empty?
-
-      crc = Zlib.crc32(key)
-      idx = HashRing.binary_search(@sorted_keys, crc)
-      [@ring[@sorted_keys[idx]], idx]
+      hash = hash_for(key)
+      idx = binary_search(@sorted_keys, hash)
+      @ring[@sorted_keys[idx]]
     end
 
     def iter_nodes(key)
       return [nil, nil] if @ring.empty?
 
-      _, pos = get_node_pos(key)
+      crc = hash_for(key)
+      pos = binary_search(@sorted_keys, crc)
       @ring.size.times do |n|
         yield @ring[@sorted_keys[(pos + n) % @ring.size]]
       end
     end
 
+    private
+
+    def hash_for(key)
+      Zlib.crc32(key)
+    end
+
+    def server_hash_for(key)
+      Digest::MD5.digest(key).unpack1("L>")
+    end
+
     # Find the closest index in HashRing with value <= the given value
-    def self.binary_search(ary, value)
-      upper = ary.size - 1
+    def binary_search(ary, value)
+      upper = ary.size
       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
+      while lower < upper
+        mid = (lower + upper) / 2
+        if ary[mid] > value
+          upper = mid
         else
-          lower = idx + 1
+          lower = mid + 1
         end
       end
 
-      upper = ary.size - 1 if upper < 0
-      upper
+      upper - 1
     end
   end
 end

data/lib/redis/pipeline.rb

@@ -1,126 +1,73 @@
 # frozen_string_literal: true
 
+require "delegate"
+
 class Redis
-  class Pipeline
+  class PipelinedConnection
     attr_accessor :db
-    attr_reader :client
-
-    attr :futures
 
-    def initialize(client)
-      @client = client.is_a?(Pipeline) ? client.client : client
-      @with_reconnect = true
-      @shutdown = false
-      @futures = []
+    def initialize(pipeline, futures = [], exception: true)
+      @pipeline = pipeline
+      @futures = futures
+      @exception = exception
     end
 
-    def timeout
-      client.timeout
-    end
+    include Commands
 
-    def with_reconnect?
-      @with_reconnect
+    def pipelined
+      yield self
     end
 
-    def without_reconnect?
-      !@with_reconnect
+    def multi
+      transaction = MultiConnection.new(@pipeline, @futures)
+      send_command([:multi])
+      size = @futures.size
+      yield transaction
+      multi_future = MultiFuture.new(@futures[size..-1])
+      @pipeline.call_v([:exec]) do |result|
+        multi_future._set(result)
+      end
+      @futures << multi_future
+      multi_future
     end
 
-    def shutdown?
-      @shutdown
-    end
+    private
 
-    def empty?
-      @futures.empty?
+    def synchronize
+      yield self
     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, timeout)
+    def send_command(command, &block)
+      future = Future.new(command, block, @exception)
+      @pipeline.call_v(command) do |result|
+        future._set(result)
+      end
       @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)
-      @db = pipeline.db
-      nil
-    end
-
-    def commands
-      @futures.map(&:_command)
-    end
-
-    def timeouts
-      @futures.map(&:timeout)
-    end
-
-    def with_reconnect(val = true)
-      @with_reconnect = false unless val
-      yield
-    end
-
-    def without_reconnect(&blk)
-      with_reconnect(false, &blk)
-    end
-
-    def finish(replies, &blk)
-      if blk
-        futures.each_with_index.map do |future, i|
-          future._set(blk.call(replies[i]))
-        end
-      else
-        futures.each_with_index.map do |future, i|
-          future._set(replies[i])
-        end
+    def send_blocking_command(command, timeout, &block)
+      future = Future.new(command, block, @exception)
+      @pipeline.blocking_call_v(timeout, command) do |result|
+        future._set(result)
       end
+      @futures << future
+      future
     end
+  end
 
-    class Multi < self
-      def finish(replies)
-        exec = replies.last
-
-        return if exec.nil? # The transaction failed because of WATCH.
-
-        # EXEC command failed.
-        raise exec if exec.is_a?(CommandError)
-
-        if exec.size < futures.size
-          # Some command wasn't recognized by Redis.
-          command_error = replies.detect { |r| r.is_a?(CommandError) }
-          raise command_error
-        end
+  class MultiConnection < PipelinedConnection
+    def multi
+      raise Redis::BaseError, "Can't nest multi transaction"
+    end
 
-        super(exec) do |reply|
-          # Because an EXEC returns nested replies, hiredis won't be able to
-          # convert an error reply to a CommandError instance itself. This is
-          # specific to MULTI/EXEC, so we solve this here.
-          reply.is_a?(::RuntimeError) ? CommandError.new(reply.message) : reply
-        end
-      end
+    private
 
-      def timeouts
-        if empty?
-          []
-        else
-          [nil, *super, nil]
-        end
-      end
-
-      def commands
-        if empty?
-          []
-        else
-          [[:multi]] + super + [[:exec]]
-        end
-      end
+    # Blocking commands inside transaction behave like non-blocking.
+    # It shouldn't be done though.
+    # https://redis.io/commands/blpop/#blpop-inside-a-multi--exec-transaction
+    def send_blocking_command(command, _timeout, &block)
+      send_command(command, &block)
     end
   end
 
@@ -133,23 +80,11 @@ class Redis
   class Future < BasicObject
     FutureNotReady = ::Redis::FutureNotReady.new
 
-    attr_reader :timeout
-
-    def initialize(command, transformation, timeout)
+    def initialize(command, coerce, exception)
       @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
+      @coerce = coerce
+      @exception = exception
     end
 
     def inspect
@@ -157,16 +92,12 @@ class Redis
     end
 
     def _set(object)
-      @object = @transformation ? @transformation.call(object) : object
+      @object = @coerce ? @coerce.call(object) : object
       value
     end
 
-    def _command
-      @command
-    end
-
     def value
-      ::Kernel.raise(@object) if @object.is_a?(::RuntimeError)
+      ::Kernel.raise(@object) if @exception && @object.is_a?(::StandardError)
       @object
     end
 
@@ -178,4 +109,23 @@ class Redis
       Future
     end
   end
+
+  class MultiFuture < Future
+    def initialize(futures)
+      @futures = futures
+      @command = [:exec]
+      @object = FutureNotReady
+    end
+
+    def _set(replies)
+      @object = if replies
+        @futures.map.with_index do |future, index|
+          future._set(replies[index])
+          future.value
+        end
+      else
+        replies
+      end
+    end
+  end
 end

data/lib/redis/subscribe.rb

@@ -4,10 +4,13 @@ class Redis
   class SubscribedClient
     def initialize(client)
       @client = client
+      @write_monitor = Monitor.new
     end
 
-    def call(command)
-      @client.process([command])
+    def call_v(command)
+      @write_monitor.synchronize do
+        @client.call_v(command)
+      end
     end
 
     def subscribe(*channels, &block)
@@ -26,12 +29,28 @@ class Redis
       subscription("psubscribe", "punsubscribe", channels, block, timeout)
     end
 
+    def ssubscribe(*channels, &block)
+      subscription("ssubscribe", "sunsubscribe", channels, block)
+    end
+
+    def ssubscribe_with_timeout(timeout, *channels, &block)
+      subscription("ssubscribe", "sunsubscribe", channels, block, timeout)
+    end
+
     def unsubscribe(*channels)
-      call([:unsubscribe, *channels])
+      call_v([:unsubscribe, *channels])
     end
 
     def punsubscribe(*channels)
-      call([:punsubscribe, *channels])
+      call_v([:punsubscribe, *channels])
+    end
+
+    def sunsubscribe(*channels)
+      call_v([:sunsubscribe, *channels])
+    end
+
+    def close
+      @client.close
     end
 
     protected
@@ -39,13 +58,21 @@ class Redis
     def subscription(start, stop, channels, block, timeout = 0)
       sub = Subscription.new(&block)
 
-      unsubscribed = false
+      case start
+      when "ssubscribe" then channels.each { |c| call_v([start, c]) } # avoid cross-slot keys
+      else call_v([start, *channels])
+      end
 
-      @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
+      while event = @client.next_event(timeout)
+        if event.is_a?(::RedisClient::CommandError)
+          raise Client::ERROR_MAPPING.fetch(event.class), event.message
+        end
+
+        type, *rest = event
+        if callback = sub.callbacks[type]
+          callback.call(*rest)
+        end
+        break if type == stop && rest.last == 0
       end
       # No need to unsubscribe here. The real client closes the connection
       # whenever an exception is raised (see #ensure_connected).
@@ -56,10 +83,7 @@ class Redis
     attr :callbacks
 
     def initialize
-      @callbacks = Hash.new do |hash, key|
-        hash[key] = ->(*_) {}
-      end
-
+      @callbacks = {}
       yield(self)
     end
 
@@ -86,5 +110,17 @@ class Redis
     def pmessage(&block)
       @callbacks["pmessage"] = block
     end
+
+    def ssubscribe(&block)
+      @callbacks["ssubscribe"] = block
+    end
+
+    def sunsubscribe(&block)
+      @callbacks["sunsubscribe"] = block
+    end
+
+    def smessage(&block)
+      @callbacks["smessage"] = block
+    end
   end
 end

data/lib/redis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Redis
-  VERSION = '4.3.1'
+  VERSION = '5.4.1'
 end