redis 4.8.1 → 6.0.0

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).
@@ -53,13 +80,10 @@ class Redis
   end
 
   class Subscription
-    attr :callbacks
+    attr_reader :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.1'
+  VERSION = '6.0.0'
 end

data/lib/redis.rb

@@ -1,31 +1,17 @@
 # frozen_string_literal: true
 
+require "redis-client"
+
 require "monitor"
 require "redis/errors"
 require "redis/commands"
 
 class Redis
   BASE_PATH = __dir__
-  @exists_returns_integer = true
-  @sadd_returns_boolean = true
-
   Deprecated = Class.new(StandardError)
 
   class << self
-    attr_reader :exists_returns_integer
-    attr_accessor :silence_deprecations, :raise_deprecations, :sadd_returns_boolean
-
-    def exists_returns_integer=(value)
-      unless value
-        deprecate!(
-          "`Redis#exists(key)` will return an Integer by default in redis-rb 4.3. The option to explicitly " \
-          "disable this behaviour via `Redis.exists_returns_integer` will be removed in 5.0. You should use " \
-          "`exists?` instead."
-        )
-      end
-
-      @exists_returns_integer = value
-    end
+    attr_accessor :silence_deprecations, :raise_deprecations
 
     def deprecate!(message)
       unless silence_deprecations
@@ -36,20 +22,22 @@ class Redis
         end
       end
     end
+  end
 
-    def current
-      deprecate!("`Redis.current` is deprecated and will be removed in 5.0. (called from: #{caller(1, 1).first})")
-      @current ||= Redis.new
-    end
-
-    def current=(redis)
-      deprecate!("`Redis.current=` is deprecated and will be removed in 5.0. (called from: #{caller(1, 1).first})")
-      @current = redis
+  # soft-deprecated
+  # We added this back for older sidekiq releases
+  module Connection
+    class << self
+      def drivers
+        [RedisClient.default_driver]
+      end
     end
   end
 
   include Commands
 
+  SERVER_URL_OPTIONS = %i(url host port path).freeze
+
   # Create a new client instance
   #
   # @param [Hash] options
@@ -59,56 +47,68 @@ class Redis
   # @option options [String] :host ("127.0.0.1") server hostname
   # @option options [Integer] :port (6379) server port
   # @option options [String] :path path to server socket (overrides host and port)
-  # @option options [Float] :timeout (5.0) timeout in seconds
+  # @option options [Float] :timeout (1.0) timeout in seconds
   # @option options [Float] :connect_timeout (same as timeout) timeout for initial connect in seconds
   # @option options [String] :username Username to authenticate against server
   # @option options [String] :password Password to authenticate against server
-  # @option options [Integer] :db (0) Database to select after initial connect
-  # @option options [Symbol] :driver Driver to use, currently supported: `:ruby`, `:hiredis`, `:synchrony`
+  # @option options [Integer] :db (0) Database to select after connect and on reconnects
+  # @option options [Symbol] :driver Driver to use, currently supported: `:ruby`, `:hiredis`
+  # @option options [Integer] :protocol (3) RESP protocol version to negotiate (`HELLO`). Defaults
+  #   to RESP3; set to `2` for RESP2. Servers without RESP3 support automatically fall back to RESP2.
   # @option options [String] :id ID for the client connection, assigns name to current connection by sending
   #   `CLIENT SETNAME`
-  # @option options [Hash, Integer] :tcp_keepalive Keepalive values, if Integer `intvl` and `probe` are calculated
-  #   based on the value, if Hash `time`, `intvl` and `probes` can be specified as a Integer
-  # @option options [Integer] :reconnect_attempts Number of attempts trying to connect
+  # @option options [String, Array<String>, false] :driver_info Identity a library built on top of `redis-rb`
+  #   reports to the server via `CLIENT SETINFO`, shown as `lib-name=redis-rb(<driver_info>)` in `CLIENT LIST`.
+  #   The recommended format is `<name>_v<version>`; an Array is joined with `;`. Pass `false` to disable
+  #   client identification entirely.
+  # @option options [Integer, Array<Integer, Float>] :reconnect_attempts Number of attempts trying to connect,
+  #   or a list of sleep duration between attempts.
   # @option options [Boolean] :inherit_socket (false) Whether to use socket in forked process or not
+  # @option options [String] :name The name of the server group to connect to.
   # @option options [Array] :sentinels List of sentinels to contact
-  # @option options [Symbol] :role (:master) Role to fetch via Sentinel, either `:master` or `:slave`
-  # @option options [Array<String, Hash{Symbol => String, Integer}>] :cluster List of cluster nodes to contact
-  # @option options [Boolean] :replica Whether to use readonly replica nodes in Redis Cluster or not
-  # @option options [String] :fixed_hostname Specify a FQDN if cluster mode enabled and
-  #   client has to connect nodes via single endpoint with SSL/TLS
-  # @option options [Class] :connector Class of custom connector
   #
   # @return [Redis] a new client instance
   def initialize(options = {})
-    @options = options.dup
-    @cluster_mode = options.key?(:cluster)
-    client = @cluster_mode ? Cluster : Client
-    @original_client = @client = client.new(options)
-    @queue = Hash.new { |h, k| h[k] = [] }
     @monitor = Monitor.new
-  end
-
-  # Run code with the client reconnecting
-  def with_reconnect(val = true, &blk)
-    synchronize do |client|
-      client.with_reconnect(val, &blk)
+    @options = options.dup
+    @options[:reconnect_attempts] = 1 unless @options.key?(:reconnect_attempts)
+    if ENV["REDIS_URL"] && SERVER_URL_OPTIONS.none? { |o| @options.key?(o) }
+      @options[:url] = ENV["REDIS_URL"]
     end
+    # Kept as state, not just a local: the RESP3->RESP2 fallback rebuilds @client and must re-apply
+    # socket inheritance, otherwise fork safety would be silently lost after a downgrade.
+    @inherit_socket = @options.delete(:inherit_socket)
+    # HIMPORT fieldsets are server session state that dies with the physical connection; the
+    # registry remembers each prepared schema so a lost session can be repaired (see the
+    # himport_* overrides below). Deleted from @options so it never reaches RedisClient::Config.
+    @himport_auto_prepare = @options.delete(:himport_auto_prepare) != false
+    @himport_fieldsets = {}
+    @subscription_client = nil
+
+    @client = build_client
   end
 
   # Run code without the client reconnecting
-  def without_reconnect(&blk)
-    with_reconnect(false, &blk)
+  def without_reconnect(&block)
+    # Route through #synchronize like every other @client access: it holds @monitor and applies the
+    # RESP3->RESP2 fallback. disable_reconnection establishes the connection eagerly, so if that
+    # handshake fails the fallback rebuilds @client and the whole block re-runs against the new
+    # (RESP2) client — keeping disable_reconnection bound to the live @client rather than a discarded
+    # one. Referencing the block argument (not @client) is what makes the retry pick up the rebuild.
+    synchronize do |client|
+      client.disable_reconnection(&block)
+    end
   end
 
   # Test whether or not the client is connected
   def connected?
-    @original_client.connected?
+    @client.connected? || @subscription_client&.connected?
   end
 
   # Disconnect the client as quickly and silently as possible.
   def close
-    @original_client.disconnect
+    @client.close
+    @subscription_client&.close
   end
   alias disconnect! close
 
@@ -116,186 +116,211 @@ class Redis
     yield self
   end
 
-  # @deprecated Queues a command for pipelining.
-  #
-  # Commands in the queue are executed with the Redis#commit method.
-  #
-  # See http://redis.io/topics/pipelining for more details.
-  #
-  def queue(*command)
-    ::Redis.deprecate!(
-      "Redis#queue is deprecated and will be removed in Redis 5.0.0. Use Redis#pipelined instead." \
-      "(called from: #{caller(1, 1).first})"
-    )
-
-    synchronize do
-      @queue[Thread.current.object_id] << command
-    end
+  def _client
+    @client
   end
 
-  # @deprecated Sends all commands in the queue.
-  #
-  # See http://redis.io/topics/pipelining for more details.
-  #
-  def commit
-    ::Redis.deprecate!(
-      "Redis#commit is deprecated and will be removed in Redis 5.0.0. Use Redis#pipelined instead. " \
-      "(called from: #{Kernel.caller(1, 1).first})"
-    )
-
+  def pipelined(exception: true)
     synchronize do |client|
-      begin
-        pipeline = Pipeline.new(client)
-        @queue[Thread.current.object_id].each do |command|
-          pipeline.call(command)
-        end
-
-        client.call_pipelined(pipeline)
-      ensure
-        @queue.delete(Thread.current.object_id)
+      client.pipelined(exception: exception) do |raw_pipeline|
+        yield PipelinedConnection.new(raw_pipeline, exception: exception)
       end
     end
   end
 
-  def _client
-    @client
+  def id
+    @client.id || @client.server_url
   end
 
-  def pipelined(&block)
-    deprecation_displayed = false
-    if block&.arity == 0
-      Pipeline.deprecation_warning("pipelined", Kernel.caller_locations(1, 5))
-      deprecation_displayed = true
-    end
+  def inspect
+    "#<Redis client v#{Redis::VERSION} for #{id}>"
+  end
 
-    synchronize do |prior_client|
-      begin
-        pipeline = Pipeline.new(prior_client)
-        @client = deprecation_displayed ? pipeline : DeprecatedPipeline.new(pipeline)
-        pipelined_connection = PipelinedConnection.new(pipeline)
-        yield pipelined_connection
-        prior_client.call_pipeline(pipeline)
-      ensure
-        @client = prior_client
-      end
-    end
+  def dup
+    # inherit_socket and himport_auto_prepare are stripped from @options before the client config
+    # is built (RedisClient::Config doesn't know them); merge the live values back so the
+    # duplicate keeps the caller's settings instead of silently reverting to defaults.
+    self.class.new(@options.merge(inherit_socket: @inherit_socket, himport_auto_prepare: @himport_auto_prepare))
   end
 
-  # Mark the start of a transaction block.
-  #
-  # Passing a block is optional.
-  #
-  # @example With a block
-  #   redis.multi do |multi|
-  #     multi.set("key", "value")
-  #     multi.incr("counter")
-  #   end # => ["OK", 6]
-  #
-  # @example Without a block
-  #   redis.multi
-  #     # => "OK"
-  #   redis.set("key", "value")
-  #     # => "QUEUED"
-  #   redis.incr("counter")
-  #     # => "QUEUED"
-  #   redis.exec
-  #     # => ["OK", 6]
-  #
-  # @yield [multi] the commands that are called inside this block are cached
-  #   and written to the server upon returning from it
-  # @yieldparam [Redis] multi `self`
-  #
-  # @return [String, Array<...>]
-  #   - when a block is not given, `OK`
-  #   - when a block is given, an array with replies
-  #
-  # @see #watch
-  # @see #unwatch
-  def multi(&block)
-    if block_given?
-      deprecation_displayed = false
-      if block&.arity == 0
-        Pipeline.deprecation_warning("multi", Kernel.caller_locations(1, 5))
-        deprecation_displayed = true
-      end
+  def connection
+    {
+      host: @client.host,
+      port: @client.port,
+      db: @client.db,
+      id: id,
+      location: "#{@client.host}:#{@client.port}"
+    }
+  end
 
-      synchronize do |prior_client|
-        begin
-          pipeline = Pipeline::Multi.new(prior_client)
-          @client = deprecation_displayed ? pipeline : DeprecatedMulti.new(pipeline)
-          pipelined_connection = PipelinedConnection.new(pipeline)
-          yield pipelined_connection
-          prior_client.call_pipeline(pipeline)
-        ensure
-          @client = prior_client
-        end
-      end
-    else
-      send_command([:multi])
+  # HIMPORT overrides adding fieldset-loss recovery on top of the transport-pure methods in
+  # Commands::Hashes. The connection can be transparently replaced under the caller (reconnect
+  # after a network error, failover, RESET by a proxy), destroying every prepared fieldset. The
+  # server then answers HIMPORT SET with "no such fieldset" — the authoritative signal that the
+  # session was lost. These overrides remember the last schema prepared per fieldset name and,
+  # on that error, re-prepare it and retry the SET exactly once. An explicitly discarded
+  # fieldset is removed from the registry and is never resurrected. Disable the recovery with
+  # `Redis.new(himport_auto_prepare: false)`; the registry is still recorded for manual use.
+
+  # Each method holds @monitor across the server command AND its registry mutation: the two must
+  # be atomic with respect to other threads, otherwise a himport_set failing between another
+  # thread's DISCARD reply and its registry delete would still see the schema and re-prepare,
+  # resurrecting the fieldset the discard just removed. @monitor is reentrant, so the nested
+  # send_command/himport_prepare calls re-enter it safely.
+
+  def himport_prepare(fieldset_name, *fields)
+    fields.flatten!(1)
+    @monitor.synchronize do
+      reply = super(fieldset_name, fields)
+      @himport_fieldsets[fieldset_name.to_s] = fields.dup.freeze
+      reply
     end
   end
 
-  def id
-    @original_client.id
+  def himport_set(key, fieldset_name, *values)
+    @monitor.synchronize do
+      super
+    rescue CommandError => error
+      fields = @himport_fieldsets[fieldset_name.to_s]
+      raise unless @himport_auto_prepare && fields && error.message.include?("no such fieldset")
+
+      himport_prepare(fieldset_name, fields)
+      # `super` (not himport_set) so a second failure propagates instead of recovering again.
+      super
+    end
   end
 
-  def inspect
-    "#<Redis client v#{Redis::VERSION} for #{id}>"
+  def himport_discard(fieldset_name)
+    @monitor.synchronize do
+      reply = super
+      @himport_fieldsets.delete(fieldset_name.to_s)
+      reply
+    end
   end
 
-  def dup
-    self.class.new(@options)
+  def himport_discard_all
+    @monitor.synchronize do
+      reply = super
+      @himport_fieldsets.clear
+      reply
+    end
   end
 
-  def connection
-    return @original_client.connection_info if @cluster_mode
+  private
 
-    {
-      host: @original_client.host,
-      port: @original_client.port,
-      db: @original_client.db,
-      id: @original_client.id,
-      location: @original_client.location
-    }
+  # Builds @client from @options and applies any instance-level settings (socket inheritance) that
+  # live outside @options. Used both at construction and when the RESP3->RESP2 fallback rebuilds the
+  # client, so those settings survive a protocol downgrade.
+  def build_client
+    client = initialize_client(@options)
+    client.inherit_socket! if @inherit_socket
+    client
   end
 
-  private
+  def initialize_client(options)
+    if options.key?(:cluster)
+      raise "Redis Cluster support was moved to the `redis-clustering` gem."
+    end
 
+    if options.key?(:sentinels)
+      Client.sentinel(**options).new_client
+    else
+      Client.config(**options).new_client
+    end
+  end
+
+  # All access to @client funnels through here: it serializes on @monitor and applies the RESP3
+  # protocol fallback. Routing pipelined/multi/watch (which all call synchronize) through the same
+  # path means they fall back to RESP2 against pre-HELLO servers just like single commands do.
   def synchronize
-    @monitor.synchronize { yield(@client) }
+    @monitor.synchronize do
+      with_protocol_fallback do
+        yield(@client)
+      end
+    end
   end
 
   def send_command(command, &block)
-    @monitor.synchronize do
-      @client.call(command, &block)
+    synchronize do |client|
+      client.call_v(command, &block)
     end
+  rescue ::RedisClient::Error => error
+    Client.translate_error!(error)
   end
 
   def send_blocking_command(command, timeout, &block)
-    @monitor.synchronize do
-      @client.call_with_timeout(command, timeout, &block)
+    synchronize do |client|
+      client.blocking_call_v(timeout, command, &block)
+    end
+  rescue ::RedisClient::Error => error
+    Client.translate_error!(error)
+  end
+
+  # We default to RESP3. Servers that don't support it reject the `HELLO 3` handshake (most
+  # notably Redis < 6.0, which has no HELLO command). Rebuild the client as RESP2 once so those
+  # servers keep working without the user setting `protocol: 2`.
+  #
+  # This is the single fallback point for every client type. Each one surfaces the resp3-unsupported
+  # error here untranslated (still a RedisClient::Error): standalone/distributed via
+  # Redis::Client#call_v et al., sentinel via the plain RedisClient (which never translates), and
+  # cluster via Redis::Cluster::Client#handle_errors. Because every @client access — single commands,
+  # pipelined, multi, watch, and the pub/sub socket — flows through #synchronize, wrapping it here
+  # covers them all.
+  #
+  # Must be called while holding @monitor: it closes and replaces @client, so it has to be
+  # serialized with the command execution that uses @client. The retried block re-reads @client, so
+  # callers must reference the rebuilt instance (via the synchronize block argument), not a cached
+  # one.
+  def with_protocol_fallback
+    yield
+  rescue ::RedisClient::Error => error
+    if @options.fetch(:protocol, 3).to_i == 3 && Client.resp3_unsupported?(error)
+      @options = @options.merge(protocol: 2)
+      @client.close
+      @client = build_client
+      # Warn only once the RESP2 client is actually in place — if the rebuild itself raises we
+      # haven't really fallen back. Fires once per client: @options[:protocol] is now 2, so this
+      # branch never re-enters. Passing `protocol: 2` explicitly skips it (and silences this).
+      warn("Redis: the server does not support RESP3 (the HELLO 3 handshake failed); falling back " \
+           "to RESP2. Pass `protocol: 2` to select RESP2 explicitly and silence this warning.")
+      retry
     end
+
+    raise
   end
 
   def _subscription(method, timeout, channels, block)
-    return @client.call([method] + channels) if subscribed?
-
-    begin
-      original, @client = @client, SubscribedClient.new(@client)
-      if timeout > 0
-        @client.send(method, timeout, *channels, &block)
-      else
-        @client.send(method, *channels, &block)
+    if block
+      if @subscription_client
+        raise SubscriptionError, "This client is already subscribed"
+      end
+
+      begin
+        # The pub/sub second socket is opened via @client.pubsub, which connects through
+        # ensure_connected rather than a command path. Route it through #synchronize so the same
+        # RESP3->RESP2 fallback applies when subscribe is the first operation against an old server.
+        @subscription_client = SubscribedClient.new(synchronize(&:pubsub))
+        if timeout > 0
+          @subscription_client.send(method, timeout, *channels, &block)
+        else
+          @subscription_client.send(method, *channels, &block)
+        end
+      ensure
+        @subscription_client&.close
+        @subscription_client = nil
       end
-    ensure
-      @client = original
+    else
+      unless @subscription_client
+        raise SubscriptionError, "This client is not subscribed"
+      end
+
+      @subscription_client.call_v([method].concat(channels))
     end
   end
 end
 
 require "redis/version"
-require "redis/connection"
+require "redis/lib_identity"
 require "redis/client"
-require "redis/cluster"
 require "redis/pipeline"
 require "redis/subscribe"