redis-client 0.11.1 → 0.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ded07d814692a3e286f61a38a3d8129ef35189659124e73fd3e24e4e53a6a08b
-  data.tar.gz: 021c3dc9bf79717313a9f41e6bc29973cafbfe08ba15b2eb2b8560228939752b
+  metadata.gz: e9858303eff06d56f8e144eb7033995fc92839c41fe39d0bda6f1d9c2fed91e9
+  data.tar.gz: a4f4ca2073a32e28932c58e537963a2f0b2321e36ca472c6edc9edab1b29122b
 SHA512:
-  metadata.gz: 52ebda137196361b56487d014cdbf5f188cd8822d92f955aeb39ee9fdea448051e38be2e68bf60616cdbeec1df942c25472a5d71e6b6c139ef96b1286db94d32
-  data.tar.gz: 495caeef04270d289eb58a5a1f0f52f19414db8d3efa0554edea041d165a3e14a33337156fa28c55c56fbee29b5683347d871fb7f84f79fea02371d1e0f605ce
+  metadata.gz: 3c20b17e4587980ed89e0877b20cb9aee7d16365401127cfdc3b4f451f7706bf338988e97ac9d1e62d33c9af5b45ebfb3c35310205fbd309995ace46c3b85fce
+  data.tar.gz: 21ed1731b716f1bd6e525b638b7715683979860faa0d14f2fc6f210c4d185a95d2329650b56cf731734d22d7008cdadccc2055a8d5ff7a332b043836e0d39b75

data/CHANGELOG.md

@@ -1,6 +1,44 @@
 # Unreleased
 
-- hiredis: Workaround a compilation bug with Xcode 14.0, Fix: #58
+# 0.14.1
+
+- Include the timeout value in TimeoutError messages.
+- Fix connection keep-alive on FreeBSD. #102.
+
+# 0.14.0
+
+- Implement Sentinels list automatic refresh.
+- hiredis binding now implement GC compaction and write barriers.
+- hiredis binding now properly release the GVL around `connect(2)`.
+- hiredis the client memory is now re-used on reconnection when possible to reduce allocation churn.
+
+# 0.13.0
+
+- Enable TCP keepalive on redis sockets. It sends a keep alive probe every 15 seconds for 2 minutes. #94.
+
+# 0.12.2
+
+- Cache calls to `Process.pid` on Ruby 3.1+. #91.
+
+# 0.12.1
+
+- Improve compatibility with `uri 0.12.0` (default in Ruby 3.2.0).
+
+# 0.12.0
+
+- hiredis: fix a compilation issue on macOS and Ruby 3.2.0. See: #79
+- Close connection on MASTERDOWN errors. Similar to READONLY.
+- Add a `circuit_breaker` configuration option for cache servers and other disposable Redis servers. See #55 / #70
+
+# 0.11.2
+
+- Close connection on READONLY errors. Fix: #64
+- Handle Redis 6+ servers with a missing HELLO command. See: #67
+- Validate `url` parameters a bit more strictly. Fix #61
+
+# 0.11.1
+
+- hiredis: Workaround a compilation bug with Xcode 14.0. Fix: #58
 - Accept `URI` instances as `uri` parameter.
 
 # 0.11.0

data/Gemfile.lock

@@ -1,16 +1,16 @@
 PATH
   remote: .
   specs:
-    redis-client (0.11.1)
+    redis-client (0.14.1)
       connection_pool
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
-    benchmark-ips (2.10.0)
+    benchmark-ips (2.12.0)
     byebug (11.1.3)
-    connection_pool (2.3.0)
+    connection_pool (2.4.0)
     hiredis (0.6.3)
     hiredis (0.6.3-java)
     minitest (5.15.0)
@@ -19,7 +19,7 @@ GEM
       ast (~> 2.4.1)
     rainbow (3.1.1)
     rake (13.0.6)
-    rake-compiler (1.2.0)
+    rake-compiler (1.2.1)
       rake
     redis (4.6.0)
     regexp_parser (2.5.0)
@@ -38,7 +38,7 @@ GEM
     rubocop-minitest (0.19.1)
       rubocop (>= 0.90, < 2.0)
     ruby-progressbar (1.11.0)
-    stackprof (0.2.22)
+    stackprof (0.2.24)
     toxiproxy (2.0.2)
     unicode-display_width (2.2.0)
 

data/README.md

@@ -63,7 +63,7 @@ redis.call("GET", "mykey")
 ### Configuration
 
 - `url`: A Redis connection URL, e.g. `redis://example.com:6379/5`, a `rediss://` scheme enable SSL, and the path is interpreted as a database number.
-  Note that all other configurations take precedence, e.g. `RedisClient.config(url: "redis://localhost:3000" port: 6380)` will connect on port `6380`.
+  Note that all other configurations take precedence, e.g. `RedisClient.config(url: "redis://localhost:3000", port: 6380)` will connect on port `6380`.
 - `host`: The server hostname or IP address. Defaults to `"localhost"`.
 - `port`: The server port. Defaults to `6379`.
 - `path`: The path to a UNIX socket, if set `url`, `host` and `port` are ignored.
@@ -81,6 +81,7 @@ redis.call("GET", "mykey")
 - `read_timeout`: The read timeout, takes precedence over the general timeout when reading responses from the server.
 - `write_timeout`: The write timeout, takes precedence over the general timeout when sending commands to the server.
 - `reconnect_attempts`: Specify how many times the client should retry to send queries. Defaults to `0`. Makes sure to read the [reconnection section](#reconnection) before enabling it.
+- `circuit_breaker`: A Hash with circuit breaker configuration. Defaults to `nil`. See the [circuit breaker section](#circuit-breaker) for details.
 - `protocol:` The version of the RESP protocol to use. Default to `3`.
 - `custom`: A user owned value ignored by `redis-client` but available as `Config#custom`. This can be used to hold middleware configurations and other user specific metadatas.
 
@@ -426,24 +427,62 @@ It can be set as a number of retries:
 redis_config = RedisClient.config(reconnect_attempts: 1)
 ```
 
-Or as a list of sleep durations for implementing exponential backoff:
-
-```ruby
-redis_config = RedisClient.config(reconnect_attempts: [0, 0.05, 0.1])
-```
-
 **Important Note**: Retrying may cause commands to be issued more than once to the server, so in the case of
 non-idempotent commands such as `LPUSH` or `INCR`, it may cause consistency issues.
 
 To selectively disable automatic retries, you can use the `#call_once` method:
 
 ```ruby
-redis_config = RedisClient.config(reconnect_attempts: [0, 0.05, 0.1])
+redis_config = RedisClient.config(reconnect_attempts: 3)
 redis = redis_config.new_client
 redis.call("GET", "counter") # Will be retried up to 3 times.
 redis.call_once("INCR", "counter") # Won't be retried.
 ```
 
+### Exponential backoff
+
+Alternatively, `reconnect_attempts` accepts a list of sleep durations for implementing exponential backoff:
+
+```ruby
+redis_config = RedisClient.config(reconnect_attempts: [0, 0.05, 0.1])
+```
+
+This configuration is generally used when the Redis server is expected to failover or recover relatively quickly and
+that it's not really possibe to continue without issuing the command.
+
+When the Redis server is used as an ephemeral cache, circuit breakers are generally prefered.
+
+### Circuit Breaker
+
+When Redis is used as a cache and a connection error happens, you may not want to retry as it might take
+longer than to recompute the value. Instead it's likely preferable to mark the server as unavailable and let it
+recover for a while.
+
+[Circuit breakers are a pattern that does exactly that](https://en.wikipedia.org/wiki/Circuit_breaker_design_pattern).
+
+Configuation options:
+
+  - `error_threshold`. The amount of errors to encounter within `error_threshold_timeout` amount of time before opening the circuit, that is to start rejecting requests instantly.
+  - `error_threshold_timeout`. The amount of time in seconds that `error_threshold` errors must occur to open the circuit. Defaults to `error_timeout` seconds if not set.
+  - `error_timeout`. The amount of time in seconds until trying to query the resource again.
+  - `success_threshold`. The amount of successes on the circuit until closing it again, that is to start accepting all requests to the circuit.
+
+```ruby
+RedisClient.config(
+  circuit_breaker: {
+    # Stop querying the server after 3 errors happened in a 2 seconds window
+    error_threshold: 3,
+    error_threshold_timeout: 2,
+
+    # Try querying again after 1 second
+    error_timeout: 1,
+
+    # Stay in half-open state until 3 queries succeeded.
+    success_threshold: 3,
+  }
+)
+```
+
 ### Drivers
 
 `redis-client` ships with a pure Ruby socket implementation.

data/Rakefile

@@ -26,6 +26,7 @@ namespace :test do
     t.libs << "test"
     t.libs << "lib"
     t.test_files = FileList["test/**/*_test.rb"].exclude("test/sentinel/*_test.rb")
+    t.options = '-v' if ENV['CI'] || ENV['VERBOSE']
   end
 
   Rake::TestTask.new(:sentinel) do |t|
@@ -33,13 +34,16 @@ namespace :test do
     t.libs << "test"
     t.libs << "lib"
     t.test_files = FileList["test/sentinel/*_test.rb"]
+    t.options = '-v' if ENV['CI'] || ENV['VERBOSE']
   end
 
   Rake::TestTask.new(:hiredis) do |t|
     t.libs << "test/hiredis"
     t.libs << "test"
+    t.libs << "hiredis-client/lib"
     t.libs << "lib"
     t.test_files = FileList["test/**/*_test.rb"].exclude("test/sentinel/*_test.rb")
+    t.options = '-v' if ENV['CI'] || ENV['VERBOSE']
   end
 end
 

data/lib/redis_client/circuit_breaker.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+class RedisClient
+  class CircuitBreaker
+    module Middleware
+      def connect(config)
+        config.circuit_breaker.protect { super }
+      end
+
+      def call(_command, config)
+        config.circuit_breaker.protect { super }
+      end
+
+      def call_pipelined(_commands, config)
+        config.circuit_breaker.protect { super }
+      end
+    end
+
+    OpenCircuitError = Class.new(CannotConnectError)
+
+    attr_reader :error_timeout, :error_threshold, :error_threshold_timeout, :success_threshold
+
+    def initialize(error_threshold:, error_timeout:, error_threshold_timeout: error_timeout, success_threshold: 0)
+      @error_threshold = Integer(error_threshold)
+      @error_threshold_timeout = Float(error_threshold_timeout)
+      @error_timeout = Float(error_timeout)
+      @success_threshold = Integer(success_threshold)
+      @errors = []
+      @successes = 0
+      @state = :closed
+      @lock = Mutex.new
+    end
+
+    def protect
+      if @state == :open
+        refresh_state
+      end
+
+      case @state
+      when :open
+        raise OpenCircuitError, "Too many connection errors happened recently"
+      when :closed
+        begin
+          yield
+        rescue ConnectionError
+          record_error
+          raise
+        end
+      when :half_open
+        begin
+          result = yield
+          record_success
+          result
+        rescue ConnectionError
+          record_error
+          raise
+        end
+      else
+        raise "[BUG] RedisClient::CircuitBreaker unexpected @state (#{@state.inspect}})"
+      end
+    end
+
+    private
+
+    def refresh_state
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @lock.synchronize do
+        if @errors.last < (now - @error_timeout)
+          if @success_threshold > 0
+            @state = :half_open
+            @successes = 0
+          else
+            @errors.clear
+            @state = :closed
+          end
+        end
+      end
+    end
+
+    def record_error
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      expiry = now - @error_timeout
+      @lock.synchronize do
+        if @state == :closed
+          @errors.reject! { |t| t < expiry }
+        end
+        @errors << now
+        @successes = 0
+        if @state == :half_open || (@state == :closed && @errors.size >= @error_threshold)
+          @state = :open
+        end
+      end
+    end
+
+    def record_success
+      return unless @state == :half_open
+
+      @lock.synchronize do
+        return unless @state == :half_open
+
+        @successes += 1
+        if @successes >= @success_threshold
+          @state = :closed
+        end
+      end
+    end
+  end
+end

data/lib/redis_client/config.rb

@@ -14,7 +14,7 @@ class RedisClient
     module Common
       attr_reader :db, :password, :id, :ssl, :ssl_params, :command_builder, :inherit_socket,
         :connect_timeout, :read_timeout, :write_timeout, :driver, :connection_prelude, :protocol,
-        :middlewares_stack, :custom
+        :middlewares_stack, :custom, :circuit_breaker
 
       alias_method :ssl?, :ssl
 
@@ -36,7 +36,8 @@ class RedisClient
         command_builder: CommandBuilder,
         inherit_socket: false,
         reconnect_attempts: false,
-        middlewares: false
+        middlewares: false,
+        circuit_breaker: nil
       )
         @username = username
         @password = password
@@ -66,6 +67,11 @@ class RedisClient
         @reconnect_attempts = reconnect_attempts
         @connection_prelude = build_connection_prelude
 
+        circuit_breaker = CircuitBreaker.new(**circuit_breaker) if circuit_breaker.is_a?(Hash)
+        if @circuit_breaker = circuit_breaker
+          middlewares = [CircuitBreaker::Middleware] + (middlewares || [])
+        end
+
         middlewares_stack = Middlewares
         if middlewares && !middlewares.empty?
           middlewares_stack = Class.new(Middlewares)
@@ -106,7 +112,9 @@ class RedisClient
       end
 
       def ssl_context
-        @ssl_context ||= @driver.ssl_context(@ssl_params || {})
+        if ssl
+          @ssl_context ||= @driver.ssl_context(@ssl_params || {})
+        end
       end
 
       def server_url
@@ -155,6 +163,10 @@ class RedisClient
     )
       if url
         uri = URI(url)
+        unless uri.scheme == "redis" || uri.scheme == "rediss"
+          raise ArgumentError, "Invalid URL: #{url.inspect}"
+        end
+
         kwargs[:ssl] = uri.scheme == "rediss" unless kwargs.key?(:ssl)
 
         kwargs[:username] ||= uri.user if uri.password && !uri.user.empty?
@@ -171,7 +183,15 @@ class RedisClient
 
       super(**kwargs)
 
-      @host = host || uri&.host&.sub(/\A\[(.*)\]\z/, '\1') || DEFAULT_HOST
+      @host = host
+      unless @host
+        uri_host = uri&.host
+        uri_host = nil if uri_host&.empty?
+        if uri_host
+          @host = uri_host&.sub(/\A\[(.*)\]\z/, '\1')
+        end
+      end
+      @host ||= DEFAULT_HOST
       @port = Integer(port || uri&.port || DEFAULT_PORT)
       @path = path
     end

data/lib/redis_client/connection_mixin.rb

@@ -6,9 +6,22 @@ class RedisClient
       @pending_reads = 0
     end
 
+    def reconnect
+      close
+      connect
+    end
+
+    def close
+      @pending_reads = 0
+      nil
+    end
+
     def revalidate
-      if @pending_reads == 0 && connected?
-        self
+      if @pending_reads > 0
+        close
+        false
+      else
+        connected?
       end
     end
 
@@ -17,7 +30,7 @@ class RedisClient
       write(command)
       result = read(timeout)
       @pending_reads -= 1
-      if result.is_a?(CommandError)
+      if result.is_a?(Error)
         result._set_command(command)
         raise result
       else
@@ -37,7 +50,7 @@ class RedisClient
         timeout = timeouts && timeouts[index]
         result = read(timeout)
         @pending_reads -= 1
-        if result.is_a?(CommandError)
+        if result.is_a?(Error)
           result._set_command(commands[index])
           exception ||= result
         end

data/lib/redis_client/pid_cache.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class RedisClient
+  module PIDCache
+    if !Process.respond_to?(:fork) # JRuby or TruffleRuby
+      @pid = Process.pid
+      singleton_class.attr_reader(:pid)
+    elsif Process.respond_to?(:_fork) # Ruby 3.1+
+      class << self
+        attr_reader :pid
+
+        def update!
+          @pid = Process.pid
+        end
+      end
+      update!
+
+      module CoreExt
+        def _fork
+          child_pid = super
+          PIDCache.update! if child_pid == 0
+          child_pid
+        end
+      end
+      Process.singleton_class.prepend(CoreExt)
+    else # Ruby 3.0 or older
+      class << self
+        def pid
+          Process.pid
+        end
+      end
+    end
+  end
+end

data/lib/redis_client/ruby_connection/buffered_io.rb

@@ -70,9 +70,9 @@ class RedisClient
               return total
             end
           when :wait_readable
-            @io.to_io.wait_readable(@read_timeout) or raise ReadTimeoutError
+            @io.to_io.wait_readable(@read_timeout) or raise(ReadTimeoutError, "Waited #{@read_timeout} seconds")
           when :wait_writable
-            @io.to_io.wait_writable(@write_timeout) or raise WriteTimeoutError
+            @io.to_io.wait_writable(@write_timeout) or raise(WriteTimeoutError, "Waited #{@write_timeout} seconds")
           when nil
             raise Errno::ECONNRESET
           else
@@ -137,12 +137,12 @@ class RedisClient
             return if !strict || remaining <= 0
           when :wait_readable
             unless @io.to_io.wait_readable(@read_timeout)
-              raise ReadTimeoutError unless @blocking_reads
+              raise ReadTimeoutError, "Waited #{@read_timeout} seconds" unless @blocking_reads
             end
           when :wait_writable
-            @io.to_io.wait_writable(@write_timeout) or raise WriteTimeoutError
+            @io.to_io.wait_writable(@write_timeout) or raise(WriteTimeoutError, "Waited #{@write_timeout} seconds")
           when nil
-            raise Errno::ECONNRESET
+            raise EOFError
           else
             raise "Unexpected `read_nonblock` return: #{bytes.inspect}"
           end

data/lib/redis_client/ruby_connection.rb

@@ -42,43 +42,11 @@ class RedisClient
 
     def initialize(config, connect_timeout:, read_timeout:, write_timeout:)
       super()
-      socket = if config.path
-        UNIXSocket.new(config.path)
-      else
-        sock = if SUPPORTS_RESOLV_TIMEOUT
-          Socket.tcp(config.host, config.port, connect_timeout: connect_timeout, resolv_timeout: connect_timeout)
-        else
-          Socket.tcp(config.host, config.port, connect_timeout: connect_timeout)
-        end
-        # disables Nagle's Algorithm, prevents multiple round trips with MULTI
-        sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-        sock
-      end
-
-      if config.ssl
-        socket = OpenSSL::SSL::SSLSocket.new(socket, config.ssl_context)
-        socket.hostname = config.host
-        loop do
-          case status = socket.connect_nonblock(exception: false)
-          when :wait_readable
-            socket.to_io.wait_readable(connect_timeout) or raise CannotConnectError
-          when :wait_writable
-            socket.to_io.wait_writable(connect_timeout) or raise CannotConnectError
-          when socket
-            break
-          else
-            raise "Unexpected `connect_nonblock` return: #{status.inspect}"
-          end
-        end
-      end
-
-      @io = BufferedIO.new(
-        socket,
-        read_timeout: read_timeout,
-        write_timeout: write_timeout,
-      )
-    rescue SystemCallError, OpenSSL::SSL::SSLError, SocketError => error
-      raise CannotConnectError, error.message, error.backtrace
+      @config = config
+      @connect_timeout = connect_timeout
+      @read_timeout = read_timeout
+      @write_timeout = write_timeout
+      connect
     end
 
     def connected?
@@ -87,13 +55,16 @@ class RedisClient
 
     def close
       @io.close
+      super
     end
 
     def read_timeout=(timeout)
+      @read_timeout = timeout
       @io.read_timeout = timeout if @io
     end
 
     def write_timeout=(timeout)
+      @write_timeout = timeout
       @io.write_timeout = timeout if @io
     end
 
@@ -129,5 +100,78 @@ class RedisClient
     rescue SystemCallError, IOError, OpenSSL::SSL::SSLError => error
       raise ConnectionError, error.message
     end
+
+    private
+
+    def connect
+      socket = if @config.path
+        UNIXSocket.new(@config.path)
+      else
+        sock = if SUPPORTS_RESOLV_TIMEOUT
+          Socket.tcp(@config.host, @config.port, connect_timeout: @connect_timeout, resolv_timeout: @connect_timeout)
+        else
+          Socket.tcp(@config.host, @config.port, connect_timeout: @connect_timeout)
+        end
+        # disables Nagle's Algorithm, prevents multiple round trips with MULTI
+        sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        enable_socket_keep_alive(sock)
+        sock
+      end
+
+      if @config.ssl
+        socket = OpenSSL::SSL::SSLSocket.new(socket, @config.ssl_context)
+        socket.hostname = @config.host
+        loop do
+          case status = socket.connect_nonblock(exception: false)
+          when :wait_readable
+            socket.to_io.wait_readable(@connect_timeout) or raise CannotConnectError
+          when :wait_writable
+            socket.to_io.wait_writable(@connect_timeout) or raise CannotConnectError
+          when socket
+            break
+          else
+            raise "Unexpected `connect_nonblock` return: #{status.inspect}"
+          end
+        end
+      end
+
+      @io = BufferedIO.new(
+        socket,
+        read_timeout: @read_timeout,
+        write_timeout: @write_timeout,
+      )
+      true
+    rescue SystemCallError, OpenSSL::SSL::SSLError, SocketError => error
+      raise CannotConnectError, error.message, error.backtrace
+    end
+
+    KEEP_ALIVE_INTERVAL = 15 # Same as hiredis defaults
+    KEEP_ALIVE_TTL = 120 # Longer than hiredis defaults
+    KEEP_ALIVE_PROBES = (KEEP_ALIVE_TTL / KEEP_ALIVE_INTERVAL) - 1
+    private_constant :KEEP_ALIVE_INTERVAL
+    private_constant :KEEP_ALIVE_TTL
+    private_constant :KEEP_ALIVE_PROBES
+
+    if %i[SOL_TCP SOL_SOCKET TCP_KEEPIDLE TCP_KEEPINTVL TCP_KEEPCNT].all? { |c| Socket.const_defined? c } # Linux
+      def enable_socket_keep_alive(socket)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+        socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPIDLE, KEEP_ALIVE_INTERVAL)
+        socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPINTVL, KEEP_ALIVE_INTERVAL)
+        socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPCNT, KEEP_ALIVE_PROBES)
+      end
+    elsif %i[IPPROTO_TCP TCP_KEEPINTVL TCP_KEEPCNT].all? { |c| Socket.const_defined? c } # macOS
+      def enable_socket_keep_alive(socket)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_KEEPINTVL, KEEP_ALIVE_INTERVAL)
+        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_KEEPCNT, KEEP_ALIVE_PROBES)
+      end
+    elsif %i[SOL_SOCKET SO_KEEPALIVE].all? { |c| Socket.const_defined? c } # unknown POSIX
+      def enable_socket_keep_alive(socket)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+      end
+    else # unknown
+      def enable_socket_keep_alive(_socket)
+      end
+    end
   end
 end

data/lib/redis_client/sentinel_config.rb

@@ -13,9 +13,9 @@ class RedisClient
       end
 
       @to_list_of_hash = @to_hash = nil
-      extra_config = {}
+      @extra_config = {}
       if client_config[:protocol] == 2
-        extra_config[:protocol] = client_config[:protocol]
+        @extra_config[:protocol] = client_config[:protocol]
         @to_list_of_hash = lambda do |may_be_a_list|
           if may_be_a_list.is_a?(Array)
             may_be_a_list.map { |l| l.each_slice(2).to_h }
@@ -26,14 +26,7 @@ class RedisClient
       end
 
       @name = name
-      @sentinel_configs = sentinels.map do |s|
-        case s
-        when String
-          Config.new(**extra_config, url: s)
-        else
-          Config.new(**extra_config, **s)
-        end
-      end
+      @sentinel_configs = sentinels_to_configs(sentinels)
       @sentinels = {}.compare_by_identity
       @role = role
       @mutex = Mutex.new
@@ -93,6 +86,17 @@ class RedisClient
 
     private
 
+    def sentinels_to_configs(sentinels)
+      sentinels.map do |sentinel|
+        case sentinel
+        when String
+          Config.new(**@extra_config, url: sentinel)
+        else
+          Config.new(**@extra_config, **sentinel)
+        end
+      end
+    end
+
     def config
       @mutex.synchronize do
         @config ||= if @role == :master
@@ -106,9 +110,11 @@ class RedisClient
     def resolve_master
       each_sentinel do |sentinel_client|
         host, port = sentinel_client.call("SENTINEL", "get-master-addr-by-name", @name)
-        if host && port
-          return Config.new(host: host, port: Integer(port), **@client_config)
-        end
+        next unless host && port
+
+        refresh_sentinels(sentinel_client)
+
+        return Config.new(host: host, port: Integer(port), **@client_config)
       end
     rescue ConnectionError
       raise ConnectionError, "No sentinels available"
@@ -159,5 +165,19 @@ class RedisClient
 
       raise last_error if last_error
     end
+
+    def refresh_sentinels(sentinel_client)
+      sentinel_response = sentinel_client.call("SENTINEL", "sentinels", @name, &@to_list_of_hash)
+      sentinels = sentinel_response.map do |sentinel|
+        { host: sentinel.fetch("ip"), port: Integer(sentinel.fetch("port")) }
+      end
+      new_sentinels = sentinels.select do |sentinel|
+        @sentinel_configs.none? do |sentinel_config|
+          sentinel_config.host == sentinel.fetch(:host) && sentinel_config.port == sentinel.fetch(:port)
+        end
+      end
+
+      @sentinel_configs.concat sentinels_to_configs(new_sentinels)
+    end
   end
 end

data/lib/redis_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class RedisClient
-  VERSION = "0.11.1"
+  VERSION = "0.14.1"
 end

data/lib/redis_client.rb

@@ -3,6 +3,7 @@
 require "redis_client/version"
 require "redis_client/command_builder"
 require "redis_client/config"
+require "redis_client/pid_cache"
 require "redis_client/sentinel_config"
 require "redis_client/middlewares"
 
@@ -62,12 +63,12 @@ class RedisClient
       write_timeout: config.write_timeout
     )
       @config = config
-      @id = id
+      @id = id&.to_s
       @connect_timeout = connect_timeout
       @read_timeout = read_timeout
       @write_timeout = write_timeout
       @command_builder = config.command_builder
-      @pid = Process.pid
+      @pid = PIDCache.pid
     end
 
     def timeout=(timeout)
@@ -90,9 +91,17 @@ class RedisClient
   WriteTimeoutError = Class.new(TimeoutError)
   CheckoutTimeoutError = Class.new(TimeoutError)
 
-  class CommandError < Error
+  module HasCommand
     attr_reader :command
 
+    def _set_command(command)
+      @command = command
+    end
+  end
+
+  class CommandError < Error
+    include HasCommand
+
     class << self
       def parse(error_message)
         code = if error_message.start_with?("ERR Error running script")
@@ -107,22 +116,24 @@ class RedisClient
         klass.new(error_message)
       end
     end
-
-    def _set_command(command)
-      @command = command
-    end
   end
 
   AuthenticationError = Class.new(CommandError)
   PermissionError = Class.new(CommandError)
-  ReadOnlyError = Class.new(CommandError)
   WrongTypeError = Class.new(CommandError)
   OutOfMemoryError = Class.new(CommandError)
 
+  ReadOnlyError = Class.new(ConnectionError)
+  ReadOnlyError.include(HasCommand)
+
+  MasterDownError = Class.new(ConnectionError)
+  MasterDownError.include(HasCommand)
+
   CommandError::ERRORS = {
     "WRONGPASS" => AuthenticationError,
     "NOPERM" => PermissionError,
     "READONLY" => ReadOnlyError,
+    "MASTERDOWN" => MasterDownError,
     "WRONGTYPE" => WrongTypeError,
     "OOM" => OutOfMemoryError,
   }.freeze
@@ -335,7 +346,6 @@ class RedisClient
 
   def close
     @raw_connection&.close
-    @raw_connection = nil
     self
   end
 
@@ -419,7 +429,7 @@ class RedisClient
 
     def close
       @raw_connection&.close
-      @raw_connection = nil
+      @raw_connection = nil # PubSub can't just reconnect
       self
     end
 
@@ -599,7 +609,7 @@ class RedisClient
   end
 
   def ensure_connected(retryable: true)
-    close if !config.inherit_socket && @pid != Process.pid
+    close if !config.inherit_socket && @pid != PIDCache.pid
 
     if @disable_reconnection
       if block_given?
@@ -643,52 +653,58 @@ class RedisClient
   end
 
   def raw_connection
-    @raw_connection = @raw_connection&.revalidate
-    @raw_connection ||= connect
+    if @raw_connection.nil? || !@raw_connection.revalidate
+      connect
+    end
+    @raw_connection
   end
 
   def connect
-    @pid = Process.pid
+    @pid = PIDCache.pid
 
-    connection = @middlewares.connect(config) do
-      config.driver.new(
-        config,
-        connect_timeout: connect_timeout,
-        read_timeout: read_timeout,
-        write_timeout: write_timeout,
-      )
+    if @raw_connection
+      @middlewares.connect(config) do
+        @raw_connection.reconnect
+      end
+    else
+      @raw_connection = @middlewares.connect(config) do
+        config.driver.new(
+          config,
+          connect_timeout: connect_timeout,
+          read_timeout: read_timeout,
+          write_timeout: write_timeout,
+        )
+      end
     end
 
     prelude = config.connection_prelude.dup
 
     if id
-      prelude << ["CLIENT", "SETNAME", id.to_s]
+      prelude << ["CLIENT", "SETNAME", id]
     end
 
     # The connection prelude is deliberately not sent to Middlewares
     if config.sentinel?
       prelude << ["ROLE"]
       role, = @middlewares.call_pipelined(prelude, config) do
-        connection.call_pipelined(prelude, nil).last
+        @raw_connection.call_pipelined(prelude, nil).last
       end
       config.check_role!(role)
     else
       unless prelude.empty?
         @middlewares.call_pipelined(prelude, config) do
-          connection.call_pipelined(prelude, nil)
+          @raw_connection.call_pipelined(prelude, nil)
         end
       end
     end
-
-    connection
-  rescue FailoverError
+  rescue FailoverError, CannotConnectError
     raise
   rescue ConnectionError => error
     raise CannotConnectError, error.message, error.backtrace
   rescue CommandError => error
-    if error.message.include?("ERR unknown command `HELLO`")
+    if error.message.match?(/ERR unknown command ['`]HELLO['`]/)
       raise UnsupportedServer,
-        "Your Redis server version is too old. redis-client requires Redis 6+. (#{config.server_url})"
+        "redis-client requires Redis 6+ with HELLO command available (#{config.server_url})"
     else
       raise
     end
@@ -696,5 +712,6 @@ class RedisClient
 end
 
 require "redis_client/pooled"
+require "redis_client/circuit_breaker"
 
 RedisClient.default_driver

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-client
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.14.1
 platform: ruby
 authors:
 - Jean Boussier
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-04 00:00:00.000000000 Z
+date: 2023-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -39,11 +39,13 @@ files:
 - Rakefile
 - lib/redis-client.rb
 - lib/redis_client.rb
+- lib/redis_client/circuit_breaker.rb
 - lib/redis_client/command_builder.rb
 - lib/redis_client/config.rb
 - lib/redis_client/connection_mixin.rb
 - lib/redis_client/decorator.rb
 - lib/redis_client/middlewares.rb
+- lib/redis_client/pid_cache.rb
 - lib/redis_client/pooled.rb
 - lib/redis_client/ruby_connection.rb
 - lib/redis_client/ruby_connection/buffered_io.rb
@@ -74,7 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: Simple low-level client for Redis 6+