redis 4.8.0 → 5.0.8

data/lib/redis/pipeline.rb

@@ -4,27 +4,30 @@ require "delegate"
 
 class Redis
   class PipelinedConnection
-    def initialize(pipeline)
+    attr_accessor :db
+
+    def initialize(pipeline, futures = [])
       @pipeline = pipeline
+      @futures = futures
     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
+    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
 
     private
@@ -34,204 +37,36 @@ class Redis
     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
+      future = Future.new(command, block)
+      @pipeline.call_v(command) do |result|
+        future._set(result)
       end
-    end
-
-    attr_accessor :db
-    attr_reader :client
-
-    attr :futures
-    alias materialized_futures futures
-
-    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
-
-    def without_reconnect?
-      !@with_reconnect
-    end
-
-    def shutdown?
-      @shutdown
-    end
-
-    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, 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.materialized_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
-      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
-
-        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
-
-      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
-        if empty?
-          []
-        else
-          [[:multi]] + super + [[:exec]]
-        end
+    def send_blocking_command(command, timeout, &block)
+      future = Future.new(command, block)
+      @pipeline.blocking_call_v(timeout, command) do |result|
+        future._set(result)
       end
+      @futures << future
+      future
     end
   end
 
-  class DeprecatedPipeline < DelegateClass(Pipeline)
-    def initialize(pipeline)
-      super(pipeline)
-      @deprecation_displayed = false
+  class MultiConnection < PipelinedConnection
+    def multi
+      raise Redis::Error, "Can't nest multi transaction"
     end
 
-    def __getobj__
-      unless @deprecation_displayed
-        Pipeline.deprecation_warning("pipelined", Kernel.caller_locations(1, 10))
-        @deprecation_displayed = true
-      end
-      @delegate_dc_obj
-    end
-  end
+    private
 
-  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
+    # 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
 
@@ -244,23 +79,10 @@ class Redis
   class Future < BasicObject
     FutureNotReady = ::Redis::FutureNotReady.new
 
-    attr_reader :timeout
-
-    def initialize(command, transformation, timeout)
+    def initialize(command, coerce)
       @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
+      @coerce = coerce
     end
 
     def inspect
@@ -268,16 +90,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 @object.is_a?(::StandardError)
       @object
     end
 
@@ -294,13 +112,16 @@ class Redis
     def initialize(futures)
       @futures = futures
       @command = [:exec]
+      @object = FutureNotReady
     end
 
     def _set(replies)
-      @futures.each_with_index do |future, index|
-        future._set(replies[index])
+      if replies
+        @futures.each_with_index do |future, index|
+          future._set(replies[index])
+        end
       end
-      replies
+      @object = replies
     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.8.0'
+  VERSION = '5.0.8'
 end