redis 4.7.1 → 5.0.7

data/lib/redis.rb

@@ -6,26 +6,11 @@ require "redis/commands"
 
 class Redis
   BASE_PATH = __dir__
-  @exists_returns_integer = true
-
   Deprecated = Class.new(StandardError)
 
   class << self
-    attr_reader :exists_returns_integer
     attr_accessor :silence_deprecations, :raise_deprecations
 
-    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
-
     def deprecate!(message)
       unless silence_deprecations
         if raise_deprecations
@@ -35,20 +20,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
@@ -62,52 +49,45 @@ class Redis
   # @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 [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 [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
+    inherit_socket = @options.delete(:inherit_socket)
+    @subscription_client = nil
+
+    @client = initialize_client(@options)
+    @client.inherit_socket! if inherit_socket
   end
 
   # Run code without the client reconnecting
-  def without_reconnect(&blk)
-    with_reconnect(false, &blk)
+  def without_reconnect(&block)
+    @client.disable_reconnection(&block)
   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
 
@@ -115,127 +95,20 @@ 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
-  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})"
-    )
-
-    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)
-      end
-    end
-  end
-
   def _client
     @client
   end
 
-  def pipelined(&block)
-    deprecation_displayed = false
-    if block&.arity == 0
-      Pipeline.deprecation_warning("pipelined", Kernel.caller_locations(1, 5))
-      deprecation_displayed = true
-    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
-  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
-
-      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
+  def pipelined
+    synchronize do |client|
+      client.pipelined do |raw_pipeline|
+        yield PipelinedConnection.new(raw_pipeline)
       end
-    else
-      send_command([:multi])
     end
   end
 
   def id
-    @original_client.id
+    @client.id || @client.server_url
   end
 
   def inspect
@@ -247,54 +120,89 @@ class Redis
   end
 
   def connection
-    return @original_client.connection_info if @cluster_mode
-
     {
-      host: @original_client.host,
-      port: @original_client.port,
-      db: @original_client.db,
-      id: @original_client.id,
-      location: @original_client.location
+      host: @client.host,
+      port: @client.port,
+      db: @client.db,
+      id: id,
+      location: "#{@client.host}:#{@client.port}"
     }
   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)
+      if url = options.delete(:url)
+        uri = URI.parse(url)
+        if !options.key?(:name) && uri.host
+          options[:name] = uri.host
+        end
+
+        if !options.key?(:password) && uri.password && !uri.password.empty?
+          options[:password] = uri.password
+        end
+
+        if !options.key?(:username) && uri.user && !uri.user.empty?
+          options[:username] = uri.user
+        end
+      end
+
+      Client.sentinel(**options).new_client
+    else
+      Client.config(**options).new_client
+    end
+  end
+
   def synchronize
     @monitor.synchronize { yield(@client) }
   end
 
   def send_command(command, &block)
     @monitor.synchronize do
-      @client.call(command, &block)
+      @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)
+      @client.blocking_call_v(timeout, command, &block)
     end
   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
-    ensure
-      @client = original
+
+      begin
+        @subscription_client = SubscribedClient.new(@client.pubsub)
+        if timeout > 0
+          @subscription_client.send(method, timeout, *channels, &block)
+        else
+          @subscription_client.send(method, *channels, &block)
+        end
+      ensure
+        @subscription_client = nil
+      end
+    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/client"
-require "redis/cluster"
 require "redis/pipeline"
 require "redis/subscribe"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis
 version: !ruby/object:Gem::Version
-  version: 4.7.1
+  version: 5.0.7
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -16,50 +16,22 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-01 00:00:00.000000000 Z
+date: 2023-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: em-synchrony
+  name: redis-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: 0.9.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: hiredis
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: mocha
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.0
 description: |2
       A Ruby client that tries to match Redis' API one-to-one, while still
       providing an idiomatic interface.
@@ -74,16 +46,6 @@ files:
 - README.md
 - lib/redis.rb
 - lib/redis/client.rb
-- lib/redis/cluster.rb
-- lib/redis/cluster/command.rb
-- lib/redis/cluster/command_loader.rb
-- lib/redis/cluster/key_slot_converter.rb
-- lib/redis/cluster/node.rb
-- lib/redis/cluster/node_key.rb
-- lib/redis/cluster/node_loader.rb
-- lib/redis/cluster/option.rb
-- lib/redis/cluster/slot.rb
-- lib/redis/cluster/slot_loader.rb
 - lib/redis/commands.rb
 - lib/redis/commands/bitmaps.rb
 - lib/redis/commands/cluster.rb
@@ -101,12 +63,6 @@ files:
 - lib/redis/commands/streams.rb
 - lib/redis/commands/strings.rb
 - lib/redis/commands/transactions.rb
-- lib/redis/connection.rb
-- lib/redis/connection/command_helper.rb
-- lib/redis/connection/hiredis.rb
-- lib/redis/connection/registry.rb
-- lib/redis/connection/ruby.rb
-- lib/redis/connection/synchrony.rb
 - lib/redis/distributed.rb
 - lib/redis/errors.rb
 - lib/redis/hash_ring.rb
@@ -119,9 +75,9 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/redis/redis-rb/issues
   changelog_uri: https://github.com/redis/redis-rb/blob/master/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/redis/4.7.1
+  documentation_uri: https://www.rubydoc.info/gems/redis/5.0.7
   homepage_uri: https://github.com/redis/redis-rb
-  source_code_uri: https://github.com/redis/redis-rb/tree/v4.7.1
+  source_code_uri: https://github.com/redis/redis-rb/tree/v5.0.7
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -130,14 +86,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A Ruby client library for Redis

data/lib/redis/cluster/command.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../errors'
-
-class Redis
-  class Cluster
-    # Keep details about Redis commands for Redis Cluster Client.
-    # @see https://redis.io/commands/command
-    class Command
-      def initialize(details)
-        @details = pick_details(details)
-      end
-
-      def extract_first_key(command)
-        i = determine_first_key_position(command)
-        return '' if i == 0
-
-        key = command[i].to_s
-        hash_tag = extract_hash_tag(key)
-        hash_tag.empty? ? key : hash_tag
-      end
-
-      def should_send_to_master?(command)
-        dig_details(command, :write)
-      end
-
-      def should_send_to_slave?(command)
-        dig_details(command, :readonly)
-      end
-
-      private
-
-      def pick_details(details)
-        details.transform_values do |detail|
-          {
-            first_key_position: detail[:first],
-            write: detail[:flags].include?('write'),
-            readonly: detail[:flags].include?('readonly')
-          }
-        end
-      end
-
-      def dig_details(command, key)
-        name = command.first.to_s
-        return unless @details.key?(name)
-
-        @details.fetch(name).fetch(key)
-      end
-
-      def determine_first_key_position(command)
-        case command.first.to_s.downcase
-        when 'eval', 'evalsha', 'migrate', 'zinterstore', 'zunionstore' then 3
-        when 'object' then 2
-        when 'memory'
-          command[1].to_s.casecmp('usage').zero? ? 2 : 0
-        when 'xread', 'xreadgroup'
-          determine_optional_key_position(command, 'streams')
-        else
-          dig_details(command, :first_key_position).to_i
-        end
-      end
-
-      def determine_optional_key_position(command, option_name)
-        idx = command.map(&:to_s).map(&:downcase).index(option_name)
-        idx.nil? ? 0 : idx + 1
-      end
-
-      # @see https://redis.io/topics/cluster-spec#keys-hash-tags Keys hash tags
-      def extract_hash_tag(key)
-        s = key.index('{')
-        e = key.index('}', s.to_i + 1)
-
-        return '' if s.nil? || e.nil?
-
-        key[s + 1..e - 1]
-      end
-    end
-  end
-end

data/lib/redis/cluster/command_loader.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'redis/errors'
-
-class Redis
-  class Cluster
-    # Load details about Redis commands for Redis Cluster Client
-    # @see https://redis.io/commands/command
-    module CommandLoader
-      module_function
-
-      def load(nodes)
-        errors = nodes.map do |node|
-          begin
-            return fetch_command_details(node)
-          rescue CannotConnectError, ConnectionError, CommandError => error
-            error
-          end
-        end
-
-        raise InitialSetupError, errors
-      end
-
-      def fetch_command_details(node)
-        node.call(%i[command]).map do |reply|
-          [reply[0], { arity: reply[1], flags: reply[2], first: reply[3], last: reply[4], step: reply[5] }]
-        end.to_h
-      end
-
-      private_class_method :fetch_command_details
-    end
-  end
-end

data/lib/redis/cluster/key_slot_converter.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-class Redis
-  class Cluster
-    # Key to slot converter for Redis Cluster Client
-    #
-    # We can test it by `CLUSTER KEYSLOT` command.
-    #
-    # @see https://github.com/antirez/redis-rb-cluster
-    #   Reference implementation in Ruby
-    # @see https://redis.io/topics/cluster-spec#appendix
-    #   Reference implementation in ANSI C
-    # @see https://redis.io/commands/cluster-keyslot
-    #   CLUSTER KEYSLOT command reference
-    #
-    # Copyright (C) 2013 Salvatore Sanfilippo <antirez@gmail.com>
-    module KeySlotConverter
-      XMODEM_CRC16_LOOKUP = [
-        0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
-        0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
-        0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
-        0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
-        0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
-        0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
-        0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
-        0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
-        0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
-        0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
-        0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
-        0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
-        0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
-        0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
-        0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
-        0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
-        0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
-        0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
-        0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
-        0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
-        0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
-        0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
-        0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
-        0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
-        0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
-        0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
-        0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
-        0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
-        0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
-        0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
-        0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
-        0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
-      ].freeze
-
-      HASH_SLOTS = 16_384
-
-      module_function
-
-      # Convert key into slot.
-      #
-      # @param key [String] the key of the redis command
-      #
-      # @return [Integer] slot number
-      def convert(key)
-        crc = 0
-        key.each_byte do |b|
-          crc = ((crc << 8) & 0xffff) ^ XMODEM_CRC16_LOOKUP[((crc >> 8) ^ b) & 0xff]
-        end
-
-        crc % HASH_SLOTS
-      end
-    end
-  end
-end