Better handling of system resolver.

Author: ioquatix

fixtures/async/dns/test_server.rb

@@ -6,7 +6,7 @@
 module Async
 	module DNS
 		class TestServer < Server
-			def initialize(endpoint = DEFAULT_ENDPOINT, resolver: Resolver.new, **options)
+			def initialize(endpoint = DEFAULT_ENDPOINT, resolver: Resolver.default, **options)
 				super(endpoint, **options)
 
 				@resolver = resolver

lib/async/dns/resolver.rb

@@ -26,38 +26,51 @@ class ResolutionFailure < StandardError
 
 	# Resolve names to addresses using the DNS protocol.
 	class Resolver
+		# The default resolver for the system.
+		def self.default(**options)
+			System.resolver(**options)
+		end
+		
 		# Servers are specified in the same manor as options[:listen], e.g.
 		#   [:tcp/:udp, address, port]
 		# In the case of multiple servers, they will be checked in sequence.
-		def initialize(endpoint = nil, origin: nil, cache: Cache.new, timeout: nil, ndots: 1, search: [nil]) 
-			@endpoint = endpoint || System.default_nameservers
-			
-			if timeout
-				@endpoint = @endpoint.with(timeout: timeout)
-			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
 
-			@ndots = ndots
+			if timeout
+				@endpoint = @endpoint.with(timeout: timeout)
+			end
 
-			@search = search
+			@ndots = ndots
+			if search
+				@search = search
+			else
+				@search = [nil]
+			end
 
 			if origin
 				@search = [origin] + @search
 			end
 
 			@cache = cache
+			@options = options
+			
 			@count = 0
 		end
 
-		attr_accessor :origin
+		# The search domains, which are used to generate fully qualified names if required.
+		attr :search
 
 		# Generates a fully qualified name from a given name.
 		#

lib/async/dns/system.rb

@@ -98,29 +98,57 @@ def parse_hosts(io)
 			end
 		end
 
+		DEFAULT_TIMEOUT = 5.0
+		
 		# Parse the `resolv.conf` file and return a list of nameservers.
 		def self.parse_resolv_configuration(path)
 			nameservers = []
+			search = nil
+			ndots = 1
+			edns = nil
+			timeout = DEFAULT_TIMEOUT
+			
 			File.open(path) do |file|
 				file.each do |line|
 					# Remove any comments:
 					line.sub!(/[#;].*/, '')
 
 					# Extract resolv.conf command:
-					keyword, *args = line.split(/\s+/)
+					keyword, *arguments = line.split(/\s+/)
 
 					case keyword
 					when 'nameserver'
-						nameservers += args
+						nameservers.concat(arguments)
+					when 'domain', 'search'
+						search = arguments
+					when 'options'
+						arguments.each do |argument|
+							key, value = argument.split(':', 2)
+							
+							case key
+							when 'ndots'
+								ndots = value.to_i
+							when 'edns0'
+								edns = 0
+							when 'timeout'
+								timeout = value.to_f
+							end
+						end
 					end
 				end
 			end
 
-			return nameservers
+			return {
+				nameservers: nameservers,
+				search: search,
+				ndots: ndots,
+				edns: edns,
+				timeout: timeout,
+			}
 		end
 
 		# Get a list of standard nameserver connections which can be used for querying any standard servers that the system has been configured with.
-		def self.standard_connections(nameservers, **options)
+		def self.endpoint_for(nameservers, **options)
 			connections = []
 
 			nameservers.each do |host|
@@ -132,21 +160,33 @@ def self.standard_connections(nameservers, **options)
 		end
 
 		# Get a list of standard nameserver connections which can be used for querying any standard servers that the system has been configured with. There is no equivalent facility to use the `hosts` file at present.
-		def self.nameservers(**options)
+		def self.resolver(**options)
 			nameservers = []
 
 			if File.exist? RESOLV_CONF
-				nameservers = parse_resolv_configuration(RESOLV_CONF)
+				options.update(parse_resolv_configuration(RESOLV_CONF))
+				nameservers = options.delete(:nameservers)
 			elsif defined?(Win32::Resolv) and RUBY_PLATFORM =~ /mswin32|cygwin|mingw|bccwin/
 				search, nameservers = Win32::Resolv.get_resolv_info
+				options.update(search: search)
 			end
 
-			return standard_connections(nameservers, **options)
-		end
-		
-		# Get a list of default nameservers.
-		def self.default_nameservers
-			self.nameservers(timeout: 5.0)
+			if search = options[:search]
+				unless search.include?('.')
+					search << nil
+				end
+			else
+				options[:search] = [nil]
+			end
+			
+			timeout = options.delete(:timeout) || DEFAULT_TIMEOUT
+			endpoint = self.endpoint_for(nameservers, timeout: timeout)
+			
+			if block_given?
+				yield endpoint, **options
+			else
+				return Resolver.new(endpoint, **options)
+			end
 		end
 	end
 end

readme.md

@@ -26,7 +26,7 @@ Here is a simple example showing how to use the resolver:
 
 ``` ruby
 Async::Reactor.run do
-	resolver = Async::DNS::Resolver.new()
+	resolver = Async::DNS::System.resolver
 
 	addresses = resolver.addresses_for("www.google.com.")
 

test/async/dns/resolver.rb

@@ -10,7 +10,7 @@
 describe Async::DNS::Resolver do
 	include Sus::Fixtures::Async::ReactorContext
 
-	let(:resolver) {Async::DNS::Resolver.new}
+	let(:resolver) {Async::DNS::Resolver.default}
 
 	it "should result in non-existent domain" do
 		response = resolver.query('foobar.example.com', Resolv::DNS::Resource::IN::A)
@@ -64,7 +64,7 @@
 	end
 
 	with '#fully_qualified_name' do
-		let(:resolver) {Async::DNS::Resolver.new(origin: "foo.bar.")}
+		let(:resolver) {Async::DNS::Resolver.new(::IO::Endpoint::Generic.new, origin: "foo.bar.")}
 
 		it "should generate fully qualified domain name with specified origin" do
 			fully_qualified_names = resolver.fully_qualified_names("baz").to_a

test/async/dns/resolver/consistency.rb

@@ -78,7 +78,7 @@ def before
 		resolved_a = resolved_b = nil
 
 		async_dns_performance = Benchmark.measure do
-			resolver = Async::DNS::Resolver.new
+			resolver = Async::DNS::Resolver.default
 
 			resolved_a = DOMAINS.to_h do |domain|
 				[domain, resolver.addresses_for(domain)]

test/async/dns/system.rb

@@ -11,12 +11,8 @@
 describe Async::DNS::System do
 	include Sus::Fixtures::Async::ReactorContext
 
-	it "should have at least one namesever" do
-		expect(Async::DNS::System.nameservers).to have_attributes(size: be > 0)
-	end
-	
 	it "should respond to query for google.com" do
-		resolver = Async::DNS::Resolver.new(Async::DNS::System.nameservers)
+		resolver = Async::DNS::Resolver.default
 
 		response = resolver.query('google.com')
 

test/async/dns/transaction.rb

@@ -16,7 +16,7 @@
 	let(:query) {Resolv::DNS::Message.new(0)}
 	let(:question) {Resolv::DNS::Name.create("www.google.com.")}
 	let(:response) {Resolv::DNS::Message.new(0)}
-	let(:resolver) {Async::DNS::Resolver.new}
+	let(:resolver) {Async::DNS::Resolver.default}
 
 	it "should append an address" do
 		transaction = Async::DNS::Transaction.new(server, query, question, IN::A, response)