class Resolver

def self.default(**options)
	System.resolver(**options)
end

def initialize(endpoint, timeout: nil, ndots: 1, search: nil, origin: nil, cache: Cache.new, **options) 
	@endpoint = endpoint
	
	# Legacy support for multiple endpoints:
	if @endpoint.is_a?(Array)
		warn "Using Array specifications for endpoint is deprecated. Please use IO::Endpoint::CompositeEndpoint instead.", uplevel: 1
		
		endpoints = @endpoint.map do |specification|
			::IO::Endpoint.public_send(specification[0], *specification[1..-1])
		end
		
		@endpoint = ::IO::Endpoint.composite(*endpoints)
	end
	
	if timeout
		@endpoint = @endpoint.with(timeout: timeout)
	end
	
	@ndots = ndots
	if search
		@search = search
	else
		@search = [nil]
	end
	
	if origin
		@search = [origin] + @search
	end
	
	@cache = cache
	@options = options
	
	@count = 0
end

parameter　name　String | Resolv::DNS::Name

The name to fully qualify.

def fully_qualified_names(name)
	return to_enum(:fully_qualified_names, name) unless block_given?
	
	name = Resolv::DNS::Name.create(name)
	
	if name.absolute?
		yield name
	else
		if @ndots <= name.length - 1
			yield name
		end
		
		@search.each do |domain|
			yield name.with_origin(domain)
		end
	end
end

def next_id!
	# Using sequential numbers for the query ID is generally a bad thing because over UDP they can be spoofed. 16-bits isn't hard to guess either, but over UDP we also use a random port, so this makes effectively 32-bits of entropy to guess per request.
	SecureRandom.random_number(2**16)
end

returns　Resolv::DNS::Message

The response from the server.

def query(name, resource_class = Resolv::DNS::Resource::IN::A)
	response = nil
	
	self.fully_qualified_names(name) do |fully_qualified_name|
		response = self.dispatch_query(fully_qualified_name, resource_class)
		
		break if response.rcode == Resolv::DNS::RCode::NoError
	end
	
	return response
end

def records_for(name, resource_classes)
	Console.debug(self) {"Looking up records for #{name.inspect} with #{resource_classes.inspect}."}
	resource_classes = Array(resource_classes)
	resources = nil
	
	self.fully_qualified_names(name) do |fully_qualified_name|
		resources = @cache.fetch(fully_qualified_name, resource_classes) do |name, resource_class|
			if response = self.dispatch_query(name, resource_class)
				response.answer.each do |name, ttl, record|
					Console.debug(self) {"Caching record for #{name.inspect} with #{record.class} and TTL #{ttl}."}
					@cache.store(name, resource_class, record)
				end
			end
		end
		
		break if resources.any?
	end
	
	return resources
end

def addresses_for(name, resource_classes = ADDRESS_RESOURCE_CLASSES)
	records = self.records_for(name, resource_classes)
	
	if records.empty?
		raise ResolutionFailure.new("Could not find any records for #{name.inspect}!")
	end
	
	addresses = []
	
	if records
		records.each do |record|
			if record.respond_to? :address
				addresses << record.address
			else
				# The most common case here is that record.class is IN::CNAME and we need to figure out the address. Usually the upstream DNS server would have replied with this too, and this will be loaded from the response if possible without requesting additional information:
				addresses += addresses_for(record.name, resource_classes)
			end
		end
	end
	
	if addresses.empty?
		raise ResolutionFailure.new("Could not find any addresses for #{name.inspect}!")
	end
	
	return addresses
end

def dispatch_query(name, resource_class)
	message = Resolv::DNS::Message.new(self.next_id!)
	message.rd = 1
	
	message.add_question(name, resource_class)
	
	return dispatch_request(message)
end

def dispatch_request(message)
	request = Request.new(message, @endpoint)
	error = nil
	
	request.each do |endpoint|
		Console.debug "[#{message.id}] Sending request #{message.question.inspect} to address #{endpoint.inspect}"
		
		begin
			response = try_server(request, endpoint)
			
			if valid_response(message, response)
				return response
			end
		rescue => error
			# Try the next server.
		end
	end
	
	if error
		raise error
	end
	
	return nil
end