async-redis 0.9.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97fe8ed81d0096bd994cbbd3511fc3acb7c0c4629cfafdac47e5c237137083f1
-  data.tar.gz: c8a5b6a33efb6de45dc7cc2154b694fbd9337a14c485f85f1693bfeabbcc0f79
+  metadata.gz: da847e343c291506a20337eec6170867a0e0bf295b713ece60fd7f48928d873f
+  data.tar.gz: 2ea6e2720f556084f57415501a1964c0bb2a93a411a9cb52138dbb8ed141c45b
 SHA512:
-  metadata.gz: ad448e4900402ef3e974a247c27a6a8fa5bf65d47fda67b46260830ecfb76a185c86a03ff0c38cd18ae1d628a7ce332d6952e26704d357f3858458fe593fb49d
-  data.tar.gz: 83535dc337e792808e6e3033864e393cb075a5d709bd5a8c507577d8b792f0600388f98cd28997c891102c36dc79062c6327004359f51c4677b50bab42eced8a
+  metadata.gz: 9ac74325525a0dc00b06aaee1fa505566bce74f4806c07f26a8581ac7b20db79f11cbb052d6d598d02b7eec94aae6a142d88da00eb01e4b0a8d72e134ef5a798
+  data.tar.gz: 2b873fd8ee1cfffda74d301265ec9477a34dfe571d30d4c36d195cf39b089c22635bc74c07ade143ca46a5e169d0db226470a6149ce912be3b3da0db96e26b49

data/changes.md

@@ -0,0 +1,46 @@
+# v0.10.0
+
+## Cluster Client
+
+`Async::Redis::ClusterClient` is a new class that provides a high-level interface to a Redis Cluster. Due to the way clustering works, it does not provide the same interface as the `Async::Redis::Client` class. Instead, you must request an appropriate client for the key you are working with.
+
+```ruby
+endpoints = [
+	Async::Redis::Endpoint.parse("redis://redis-a"),
+	Async::Redis::Endpoint.parse("redis://redis-b"),
+	Async::Redis::Endpoint.parse("redis://redis-c"),
+]
+
+cluster_client = Async::Redis::ClusterClient.new(endpoints)
+
+cluster_client.clients_for("key") do |client|
+	puts client.get("key")
+end
+```
+
+## Sentinel Client
+
+The previous implementation `Async::Redis::SentinelsClient` has been replaced with `Async::Redis::SentinelClient`. This new class uses `Async::Redis::Endpoint` objects to represent the sentinels and the master.
+
+```ruby
+sentinels = [
+	Async::Redis::Endpoint.parse("redis://redis-sentinel-a"),
+	Async::Redis::Endpoint.parse("redis://redis-sentinel-b"),
+	Async::Redis::Endpoint.parse("redis://redis-sentinel-c"),
+]
+
+master_client = Async::Redis::SentinelClient.new(sentinels)
+slave_client = Async::Redis::SentinelClient.new(sentinels, role: :slave)
+
+master_client.session do |session|
+	session.set("key", "value")
+end
+
+slave_client.session do |session|
+	puts session.get("key")
+end
+```
+
+## Integration Tests
+
+Integration tests for Redis Cluster and Sentinel have been added, using `docker-compose` to start the required services and run the tests. These tests are not part of the default test suite and must be run separately. See the documentation in the `sentinel/` and `cluster/` directories for more information.

data/lib/async/redis/client.rb

@@ -26,6 +26,65 @@ module Async
 		class Client
 			include ::Protocol::Redis::Methods
 			
+			module Methods
+				def subscribe(*channels)
+					context = Context::Subscribe.new(@pool, channels)
+					
+					return context unless block_given?
+					
+					begin
+						yield context
+					ensure
+						context.close
+					end
+				end
+				
+				def transaction(&block)
+					context = Context::Transaction.new(@pool)
+					
+					return context unless block_given?
+					
+					begin
+						yield context
+					ensure
+						context.close
+					end
+				end
+				
+				alias multi transaction
+				
+				def pipeline(&block)
+					context = Context::Pipeline.new(@pool)
+					
+					return context unless block_given?
+					
+					begin
+						yield context
+					ensure
+						context.close
+					end
+				end
+				
+				# Deprecated.
+				alias nested pipeline
+				
+				def call(*arguments)
+					@pool.acquire do |connection|
+						connection.write_request(arguments)
+						
+						connection.flush
+						
+						return connection.read_response
+					end
+				end
+				
+				def close
+					@pool.close
+				end
+			end
+			
+			include Methods
+			
 			def initialize(endpoint = Endpoint.local, protocol: endpoint.protocol, **options)
 				@endpoint = endpoint
 				@protocol = protocol
@@ -38,8 +97,8 @@ module Async
 			
 			# @return [client] if no block provided.
 			# @yield [client, task] yield the client in an async task.
-			def self.open(*arguments, &block)
-				client = self.new(*arguments)
+			def self.open(*arguments, **options, &block)
+				client = self.new(*arguments, **options)
 				
 				return client unless block_given?
 				
@@ -52,61 +111,6 @@ module Async
 				end.wait
 			end
 			
-			def close
-				@pool.close
-			end
-			
-			def subscribe(*channels)
-				context = Context::Subscribe.new(@pool, channels)
-				
-				return context unless block_given?
-				
-				begin
-					yield context
-				ensure
-					context.close
-				end
-			end
-			
-			def transaction(&block)
-				context = Context::Transaction.new(@pool)
-				
-				return context unless block_given?
-				
-				begin
-					yield context
-				ensure
-					context.close
-				end
-			end
-			
-			alias multi transaction
-			
-			def pipeline(&block)
-				context = Context::Pipeline.new(@pool)
-				
-				return context unless block_given?
-				
-				begin
-					yield context
-				ensure
-					context.close
-				end
-			end
-			
-			# Deprecated.
-			alias nested pipeline
-			
-			def call(*arguments)
-				@pool.acquire do |connection|
-					connection.write_request(arguments)
-					
-					connection.flush
-					
-					return connection.read_response
-				end
-			end
-			
 			protected
 			
 			def connect(**options)

data/lib/async/redis/cluster_client.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2020, by David Ortiz.
+# Copyright, 2023-2024, by Samuel Williams.
+
+require_relative 'client'
+require 'io/stream'
+
+module Async
+	module Redis
+		class ClusterClient
+			class ReloadError < StandardError
+			end
+			
+			class SlotError < StandardError
+			end
+			
+			Node = Struct.new(:id, :endpoint, :role, :health, :client)
+			
+			class RangeMap
+				def initialize
+					@ranges = []
+				end
+				
+				def add(range, value)
+					@ranges << [range, value]
+					
+					return value
+				end
+				
+				def find(key)
+					@ranges.each do |range, value|
+						return value if range.include?(key)
+					end
+					
+					if block_given?
+						return yield
+					end
+					
+					return nil
+				end
+				
+				def each
+					@ranges.each do |range, value|
+						yield value
+					end
+				end
+				
+				def clear
+					@ranges.clear
+				end
+			end
+			
+			# Create a new instance of the cluster client.
+			#
+			# @property endpoints [Array(Endpoint)] The list of cluster endpoints.
+			def initialize(endpoints, **options)
+				@endpoints = endpoints
+				@shards = nil
+			end
+			
+			def clients_for(*keys, role: :master, attempts: 3)
+				slots = slots_for(keys)
+				
+				slots.each do |slot, keys|
+					yield client_for(slot, role), keys
+				end
+			rescue ServerError => error
+				Console.warn(self, error)
+				
+				if error.message =~ /MOVED|ASK/
+					reload_cluster!
+					
+					attempts -= 1
+					
+					retry if attempts > 0
+					
+					raise
+				else
+					raise
+				end
+			end
+			
+			def client_for(slot, role = :master)
+				unless @shards
+					reload_cluster!
+				end
+				
+				if nodes = @shards.find(slot)
+					nodes = nodes.select{|node| node.role == role}
+				else
+					raise SlotError, "No nodes found for slot #{slot}"
+				end
+				
+				if node = nodes.sample
+					return (node.client ||= Client.new(node.endpoint))
+				end
+			end
+			
+			protected
+			
+			def reload_cluster!(endpoints = @endpoints)
+				@endpoints.each do |endpoint|
+					client = Client.new(endpoint)
+					
+					shards = RangeMap.new
+					endpoints = []
+					
+					client.call('CLUSTER', 'SHARDS').each do |shard|
+						shard = shard.each_slice(2).to_h
+						
+						slots = shard['slots']
+						range = Range.new(*slots)
+						
+						nodes = shard['nodes'].map do |node|
+							node = node.each_slice(2).to_h
+							endpoint = Endpoint.remote(node['ip'], node['port'])
+							
+							# Collect all endpoints:
+							endpoints << endpoint
+							
+							Node.new(node['id'], endpoint, node['role'].to_sym, node['health'].to_sym)
+						end
+						
+						shards.add(range, nodes)
+					end
+					
+					@shards = shards
+					# @endpoints = @endpoints | endpoints
+					
+					return true
+				rescue Errno::ECONNREFUSED
+					next
+				end
+				
+				raise ReloadError, "Failed to reload cluster configuration."
+			end
+			
+			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
+			
+			# This is the CRC16 algorithm used by Redis Cluster to hash keys.
+			# Copied from https://github.com/antirez/redis-rb-cluster/blob/master/crc16.rb
+			def crc16(bytes)
+				sum = 0
+				
+				bytes.each_byte do |byte|
+					sum = ((sum << 8) & 0xffff) ^ XMODEM_CRC16_LOOKUP[((sum >> 8) ^ byte) & 0xff]
+				end
+				
+				return sum
+			end
+			
+			public
+			
+			HASH_SLOTS = 16_384
+			
+			# Return Redis::Client for a given key.
+			# Modified from https://github.com/antirez/redis-rb-cluster/blob/master/cluster.rb#L104-L117
+			def slot_for(key)
+				key = key.to_s
+				
+				if s = key.index('{')
+					if e = key.index('}', s + 1) and e != s + 1
+						key = key[s + 1..e - 1]
+					end
+				end
+				
+				return crc16(key) % HASH_SLOTS
+			end
+			
+			def slots_for(keys)
+				slots = Hash.new{|hash, key| hash[key] = []}
+				
+				keys.each do |key|
+					slots[slot_for(key)] << key
+				end
+				
+				return slots
+			end
+		end
+	end
+end

data/lib/async/redis/endpoint.rb

@@ -23,7 +23,11 @@ module Async
 			
 			def self.local(**options)
 				self.new(LOCALHOST, **options)
-			end	
+			end
+			
+			def self.remote(host, port = 6379, **options)
+				self.new(URI.parse("redis://#{host}:#{port}"), **options)
+			end
 			
 			SCHEMES = {
 				'redis' => URI::Generic,
@@ -40,7 +44,7 @@ module Async
 			#
 			# @parameter scheme [String] The scheme to use, e.g. "redis" or "rediss".
 			# @parameter hostname [String] The hostname to connect to (or bind to).
-			# @parameter *options [Hash] Additional options, passed to {#initialize}.
+			# @parameter options [Hash] Additional options, passed to {#initialize}.
 			def self.for(scheme, hostname, credentials: nil, port: nil, database: nil, **options)
 				uri_klass = SCHEMES.fetch(scheme.downcase) do
 					raise ArgumentError, "Unsupported scheme: #{scheme.inspect}"
@@ -70,9 +74,10 @@ module Async
 			#
 			# @parameter url [URI] The URL to connect to.
 			# @parameter endpoint [Endpoint] The underlying endpoint to use.
-			# @parameter scheme [String] The scheme to use, e.g. "redis" or "rediss".
-			# @parameter hostname [String] The hostname to connect to (or bind to), overrides the URL hostname (used for SNI).
-			# @parameter port [Integer] The port to bind to, overrides the URL port.
+			# @option scheme [String] The scheme to use, e.g. "redis" or "rediss".
+			# @option hostname [String] The hostname to connect to (or bind to), overrides the URL hostname (used for SNI).
+			# @option port [Integer] The port to bind to, overrides the URL port.
+			# @option ssl_context [OpenSSL::SSL::SSLContext] The SSL context to use for secure connections.
 			def initialize(url, endpoint = nil, **options)
 				super(**options)
 				

data/lib/async/redis/sentinel_client.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2020, by David Ortiz.
+# Copyright, 2023-2024, by Samuel Williams.
+
+require_relative 'client'
+require 'io/stream'
+
+module Async
+	module Redis
+		class SentinelClient
+			DEFAULT_MASTER_NAME = 'mymaster'
+			
+			include ::Protocol::Redis::Methods
+			include Client::Methods
+			
+			# Create a new instance of the SentinelClient.
+			#
+			# @property endpoints [Array(Endpoint)] The list of sentinel endpoints.
+			# @property master_name [String] The name of the master instance, defaults to 'mymaster'.
+			# @property role [Symbol] The role of the instance that you want to connect to, either `:master` or `:slave`.
+			# @property protocol [Protocol] The protocol to use when connecting to the actual Redis server, defaults to {Protocol::RESP2}.
+			def initialize(endpoints, master_name: DEFAULT_MASTER_NAME, role: :master, protocol: Protocol::RESP2, **options)
+				@endpoints = endpoints
+				@master_name = master_name
+				@role = role
+				@protocol = protocol
+				
+				# A cache of sentinel connections.
+				@sentinels = {}
+				
+				@pool = connect(**options)
+			end
+			
+			# @attribute [String] The name of the master instance.
+			attr :master_name
+			
+			# @attribute [Symbol] The role of the instance that you want to connect to.
+			attr :role
+			
+			def resolve_address(role = @role)
+				case role
+				when :master
+					resolve_master
+				when :slave
+					resolve_slave
+				else
+					raise ArgumentError, "Unknown instance role #{role}"
+				end => address
+				
+				Console.debug(self, "Resolved #{@role} address: #{address}")
+				
+				address or raise RuntimeError, "Unable to fetch #{role} via Sentinel."
+			end
+			
+			def close
+				super
+				
+				@sentinels.each do |_, client|
+					client.close
+				end
+			end
+			
+			def failover(name = @master_name)
+				sentinels do |client|
+					return client.call('SENTINEL', 'FAILOVER', name)
+				end
+			end
+			
+			def masters
+				sentinels do |client|
+					return client.call('SENTINEL', 'MASTERS').map{|fields| fields.each_slice(2).to_h}
+				end
+			end
+			
+			def master(name = @master_name)
+				sentinels do |client|
+					return client.call('SENTINEL', 'MASTER', name).each_slice(2).to_h
+				end
+			end
+			
+			def resolve_master
+				sentinels do |client|
+					begin
+						address = client.call('SENTINEL', 'GET-MASTER-ADDR-BY-NAME', @master_name)
+					rescue Errno::ECONNREFUSED
+						next
+					end
+					
+					return Endpoint.remote(address[0], address[1]) if address
+				end
+				
+				return nil
+			end
+			
+			def resolve_slave
+				sentinels do |client|
+					begin
+						reply = client.call('SENTINEL', 'SLAVES', @master_name)
+					rescue Errno::ECONNREFUSED
+						next
+					end
+					
+					slaves = available_slaves(reply)
+					next if slaves.empty?
+					
+					slave = select_slave(slaves)
+					return Endpoint.remote(slave['ip'], slave['port'])
+				end
+				
+				return nil
+			end
+			
+			protected
+			
+			# Override the parent method. The only difference is that this one needs to resolve the master/slave address.
+			def connect(**options)
+				Async::Pool::Controller.wrap(**options) do
+					endpoint = resolve_address
+					peer = endpoint.connect
+					stream = ::IO::Stream(peer)
+					
+					@protocol.client(stream)
+				end
+			end
+			
+			def sentinels
+				@endpoints.map do |endpoint|
+					@sentinels[endpoint] ||= Client.new(endpoint)
+					
+					yield @sentinels[endpoint]
+				end
+			end
+			
+			def available_slaves(reply)
+				# The reply is an array with the format: [field1, value1, field2,
+				# value2, etc.].
+				# When a slave is marked as down by the sentinel, the "flags" field
+				# (comma-separated array) contains the "s_down" value.
+				slaves = reply.map{|fields| fields.each_slice(2).to_h}
+				
+				slaves.reject do |slave|
+					slave['flags'].split(',').include?('s_down')
+				end
+			end
+			
+			def select_slave(available_slaves)
+				available_slaves.sample
+			end
+		end
+	end
+end

data/lib/async/redis/version.rb

@@ -5,6 +5,6 @@
 
 module Async
 	module Redis
-		VERSION = "0.9.0"
+		VERSION = "0.10.1"
 	end
 end

data/lib/async/redis.rb

@@ -6,4 +6,6 @@
 
 require_relative 'redis/version'
 require_relative 'redis/client'
-require_relative 'redis/sentinels'
+
+require_relative 'redis/cluster_client'
+require_relative 'redis/sentinel_client'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-redis
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Samuel Williams
@@ -48,7 +48,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2024-08-16 00:00:00.000000000 Z
+date: 2024-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -126,8 +126,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- changes.md
 - lib/async/redis.rb
 - lib/async/redis/client.rb
+- lib/async/redis/cluster_client.rb
 - lib/async/redis/context/generic.rb
 - lib/async/redis/context/pipeline.rb
 - lib/async/redis/context/subscribe.rb
@@ -137,7 +139,7 @@ files:
 - lib/async/redis/protocol/authenticated.rb
 - lib/async/redis/protocol/resp2.rb
 - lib/async/redis/protocol/selected.rb
-- lib/async/redis/sentinels.rb
+- lib/async/redis/sentinel_client.rb
 - lib/async/redis/version.rb
 - license.md
 - readme.md

data/lib/async/redis/sentinels.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the MIT License.
-# Copyright, 2020, by David Ortiz.
-# Copyright, 2023-2024, by Samuel Williams.
-
-require 'io/stream'
-
-module Async
-	module Redis
-		class SentinelsClient < Client
-			def initialize(master_name, sentinels, role = :master, protocol = Protocol::RESP2, **options)
-				@master_name = master_name
-				
-				@sentinel_endpoints = sentinels.map do |sentinel|
-					::IO::Endpoint.tcp(sentinel[:host], sentinel[:port])
-				end
-				
-				@role = role
-				@protocol = protocol
-				@pool = connect(**options)
-			end
-			
-			private
-			
-			# Override the parent method. The only difference is that this one needs
-			# to resolve the master/slave address.
-			def connect(**options)
-				Async::Pool::Controller.wrap(**options) do
-					endpoint = resolve_address
-					peer = endpoint.connect
-					stream = ::IO::Stream(peer)
-					
-					@protocol.client(stream)
-				end
-			end
-			
-			def resolve_address
-				case @role
-				when :master
-					resolve_master
-				when :slave
-					resolve_slave
-				else
-					raise ArgumentError, "Unknown instance role #{@role}"
-				end => address
-				
-				address or raise RuntimeError, "Unable to fetch #{@role} via Sentinel."
-			end
-			
-			def resolve_master
-				@sentinel_endpoints.each do |sentinel_endpoint|
-					client = Client.new(sentinel_endpoint, protocol: @protocol)
-					
-					begin
-						address = client.call('sentinel', 'get-master-addr-by-name', @master_name)
-					rescue Errno::ECONNREFUSED
-						next
-					end
-					
-					return ::IO::Endpoint.tcp(address[0], address[1]) if address
-				end
-				
-				nil
-			end
-			
-			def resolve_slave
-				@sentinel_endpoints.each do |sentinel_endpoint|
-					client = Client.new(sentinel_endpoint, protocol: @protocol)
-					
-					begin
-						reply = client.call('sentinel', 'slaves', @master_name)
-					rescue Errno::ECONNREFUSED
-						next
-					end
-					
-					slaves = available_slaves(reply)
-					next if slaves.empty?
-					
-					slave = select_slave(slaves)
-					return ::IO::Endpoint.tcp(slave['ip'], slave['port'])
-				end
-				
-				nil
-			end
-			
-			def available_slaves(reply)
-				# The reply is an array with the format: [field1, value1, field2,
-				# value2, etc.].
-				# When a slave is marked as down by the sentinel, the "flags" field
-				# (comma-separated array) contains the "s_down" value.
-				slaves = reply.map{|fields| fields.each_slice(2).to_h}
-				
-				slaves.reject do |slave|
-					slave['flags'].split(',').include?('s_down')
-				end
-			end
-			
-			def select_slave(available_slaves)
-				available_slaves.sample
-			end
-		end
-	end
-end