class SentinelClient

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 = make_pool(**options)
end

attribute　String

The name of the master instance.

attribute　Symbol

The role of the instance that you want to connect to.

parameter　role　Symbol

The role to resolve (:master or :slave).

returns　Endpoint

The resolved endpoint address.

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

parameter　name　String

The name of the master to failover.

returns　Object

The result of the failover command.

def failover(name = @master_name)
	sentinels do |client|
		return client.call("SENTINEL", "FAILOVER", name)
	end
end

returns　Array(Hash)

Array of master information hashes.

def masters
	sentinels do |client|
		return client.call("SENTINEL", "MASTERS").map{|fields| fields.each_slice(2).to_h}
	end
end

parameter　name　String

The name of the master.

returns　Hash

The master information hash.

def master(name = @master_name)
	sentinels do |client|
		return client.call("SENTINEL", "MASTER", name).each_slice(2).to_h
	end
end

returns　Endpoint | Nil

The master endpoint or nil if not found.

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

returns　Endpoint | Nil

A slave endpoint or nil if not found.

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

def make_pool(**options)
	self.assign_default_tags(options[:tags] ||= {})
	
	Async::Pool::Controller.wrap(**options) do
		endpoint = resolve_address
		peer = endpoint.connect
		stream = ::IO::Stream(peer)
		
		@protocol.client(stream)
	end
end