async-redis 0.8.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c61c1f4d04e59d7a09f58429a04438e674d7839bc6d6411b3fc33668d4068c4b
-  data.tar.gz: f13579f444972e6b5a7d1388f37d20d74978e867130b5cdad303e829905a6ca6
+  metadata.gz: 31704f6caaeffba85223e9917ac746128c05862b53738ab42d03f0c91bd808c3
+  data.tar.gz: 72afd9739ce773d441870c238e9f2600a6ac3e3d46b13bb66c3a7f3febf3f4d6
 SHA512:
-  metadata.gz: 99b7e9bb4091f09a6b51a1216a44b69ebd63918df6755d447f327b69bdf148cbf91e7a1b1a5adbe75ccff93f36be93cdf0d5034bed624743fcac23524d285df7
-  data.tar.gz: f9afbc599da80472df731cb370c77422184c3a41a4ab0efd0df638fad31f9a68fa7cde775d7451826cf781c1d29e9c86d3d27c0a94a6b1605b121dd33dddd13f
+  metadata.gz: 5b12190eab39bba378d6ca1793abd3e56ab513a13af4bedfbb332d3d7e869d5b61c9d3958eaa96f22987e341e50b6acdc018c84c1d88effea3fee72fd132a7fe
+  data.tar.gz: '086307e4ec9c27d407cce2e61e99c6b4712e1d1fb3b8bca660c7e1a4270a9aa9061c36dd5a801e3edfa42eb52a6f41a41c858830ccc7e673e38917d0a4f9e700'

data/lib/async/redis/client.rb

@@ -10,7 +10,7 @@
 require_relative 'context/pipeline'
 require_relative 'context/transaction'
 require_relative 'context/subscribe'
-require_relative 'protocol/resp2'
+require_relative 'endpoint'
 
 require 'io/endpoint/host_endpoint'
 require 'async/pool/controller'
@@ -23,14 +23,69 @@ module Async
 		# Legacy.
 		ServerError = ::Protocol::Redis::ServerError
 		
-		def self.local_endpoint(port: 6379)
-			::IO::Endpoint.tcp('localhost', port)
-		end
-		
 		class Client
 			include ::Protocol::Redis::Methods
 			
-			def initialize(endpoint = Redis.local_endpoint, protocol: Protocol::RESP2, **options)
+			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
 				
@@ -42,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?
 				
@@ -56,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,211 @@
+# 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
+			
+			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
+				
+				nodes = @shards.find(slot)
+				
+				nodes = nodes.select{|node| node.role == role}
+				
+				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, exclude_end: false)
+						
+						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
+			
+			HASH_SLOTS = 16_384
+			
+			public
+			
+			# 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/context/pipeline.rb

@@ -2,7 +2,7 @@
 
 # Released under the MIT License.
 # Copyright, 2019, by David Ortiz.
-# Copyright, 2019-2023, by Samuel Williams.
+# Copyright, 2019-2024, by Samuel Williams.
 # Copyright, 2022, by Tim Willard.
 
 require_relative 'generic'
@@ -22,8 +22,8 @@ module Async
 					end
 					
 					# This method just accumulates the commands and their params.
-					def call(command, *arguments)
-						@pipeline.call(command, *arguments)
+					def call(...)
+						@pipeline.call(...)
 						
 						@pipeline.flush(1)
 						
@@ -46,6 +46,15 @@ module Async
 					end
 				end
 				
+				def collect
+					if block_given?
+						flush
+						yield
+					end
+					
+					@count.times.map{read_response}
+				end
+				
 				def sync
 					@sync ||= Sync.new(self)
 				end
@@ -73,15 +82,9 @@ module Async
 					end
 				end
 				
-				def collect
-					yield
-					
-					@count.times.map{read_response}
-				end
-				
 				def close
 					flush
-			  ensure
+				ensure
 					super
 				end
 			end

data/lib/async/redis/endpoint.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'io/endpoint'
+require 'io/endpoint/host_endpoint'
+require 'io/endpoint/ssl_endpoint'
+
+require_relative 'protocol/resp2'
+require_relative 'protocol/authenticated'
+require_relative 'protocol/selected'
+
+module Async
+	module Redis
+		def self.local_endpoint(**options)
+			Endpoint.local(**options)
+		end
+		
+		# Represents a way to connect to a remote Redis server.
+		class Endpoint < ::IO::Endpoint::Generic
+			LOCALHOST = URI.parse("redis://localhost").freeze
+			
+			def self.local(**options)
+				self.new(LOCALHOST, **options)
+			end
+			
+			def self.remote(host, port = 6379, **options)
+				self.new(URI.parse("redis://#{host}:#{port}"), **options)
+			end
+			
+			SCHEMES = {
+				'redis' => URI::Generic,
+				'rediss' => URI::Generic,
+			}
+			
+			def self.parse(string, endpoint = nil, **options)
+				url = URI.parse(string).normalize
+				
+				return self.new(url, endpoint, **options)
+			end
+			
+			# Construct an endpoint with a specified scheme, hostname, optional path, and options.
+			#
+			# @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}.
+			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}"
+				end
+				
+				if database
+					path = "/#{database}"
+				end
+				
+				self.new(
+					uri_klass.new(scheme, credentials&.join(":"), hostname, port, nil, path, nil, nil, nil).normalize,
+					**options
+				)
+			end
+			
+			# Coerce the given object into an endpoint.
+			# @parameter url [String | Endpoint] The URL or endpoint to convert.
+			def self.[](object)
+				if object.is_a?(self)
+					return object
+				else
+					self.parse(object.to_s)
+				end
+			end
+			
+			# Create a new endpoint.
+			#
+			# @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.
+			def initialize(url, endpoint = nil, **options)
+				super(**options)
+				
+				raise ArgumentError, "URL must be absolute (include scheme, host): #{url}" unless url.absolute?
+				
+				@url = url
+				
+				if endpoint
+					@endpoint = self.build_endpoint(endpoint)
+				else
+					@endpoint = nil
+				end
+			end
+			
+			def to_url
+				url = @url.dup
+				
+				unless default_port?
+					url.port = self.port
+				end
+				
+				return url
+			end
+			
+			def to_s
+				"\#<#{self.class} #{self.to_url} #{@options}>"
+			end
+			
+			def inspect
+				"\#<#{self.class} #{self.to_url} #{@options.inspect}>"
+			end
+			
+			attr :url
+			
+			def address
+				endpoint.address
+			end
+			
+			def secure?
+				['rediss'].include?(self.scheme)
+			end
+			
+			def protocol
+				protocol = @options.fetch(:protocol, Protocol::RESP2)
+				
+				if credentials = self.credentials
+					protocol = Protocol::Authenticated.new(credentials, protocol)
+				end
+				
+				if database = self.database
+					protocol = Protocol::Selected.new(database, protocol)
+				end
+				
+				return protocol
+			end
+			
+			def default_port
+				6379
+			end
+			
+			def default_port?
+				port == default_port
+			end
+			
+			def port
+				@options[:port] || @url.port || default_port
+			end
+			
+			# The hostname is the server we are connecting to:
+			def hostname
+				@options[:hostname] || @url.hostname
+			end
+			
+			def scheme
+				@options[:scheme] || @url.scheme
+			end
+			
+			def database
+				@options[:database] || extract_database(@url.path)
+			end
+			
+			private def extract_database(path)
+				if path =~ /\/(\d+)$/
+					return $1.to_i
+				end
+			end
+			
+			def credentials
+				@options[:credentials] || extract_userinfo(@url.userinfo)
+			end
+			
+			private def extract_userinfo(userinfo)
+				if userinfo
+					credentials = userinfo.split(":").reject(&:empty?)
+					
+					if credentials.any?
+						return credentials
+					end
+				end
+			end
+			
+			def localhost?
+				@url.hostname =~ /^(.*?\.)?localhost\.?$/
+			end
+			
+			# We don't try to validate peer certificates when talking to localhost because they would always be self-signed.
+			def ssl_verify_mode
+				if self.localhost?
+					OpenSSL::SSL::VERIFY_NONE
+				else
+					OpenSSL::SSL::VERIFY_PEER
+				end
+			end
+			
+			def ssl_context
+				@options[:ssl_context] || OpenSSL::SSL::SSLContext.new.tap do |context|
+					context.set_params(
+						verify_mode: self.ssl_verify_mode
+					)
+				end
+			end
+			
+			def build_endpoint(endpoint = nil)
+				endpoint ||= tcp_endpoint
+				
+				if secure?
+					# Wrap it in SSL:
+					return ::IO::Endpoint::SSLEndpoint.new(endpoint,
+						ssl_context: self.ssl_context,
+						hostname: @url.hostname,
+						timeout: self.timeout,
+					)
+				end
+				
+				return endpoint
+			end
+			
+			def endpoint
+				@endpoint ||= build_endpoint
+			end
+			
+			def endpoint=(endpoint)
+				@endpoint = build_endpoint(endpoint)
+			end
+			
+			def bind(*arguments, &block)
+				endpoint.bind(*arguments, &block)
+			end
+			
+			def connect(&block)
+				endpoint.connect(&block)
+			end
+			
+			def each
+				return to_enum unless block_given?
+				
+				self.tcp_endpoint.each do |endpoint|
+					yield self.class.new(@url, endpoint, **@options)
+				end
+			end
+			
+			def key
+				[@url, @options]
+			end
+			
+			def eql? other
+				self.key.eql? other.key
+			end
+			
+			def hash
+				self.key.hash
+			end
+			
+			protected
+			
+			def tcp_options
+				options = @options.dup
+				
+				options.delete(:scheme)
+				options.delete(:port)
+				options.delete(:hostname)
+				options.delete(:ssl_context)
+				options.delete(:protocol)
+				
+				return options
+			end
+			
+			def tcp_endpoint
+				::IO::Endpoint.tcp(self.hostname, port, **tcp_options)
+			end
+		end
+	end
+end

data/lib/async/redis/protocol/authenticated.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'protocol/redis'
+
+module Async
+	module Redis
+		module Protocol
+			# Executes AUTH after the user has established a connection.
+			class Authenticated
+				# Authentication has failed for some reason.
+				class AuthenticationError < StandardError
+				end
+				
+				# Create a new authenticated protocol.
+				#
+				# @parameter credentials [Array] The credentials to use for authentication.
+				# @parameter protocol [Object] The delegated protocol for connecting.
+				def initialize(credentials, protocol = Async::Redis::Protocol::RESP2)
+					@credentials = credentials
+					@protocol = protocol
+				end
+				
+				attr :credentials
+				
+				# Create a new client and authenticate it.
+				def client(stream)
+					client = @protocol.client(stream)
+					
+					client.write_request(["AUTH", *@credentials])
+					response = client.read_response
+					
+					if response != "OK"
+						raise AuthenticationError, "Could not authenticate: #{response}"
+					end
+					
+					return client
+				end
+			end
+		end
+	end
+end

data/lib/async/redis/protocol/selected.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'protocol/redis'
+
+module Async
+	module Redis
+		module Protocol
+			# Executes AUTH after the user has established a connection.
+			class Selected
+				# Authentication has failed for some reason.
+				class SelectionError < StandardError
+				end
+				
+				# Create a new authenticated protocol.
+				#
+				# @parameter index [Integer] The database index to select.
+				# @parameter protocol [Object] The delegated protocol for connecting.
+				def initialize(index, protocol = Async::Redis::Protocol::RESP2)
+					@index = index
+					@protocol = protocol
+				end
+				
+				attr :index
+				
+				# Create a new client and authenticate it.
+				def client(stream)
+					client = @protocol.client(stream)
+					
+					client.write_request(["SELECT", @index])
+					response = client.read_response
+					
+					if response != "OK"
+						raise SelectionError, "Could not select database: #{response}"
+					end
+					
+					return client
+				end
+			end
+		end
+	end
+end

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

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2018-2024, by Samuel Williams.
 
 module Async
 	module Redis
-		VERSION = "0.8.1"
+		VERSION = "0.10.0"
 	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'

data/readme.md

@@ -6,9 +6,9 @@ An asynchronous client for Redis including TLS. Support for streaming requests a
 
 ## Usage
 
-Please see the [project documentation](https://github.com/socketry/async-redis) for more details.
+Please see the [project documentation](https://socketry.github.io/async-redis/) for more details.
 
-  - [Getting Started](https://github.com/socketry/async-redisguides/getting-started/index) - This guide explains how to use the `async-redis` gem to connect to a Redis server and perform basic operations.
+  - [Getting Started](https://socketry.github.io/async-redis/guides/getting-started/index) - This guide explains how to use the `async-redis` gem to connect to a Redis server and perform basic operations.
 
 ## Contributing
 
@@ -22,8 +22,8 @@ We welcome contributions to this project.
 
 ### Developer Certificate of Origin
 
-This project uses the [Developer Certificate of Origin](https://developercertificate.org/). All contributors to this project must agree to this document to have their contributions accepted.
+In order to protect users of this project, we require all contributors to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed.
 
-### Contributor Covenant
+### Community Guidelines
 
-This project is governed by the [Contributor Covenant](https://www.contributor-covenant.org/). All contributors and participants agree to abide by its terms.
+This project is best served by a collaborative and respectful environment. Treat each other professionally, respect differing viewpoints, and engage constructively. Harassment, discrimination, or harmful behavior is not tolerated. Communicate clearly, listen actively, and support one another. If any issues arise, please inform the project maintainers.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-redis
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -48,28 +48,22 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2024-04-24 00:00:00.000000000 Z
+date: 2024-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.8'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '2.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.8'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '2.10'
 - !ruby/object:Gem::Dependency
   name: async-pool
   requirement: !ruby/object:Gem::Requirement
@@ -118,14 +112,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '0.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '0.9'
 description:
 email:
 executables: []
@@ -134,13 +128,17 @@ extra_rdoc_files: []
 files:
 - 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
 - lib/async/redis/context/transaction.rb
+- lib/async/redis/endpoint.rb
 - lib/async/redis/key.rb
+- lib/async/redis/protocol/authenticated.rb
 - lib/async/redis/protocol/resp2.rb
-- lib/async/redis/sentinels.rb
+- lib/async/redis/protocol/selected.rb
+- lib/async/redis/sentinel_client.rb
 - lib/async/redis/version.rb
 - license.md
 - readme.md
@@ -148,6 +146,7 @@ homepage: https://github.com/socketry/async-redis
 licenses:
 - MIT
 metadata:
+  documentation_uri: https://socketry.github.io/async-redis/
   source_code_uri: https://github.com/socketry/async-redis.git
 post_install_message:
 rdoc_options: []
@@ -164,7 +163,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: A Redis client library.

data/lib/async/redis/sentinels.rb

@@ -1,97 +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
-				address = case @role
-									when :master then resolve_master
-									when :slave then resolve_slave
-									else raise ArgumentError, "Unknown instance role #{@role}"
-									end
-
-				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)
-
-					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)
-
-					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(slaves_cmd_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_cmd_reply.map { |s| s.each_slice(2).to_h }
-						            .reject { |s| s.fetch('flags').split(',').include?('s_down') }
-			end
-
-			def select_slave(available_slaves)
-				available_slaves.sample
-			end
-		end
-	end
-end