redis 4.8.1 → 6.0.0

data/lib/redis/errors.rb

@@ -2,7 +2,7 @@
 
 class Redis
   # Base error for all redis-rb errors.
-  class BaseError < RuntimeError
+  class BaseError < StandardError
   end
 
   # Raised by the connection when a protocol error occurs.
@@ -20,6 +20,20 @@ class Redis
   class CommandError < BaseError
   end
 
+  class PermissionError < CommandError
+  end
+
+  class WrongTypeError < CommandError
+  end
+
+  class OutOfMemoryError < CommandError
+  end
+
+  if defined?(RedisClient::NoScriptError)
+    class NoScriptError < CommandError
+    end
+  end
+
   # Base error for connection related errors.
   class BaseConnectionError < BaseError
   end
@@ -40,58 +54,14 @@ class Redis
   class InheritedError < BaseConnectionError
   end
 
+  # Generally raised during Redis failover scenarios
+  class ReadOnlyError < BaseConnectionError
+  end
+
   # Raised when client options are invalid.
   class InvalidClientOptionError < BaseError
   end
 
-  class Cluster
-    # Raised when client connected to redis as cluster mode
-    # and failed to fetch cluster state information by commands.
-    class InitialSetupError < BaseError
-      # @param errors [Array<Redis::BaseError>]
-      def initialize(errors)
-        super("Redis client could not fetch cluster information: #{errors.map(&:message).uniq.join(',')}")
-      end
-    end
-
-    # Raised when client connected to redis as cluster mode
-    # and some cluster subcommands were called.
-    class OrchestrationCommandNotSupported < BaseError
-      def initialize(command, subcommand = '')
-        str = [command, subcommand].map(&:to_s).reject(&:empty?).join(' ').upcase
-        msg = "#{str} command should be used with care "\
-              'only by applications orchestrating Redis Cluster, like redis-trib, '\
-              'and the command if used out of the right context can leave the cluster '\
-              'in a wrong state or cause data loss.'
-        super(msg)
-      end
-    end
-
-    # Raised when error occurs on any node of cluster.
-    class CommandErrorCollection < BaseError
-      attr_reader :errors
-
-      # @param errors [Hash{String => Redis::CommandError}]
-      # @param error_message [String]
-      def initialize(errors, error_message = 'Command errors were replied on any node')
-        @errors = errors
-        super(error_message)
-      end
-    end
-
-    # Raised when cluster client can't select node.
-    class AmbiguousNodeError < BaseError
-      def initialize(command)
-        super("Cluster client doesn't know which node the #{command} command should be sent to.")
-      end
-    end
-
-    # Raised when commands in pipelining include cross slot keys.
-    class CrossSlotPipeliningError < BaseError
-      def initialize(keys)
-        super("Cluster client couldn't send pipelining to single node. "\
-              "The commands include cross slot keys. #{keys}")
-      end
-    end
+  class SubscriptionError < BaseError
   end
 end

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/lib_identity.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "redis-client"
+require "redis/version"
+
+class Redis
+  # Reports `redis-rb` as the connecting library via `CLIENT SETINFO`.
+  #
+  # `redis-client` builds its own `LIB-NAME` as `redis-client(<driver_info>)` and always
+  # reports its own version as `LIB-VER`, which would identify `redis-client` rather than
+  # `redis-rb` to the server. We append a second pair of `CLIENT SETINFO` commands, which wins
+  # because the command is last-write-wins, so that `CLIENT LIST` / `CLIENT INFO` report
+  # `lib-name=redis-rb` and `lib-ver=<Redis::VERSION>`.
+  #
+  # Libraries built on top of `redis-rb` can still identify themselves by passing `driver_info`,
+  # in which case they are reported inside the parentheses, e.g. `lib-name=redis-rb(my-gem_v1.0.0)`.
+  # The official convention for such suffixes is `<name>_v<version>` (matching
+  # `(?<custom-name>[ -~]+)[ -~]v(?<custom-version>[\d\.]+)`), with `;` delimiting multiple
+  # suffixes and parentheses avoided inside them — see
+  # https://redis.io/docs/latest/commands/client-setinfo/. Passing `driver_info: false` disables
+  # `CLIENT SETINFO` entirely, for peers that can't tolerate unknown commands during the handshake
+  # (e.g. some proxies).
+  #
+  # Applications that use `redis-client` directly are left untouched: the override only applies
+  # to configurations whose `driver_info` was built by this module.
+  module LibIdentity
+    # Follows the official suffix convention, so that the transient pair `redis-client` itself
+    # builds from this value (`lib-name=redis-client(redis-rb_v<version>)`) is well-formed too.
+    MARKER = "redis-rb_v"
+    LIB_NAME = "redis-rb"
+    SEPARATOR = ";"
+    # Interpolated strings are not frozen by the magic comment; explicit freezes keep these
+    # constants Ractor-shareable (lazy module ivars here would raise Ractor::IsolationError).
+    OWN_INFO = "#{MARKER}#{Redis::VERSION}".freeze
+    OWN_PREFIX = "#{OWN_INFO}#{SEPARATOR}".freeze
+    # `CLIENT SETINFO` values must be printable ASCII with no spaces — the server rejects anything
+    # else, and `redis-client` swallows that error, which would silently leave `lib-name` empty.
+    # Parentheses are excluded as well: they delimit the suffix in `lib-name=redis-rb(<suffix>)`,
+    # so a suffix containing them would corrupt the reported name.
+    INVALID_CHARS = /(?:[^!-~]|[()])+/
+
+    class << self
+      # Combines redis-rb's own identity with the `driver_info` a downstream library passed in,
+      # so that both can be recovered when the connection prelude is built. `false` is passed
+      # through untouched and, being falsy, turns `CLIENT SETINFO` off wholesale (`redis-client`
+      # gates its own commands on `driver_info` too). Any other non-String, non-Array value is
+      # also passed through, leaving `redis-client` to reject it.
+      def driver_info(downstream = nil)
+        case downstream
+        when nil then OWN_INFO
+        when String then combine(downstream)
+        when Array then combine(downstream.join(SEPARATOR))
+        else downstream
+        end
+      end
+
+      # True only for values `driver_info` produced: exactly our own identity, or our identity
+      # followed by a downstream library's. Matching on the bare `MARKER` prefix instead would
+      # also capture a direct `redis-client` user whose own `driver_info` merely starts with
+      # `redis-rb_v` (say `redis-rb_viewer-1.0`) and would silently discard their identity.
+      def ours?(info)
+        info.is_a?(String) && (info == OWN_INFO || info.start_with?(OWN_PREFIX))
+      end
+
+      def setinfo_commands(info)
+        [
+          ["CLIENT", "SETINFO", "LIB-NAME", lib_name(info)].freeze,
+          ["CLIENT", "SETINFO", "LIB-VER", Redis::VERSION].freeze,
+        ].freeze
+      end
+
+      private
+
+      def combine(downstream)
+        downstream = downstream.scrub(" ") # invalid byte sequences would make gsub raise
+                               .gsub(/\A#{INVALID_CHARS}|#{INVALID_CHARS}\z/o, "")
+                               .gsub(INVALID_CHARS, "_")
+        downstream.empty? ? OWN_INFO : "#{OWN_PREFIX}#{downstream}"
+      end
+
+      def lib_name(info)
+        downstream = info == OWN_INFO ? nil : info.delete_prefix(OWN_PREFIX)
+        downstream.nil? || downstream.empty? ? LIB_NAME : "#{LIB_NAME}(#{downstream})".freeze
+      end
+    end
+
+    def connection_prelude
+      prelude = super
+      info = driver_info
+      return prelude unless LibIdentity.ours?(info)
+
+      # `CLIENT SETINFO` is last-write-wins, so appending after the commands `redis-client`
+      # already built overrides them, without having to recognise or remove them.
+      (prelude + LibIdentity.setinfo_commands(info)).freeze
+    end
+  end
+end
+
+# Prepended to the concrete config classes rather than to `RedisClient::Config::Common`, so that
+# the two `redis-client` entry points are covered without altering the shared module for anything
+# else that includes it. `RedisClient::SentinelConfig` is NOT a `RedisClient::Config` subclass, so
+# both lines are required. `RedisClient::Cluster::Node::Config` does subclass `RedisClient::Config`
+# and calls `super` in its own `connection_prelude`, so cluster nodes are covered by the first.
+RedisClient::Config.prepend(Redis::LibIdentity)
+RedisClient::SentinelConfig.prepend(Redis::LibIdentity)

data/lib/redis/pipeline.rb

@@ -4,27 +4,31 @@ require "delegate"
 
 class Redis
   class PipelinedConnection
-    def initialize(pipeline)
+    attr_accessor :db
+
+    def initialize(pipeline, futures = [], exception: true)
       @pipeline = pipeline
+      @futures = futures
+      @exception = exception
     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 +38,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, @exception)
+      @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, @exception)
+      @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::BaseError, "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
-
-  class DeprecatedMulti < DelegateClass(Pipeline::Multi)
-    def initialize(pipeline)
-      super(pipeline)
-      @deprecation_displayed = false
-    end
+    private
 
-    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 +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 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
+      @exception = exception
     end
 
     def inspect
@@ -268,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
 
@@ -294,13 +114,18 @@ 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])
+      @object = if replies
+        @futures.map.with_index do |future, index|
+          future._set(replies[index])
+          future.value
+        end
+      else
+        replies
       end
-      replies
     end
   end
 end