redis 4.2.5 → 4.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 862e8133262fead707e4ca317b29d0e35425e3a7861ea1a52033bc91ba61bf6d
-  data.tar.gz: 5b2b32250d783fe58b0af54cc386f2568241644a0badc0b7247bb29b1ac94a93
+  metadata.gz: b18788ff80698e8f79fb103e7419d9ba74fb0b6a5eb55c672422cd76abff985c
+  data.tar.gz: 1eed18a57039c677c894564ceaa1cf6bc9c0535be51501d078b09d75617a9d89
 SHA512:
-  metadata.gz: 2aab289f4f22b2f3a804ca7b0da4cf95e352a8d246611490d8d803edebbbc7e7c299355cd0b90e6f3ac8bc0d11e9bf3792a328c95847d32e1d984729afe66ed2
-  data.tar.gz: d9ec8ba4d314d099e909cdddf6dfb4c3c14b853b46f45c4909ac3ba10fb1880bd9a7b0465257fa91f9a4ea6c9f82723c16c177810ac15c89fab3790d7af31ad0
+  metadata.gz: 5f2f7ce595d431f548c126a63c5ce697cc9e596e9b0eaa00f1e0186ae3853e73922c6e130b989ba9e026aec32f766a774433fdd1cff216420e837837db90659b
+  data.tar.gz: 02fb8debb0d11f7b9d04f7616093535426f0ee5a0994992fcf3187ab00aa890dcd2fb248f14da49837508a3ccbb5756be208fc5d3b8dcd18ec6aaf0fb1bb1193

data/CHANGELOG.md

@@ -1,5 +1,118 @@
 # Unreleased
 
+# 4.8.1
+
+* Automatically reconnect after fork regardless of `reconnect_attempts`
+
+# 4.8.0
+
+* Introduce `sadd?` and `srem?` as boolean returning versions of `sadd` and `srem`.
+* Deprecate `sadd` and `srem` returning a boolean when called with a single argument.
+  To enable the redis 5.0 behavior you can set `Redis.sadd_returns_boolean = false`.
+* Deprecate passing `timeout` as a positional argument in blocking commands (`brpop`, `blop`, etc).
+
+# 4.7.1
+
+* Gracefully handle OpenSSL 3.0 EOF Errors (`OpenSSL::SSL::SSLError: SSL_read: unexpected eof while reading`). See #1106
+  This happens frequently on heroku-22.
+
+# 4.7.0
+
+* Support single endpoint architecture with SSL/TLS in cluster mode. See #1086.
+* `zrem` and `zadd` act as noop when provided an empty list of keys. See #1097.
+* Support IPv6 URLs.
+* Add `Redis#with` for better compatibility with `connection_pool` usage.
+* Fix the block form of `multi` called inside `pipelined`. Previously the `MUTLI/EXEC` wouldn't be sent. See #1073.
+
+# 4.6.0
+
+* Deprecate `Redis.current`.
+* Deprecate calling commands on `Redis` inside `Redis#pipelined`. See #1059.
+  ```ruby
+  redis.pipelined do
+    redis.get("key")
+  end
+  ```
+
+  should be replaced by:
+
+  ```ruby
+  redis.pipelined do |pipeline|
+    pipeline.get("key")
+  end
+  ```
+* Deprecate calling commands on `Redis` inside `Redis#multi`. See #1059.
+  ```ruby
+  redis.multi do
+    redis.get("key")
+  end
+  ```
+
+  should be replaced by:
+
+  ```ruby
+  redis.multi do |transaction|
+    transaction.get("key")
+  end
+  ```
+* Deprecate `Redis#queue` and `Redis#commit`. See #1059.
+
+* Fix `zpopmax` and `zpopmin` when called inside a pipeline. See #1055.
+* `Redis#synchronize` is now private like it should always have been.
+
+* Add `Redis.silence_deprecations=` to turn off deprecation warnings.
+  If you don't wish to see warnings yet, you can set `Redis.silence_deprecations = true`.
+  It is however heavily recommended to fix them instead when possible.
+* Add `Redis.raise_deprecations=` to turn deprecation warnings into errors.
+  This makes it easier to identitify the source of deprecated APIs usage.
+  It is recommended to set `Redis.raise_deprecations = true` in development and test environments.
+* Add new options to ZRANGE. See #1053.
+* Add ZRANGESTORE command. See #1053.
+* Add SCAN support for `Redis::Cluster`. See #1049.
+* Add COPY command. See #1053. See #1048.
+* Add ZDIFFSTORE command. See #1046.
+* Add ZDIFF command. See #1044.
+* Add ZUNION command. See #1042.
+* Add HRANDFIELD command. See #1040.
+
+# 4.5.1
+
+* Restore the accidential auth behavior of redis-rb 4.3.0 with a warning. If provided with the `default` user's password, but a wrong username,
+  redis-rb will first try to connect as the provided user, but then will fallback to connect as the `default` user with the provided password.
+  This behavior is deprecated and will be removed in Redis 4.6.0. Fix #1038.
+
+# 4.5.0
+
+* Handle parts of the command using incompatible encodings. See #1037.
+* Add GET option to SET command. See #1036.
+* Add ZRANDMEMBER command. See #1035.
+* Add LMOVE/BLMOVE commands. See #1034.
+* Add ZMSCORE command. See #1032.
+* Add LT/GT options to ZADD. See #1033.
+* Add SMISMEMBER command. See #1031.
+* Add EXAT/PXAT options to SET. See #1028.
+* Add GETDEL/GETEX commands. See #1024.
+* `Redis#exists` now returns an Integer by default, as warned since 4.2.0. The old behavior can be restored with `Redis.exists_returns_integer = false`.
+* Fix Redis < 6 detection during connect. See #1025.
+* Fix fetching command details in Redis cluster when the first node is unhealthy. See #1026.
+
+# 4.4.0
+
+* Redis cluster: fix cross-slot validation in pipelines. Fix ##1019.
+* Add support for `XAUTOCLAIM`. See #1018.
+* Properly issue `READONLY` when reconnecting to replicas. Fix #1017.
+* Make `del` a noop if passed an empty list of keys. See #998.
+* Add support for `ZINTER`. See #995.
+
+# 4.3.1
+
+* Fix password authentication against redis server 5 and older.
+
+# 4.3.0
+
+* Add the TYPE argument to scan and scan_each. See #985.
+* Support AUTH command for ACL. See #967.
+
 # 4.2.5
 
 * Optimize the ruby connector write buffering. See #964.

data/README.md

@@ -1,4 +1,4 @@
-# redis-rb [![Build Status][travis-image]][travis-link] [![Inline docs][inchpages-image]][inchpages-link] ![](https://github.com/redis/redis-rb/workflows/Test/badge.svg?branch=master)
+# redis-rb [![Build Status][gh-actions-image]][gh-actions-link] [![Inline docs][inchpages-image]][inchpages-link]
 
 A Ruby client that tries to match [Redis][redis-home]' API one-to-one, while still
 providing an idiomatic interface.
@@ -54,6 +54,12 @@ To connect to a password protected Redis instance, use:
 redis = Redis.new(password: "mysecret")
 ```
 
+To connect a Redis instance using [ACL](https://redis.io/topics/acl), use:
+
+```ruby
+redis = Redis.new(username: 'myname', password: 'mysecret')
+```
+
 The Redis class exports methods that are named identical to the commands
 they execute. The arguments these methods accept are often identical to
 the arguments specified on the [Redis website][redis-commands]. For
@@ -149,6 +155,21 @@ redis.mget('{key}1', '{key}2')
 * The client support permanent node failures, and will reroute requests to promoted slaves.
 * The client supports `MOVED` and `ASK` redirections transparently.
 
+## Cluster mode with SSL/TLS
+Since Redis can return FQDN of nodes in reply to client since `7.*` with CLUSTER commands, we can use cluster feature with SSL/TLS connection like this:
+
+```ruby
+Redis.new(cluster: %w[rediss://foo.example.com:6379])
+```
+
+On the other hand, in Redis versions prior to `6.*`, you can specify options like the following if cluster mode is enabled and client has to connect to nodes via single endpoint with SSL/TLS.
+
+```ruby
+Redis.new(cluster: %w[rediss://foo-endpoint.example.com:6379], fixed_hostname: 'foo-endpoint.example.com')
+```
+
+In case of the above architecture, if you don't pass the `fixed_hostname` option to the client and servers return IP addresses of nodes, the client may fail to verify certificates.
+
 ## Storing objects
 
 Redis "string" types can be used to store serialized Ruby objects, for
@@ -178,9 +199,9 @@ commands to Redis and gathers their replies. These replies are returned
 by the `#pipelined` method.
 
 ```ruby
-redis.pipelined do
-  redis.set "foo", "bar"
-  redis.incr "baz"
+redis.pipelined do |pipeline|
+  pipeline.set "foo", "bar"
+  pipeline.incr "baz"
 end
 # => ["OK", 1]
 ```
@@ -194,9 +215,9 @@ the regular pipeline, the replies to the commands are returned by the
 `#multi` method.
 
 ```ruby
-redis.multi do
-  redis.set "foo", "bar"
-  redis.incr "baz"
+redis.multi do |transaction|
+  transaction.set "foo", "bar"
+  transaction.incr "baz"
 end
 # => ["OK", 1]
 ```
@@ -204,15 +225,15 @@ end
 ### Futures
 
 Replies to commands in a pipeline can be accessed via the *futures* they
-emit (since redis-rb 3.0). All calls inside a pipeline block return a
+emit (since redis-rb 3.0). All calls on the pipeline object return a
 `Future` object, which responds to the `#value` method. When the
 pipeline has successfully executed, all futures are assigned their
 respective replies and can be used.
 
 ```ruby
-redis.pipelined do
-  @set = redis.set "foo", "bar"
-  @incr = redis.incr "baz"
+redis.pipelined do |pipeline|
+  @set = pipeline.set "foo", "bar"
+  @incr = pipeline.incr "baz"
 end
 
 @set.value
@@ -440,7 +461,7 @@ redis = Redis.new(:driver => :synchrony)
 ## Testing
 
 This library is tested against recent Ruby and Redis versions.
-Check [Travis][travis-link] for the exact versions supported.
+Check [Github Actions][gh-actions-link] for the exact versions supported.
 
 ## See Also
 
@@ -459,12 +480,11 @@ client and evangelized Redis in Rubyland. Thank you, Ezra.
 requests.
 
 
-[inchpages-image]: https://inch-ci.org/github/redis/redis-rb.svg
-[inchpages-link]:  https://inch-ci.org/github/redis/redis-rb
-[redis-commands]:  https://redis.io/commands
-[redis-home]:      https://redis.io
-[redis-url]:       http://www.iana.org/assignments/uri-schemes/prov/redis
-[travis-home]:     https://travis-ci.org/
-[travis-image]:    https://secure.travis-ci.org/redis/redis-rb.svg?branch=master
-[travis-link]:     https://travis-ci.org/redis/redis-rb
-[rubydoc]:         http://www.rubydoc.info/gems/redis
+[inchpages-image]:  https://inch-ci.org/github/redis/redis-rb.svg
+[inchpages-link]:   https://inch-ci.org/github/redis/redis-rb
+[redis-commands]:   https://redis.io/commands
+[redis-home]:       https://redis.io
+[redis-url]:        http://www.iana.org/assignments/uri-schemes/prov/redis
+[gh-actions-image]: https://github.com/redis/redis-rb/workflows/Test/badge.svg
+[gh-actions-link]:  https://github.com/redis/redis-rb/actions
+[rubydoc]:          http://www.rubydoc.info/gems/redis

data/lib/redis/client.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "errors"
 require "socket"
 require "cgi"
+require "redis/errors"
 
 class Redis
   class Client
@@ -17,6 +17,7 @@ class Redis
       write_timeout: nil,
       connect_timeout: nil,
       timeout: 5.0,
+      username: nil,
       password: nil,
       db: 0,
       driver: nil,
@@ -31,7 +32,7 @@ class Redis
       role: nil
     }.freeze
 
-    attr_reader :options
+    attr_reader :options, :connection, :command_map
 
     def scheme
       @options[:scheme]
@@ -61,6 +62,10 @@ class Redis
       @options[:read_timeout]
     end
 
+    def username
+      @options[:username]
+    end
+
     def password
       @options[:password]
     end
@@ -82,8 +87,6 @@ class Redis
     end
 
     attr_accessor :logger
-    attr_reader :connection
-    attr_reader :command_map
 
     def initialize(options = {})
       @options = _parse_options(options)
@@ -110,7 +113,34 @@ class Redis
       # Don't try to reconnect when the connection is fresh
       with_reconnect(false) do
         establish_connection
-        call [:auth, password] if password
+        if password
+          if username
+            begin
+              call [:auth, username, password]
+            rescue CommandError => err # Likely on Redis < 6
+              case err.message
+              when /ERR wrong number of arguments for 'auth' command/
+                call [:auth, password]
+              when /WRONGPASS invalid username-password pair/
+                begin
+                  call [:auth, password]
+                rescue CommandError
+                  raise err
+                end
+                ::Redis.deprecate!(
+                  "[redis-rb] The Redis connection was configured with username #{username.inspect}, but" \
+                  " the provided password was for the default user. This will start failing in redis-rb 5.0.0."
+                )
+              else
+                raise
+              end
+            end
+          else
+            call [:auth, password]
+          end
+        end
+
+        call [:readonly] if @options[:readonly]
         call [:select, db] if db != 0
         call [:client, :setname, @options[:id]] if @options[:id]
         @connector.check(self)
@@ -120,7 +150,7 @@ class Redis
     end
 
     def id
-      @options[:id] || "redis://#{location}/#{db}"
+      @options[:id] || "#{@options[:ssl] ? 'rediss' : @options[:scheme]}://#{location}/#{db}"
     end
 
     def location
@@ -131,7 +161,7 @@ class Redis
       reply = process([command]) { read }
       raise reply if reply.is_a?(CommandError)
 
-      if block_given?
+      if block_given? && reply != 'QUEUED'
         yield reply
       else
         reply
@@ -221,7 +251,8 @@ class Redis
       result
     end
 
-    def call_with_timeout(command, timeout, &blk)
+    def call_with_timeout(command, extra_timeout, &blk)
+      timeout = extra_timeout == 0 ? 0 : self.timeout + extra_timeout
       with_socket_timeout(timeout) do
         call(command, &blk)
       end
@@ -271,7 +302,7 @@ class Redis
       e2 = TimeoutError.new("Connection timed out")
       e2.set_backtrace(e1.backtrace)
       raise e2
-    rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF, Errno::EINVAL => e
+    rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF, Errno::EINVAL, EOFError => e
       raise ConnectionError, "Connection lost (%s)" % [e.class.name.split("::").last]
     end
 
@@ -368,23 +399,14 @@ class Redis
     end
 
     def ensure_connected
-      disconnect if @pending_reads > 0
+      disconnect if @pending_reads > 0 || (@pid != Process.pid && !inherit_socket?)
 
       attempts = 0
 
       begin
         attempts += 1
 
-        if connected?
-          unless inherit_socket? || Process.pid == @pid
-            raise InheritedError,
-                  "Tried to use a connection from a child process without reconnecting. " \
-                  "You need to reconnect to Redis after forking " \
-                  "or set :inherit_socket to true."
-          end
-        else
-          connect
-        end
+        connect unless connected?
 
         yield
       rescue BaseConnectionError
@@ -411,7 +433,7 @@ class Redis
       defaults = DEFAULTS.dup
       options = options.dup
 
-      defaults.keys.each do |key|
+      defaults.each_key do |key|
         # Fill in defaults if needed
         defaults[key] = defaults[key].call if defaults[key].respond_to?(:call)
 
@@ -428,13 +450,15 @@ class Redis
 
         uri = URI(url)
 
-        if uri.scheme == "unix"
+        case uri.scheme
+        when "unix"
           defaults[:path] = uri.path
-        elsif uri.scheme == "redis" || uri.scheme == "rediss"
+        when "redis", "rediss"
           defaults[:scheme]   = uri.scheme
-          defaults[:host]     = uri.host if uri.host
+          defaults[:host]     = uri.host.sub(/\A\[(.*)\]\z/, '\1') if uri.host
           defaults[:port]     = uri.port if uri.port
-          defaults[:password] = CGI.unescape(uri.password) if uri.password
+          defaults[:username] = CGI.unescape(uri.user) if uri.user && !uri.user.empty?
+          defaults[:password] = CGI.unescape(uri.password) if uri.password && !uri.password.empty?
           defaults[:db]       = uri.path[1..-1].to_i if uri.path
           defaults[:role] = :master
         else
@@ -445,7 +469,7 @@ class Redis
       end
 
       # Use default when option is not specified or nil
-      defaults.keys.each do |key|
+      defaults.each_key do |key|
         options[key] = defaults[key] if options[key].nil?
       end
 
@@ -510,7 +534,7 @@ class Redis
           require_relative "connection/#{driver}"
         rescue LoadError, NameError
           begin
-            require "connection/#{driver}"
+            require "redis/connection/#{driver}"
           rescue LoadError, NameError => error
             raise "Cannot load driver #{driver.inspect}: #{error.message}"
           end
@@ -579,6 +603,7 @@ class Redis
             client = Client.new(@options.merge({
                                                  host: sentinel[:host] || sentinel["host"],
                                                  port: sentinel[:port] || sentinel["port"],
+                                                 username: sentinel[:username] || sentinel["username"],
                                                  password: sentinel[:password] || sentinel["password"],
                                                  reconnect_attempts: 0
                                                }))

data/lib/redis/cluster/command.rb

@@ -31,13 +31,13 @@ class Redis
       private
 
       def pick_details(details)
-        details.map do |command, detail|
-          [command, {
+        details.transform_values do |detail|
+          {
             first_key_position: detail[:first],
             write: detail[:flags].include?('write'),
             readonly: detail[:flags].include?('readonly')
-          }]
-        end.to_h
+          }
+        end
       end
 
       def dig_details(command, key)
@@ -53,8 +53,6 @@ class Redis
         when 'object' then 2
         when 'memory'
           command[1].to_s.casecmp('usage').zero? ? 2 : 0
-        when 'scan', 'sscan', 'hscan', 'zscan'
-          determine_optional_key_position(command, 'match')
         when 'xread', 'xreadgroup'
           determine_optional_key_position(command, 'streams')
         else

data/lib/redis/cluster/command_loader.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../errors'
+require 'redis/errors'
 
 class Redis
   class Cluster
@@ -10,22 +10,21 @@ class Redis
       module_function
 
       def load(nodes)
-        details = {}
-
-        nodes.each do |node|
-          details = fetch_command_details(node)
-          details.empty? ? next : break
+        errors = nodes.map do |node|
+          begin
+            return fetch_command_details(node)
+          rescue CannotConnectError, ConnectionError, CommandError => error
+            error
+          end
         end
 
-        details
+        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
-      rescue CannotConnectError, ConnectionError, CommandError
-        {} # can retry on another node
       end
 
       private_class_method :fetch_command_details

data/lib/redis/cluster/node.rb

@@ -58,6 +58,18 @@ class Redis
         try_map { |_, client| client.process(commands, &block) }.values
       end
 
+      def scale_reading_clients
+        reading_clients = []
+
+        @clients.each do |node_key, client|
+          next unless replica_disabled? ? master?(node_key) : slave?(node_key)
+
+          reading_clients << client
+        end
+
+        reading_clients
+      end
+
       private
 
       def replica_disabled?
@@ -76,8 +88,9 @@ class Redis
         clients = options.map do |node_key, option|
           next if replica_disabled? && slave?(node_key)
 
+          option = option.merge(readonly: true) if slave?(node_key)
+
           client = Client.new(option)
-          client.call(%i[readonly]) if slave?(node_key)
           [node_key, client]
         end
 

data/lib/redis/cluster/node_loader.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../errors'
+require 'redis/errors'
 
 class Redis
   class Cluster
@@ -9,16 +9,15 @@ class Redis
       module_function
 
       def load_flags(nodes)
-        info = {}
-
-        nodes.each do |node|
-          info = fetch_node_info(node)
-          info.empty? ? next : break
+        errors = nodes.map do |node|
+          begin
+            return fetch_node_info(node)
+          rescue CannotConnectError, ConnectionError, CommandError => error
+            error
+          end
         end
 
-        return info unless info.empty?
-
-        raise CannotConnectError, 'Redis client could not connect to any cluster nodes'
+        raise InitialSetupError, errors
       end
 
       def fetch_node_info(node)
@@ -27,8 +26,6 @@ class Redis
             .map { |str| str.split(' ') }
             .map { |arr| [arr[1].split('@').first, (arr[2].split(',') & %w[master slave]).first] }
             .to_h
-      rescue CannotConnectError, ConnectionError, CommandError
-        {} # can retry on another node
       end
 
       private_class_method :fetch_node_info

data/lib/redis/cluster/option.rb

@@ -17,14 +17,20 @@ class Redis
         node_addrs = options.delete(:cluster)
         @node_opts = build_node_options(node_addrs)
         @replica = options.delete(:replica) == true
+        @fixed_hostname = options.delete(:fixed_hostname)
         add_common_node_option_if_needed(options, @node_opts, :scheme)
+        add_common_node_option_if_needed(options, @node_opts, :username)
         add_common_node_option_if_needed(options, @node_opts, :password)
         @options = options
       end
 
       def per_node_key
-        @node_opts.map { |opt| [NodeKey.build_from_host_port(opt[:host], opt[:port]), @options.merge(opt)] }
-                  .to_h
+        @node_opts.map do |opt|
+          node_key = NodeKey.build_from_host_port(opt[:host], opt[:port])
+          options = @options.merge(opt)
+          options = options.merge(host: @fixed_hostname) if @fixed_hostname && !@fixed_hostname.empty?
+          [node_key, options]
+        end.to_h
       end
 
       def use_replica?
@@ -63,7 +69,11 @@ class Redis
         raise InvalidClientOptionError, "Invalid uri scheme #{addr}" unless VALID_SCHEMES.include?(uri.scheme)
 
         db = uri.path.split('/')[1]&.to_i
-        { scheme: uri.scheme, password: uri.password, host: uri.host, port: uri.port, db: db }.reject { |_, v| v.nil? }
+        username = uri.user ? URI.decode_www_form_component(uri.user) : nil
+        password = uri.password ? URI.decode_www_form_component(uri.password) : nil
+
+        { scheme: uri.scheme, username: username, password: password, host: uri.host, port: uri.port, db: db }
+          .reject { |_, v| v.nil? || v == '' }
       rescue URI::InvalidURIError => err
         raise InvalidClientOptionError, err.message
       end
@@ -79,7 +89,7 @@ class Redis
 
       # Redis cluster node returns only host and port information.
       # So we should complement additional information such as:
-      #   scheme, password and so on.
+      #   scheme, username, password and so on.
       def add_common_node_option_if_needed(options, node_opts, key)
         return options if options[key].nil? && node_opts.first[key].nil?
 

data/lib/redis/cluster/slot_loader.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../errors'
-require_relative 'node_key'
+require 'redis/errors'
+require 'redis/cluster/node_key'
 
 class Redis
   class Cluster
@@ -10,16 +10,15 @@ class Redis
       module_function
 
       def load(nodes)
-        info = {}
-
-        nodes.each do |node|
-          info = fetch_slot_info(node)
-          info.empty? ? next : break
+        errors = nodes.map do |node|
+          begin
+            return fetch_slot_info(node)
+          rescue CannotConnectError, ConnectionError, CommandError => error
+            error
+          end
         end
 
-        return info unless info.empty?
-
-        raise CannotConnectError, 'Redis client could not connect to any cluster nodes'
+        raise InitialSetupError, errors
       end
 
       def fetch_slot_info(node)
@@ -27,8 +26,6 @@ class Redis
         node.call(%i[cluster slots])
             .flat_map { |arr| parse_slot_info(arr, default_ip: node.host) }
             .each_with_object(hash_with_default_arr) { |arr, h| h[arr[0]] << arr[1] }
-      rescue CannotConnectError, ConnectionError, CommandError
-        {} # can retry on another node
       end
 
       def parse_slot_info(arr, default_ip:)