class Async::DNS::Resolver

Constants

DEFAULT_DELAY

10ms wait between making requests. Override with `options`

DEFAULT_RETRIES

Try a given request 10 times before failing. Override with `options`.

DEFAULT_TIMEOUT

Wait for up to 5 seconds for a response. Override with `options`

Attributes

origin[RW]

Public Class Methods

new(endpoints, origin: nil, logger: Console.logger, timeout: DEFAULT_TIMEOUT) click to toggle source

Servers are specified in the same manor as options, e.g.

[:tcp/:udp, address, port]

In the case of multiple servers, they will be checked in sequence.

# File lib/async/dns/resolver.rb, line 49
def initialize(endpoints, origin: nil, logger: Console.logger, timeout: DEFAULT_TIMEOUT)
        @endpoints = endpoints
        
        @origin = origin
        @logger = logger
        @timeout = timeout
end

Public Instance Methods

addresses_for(name, resource_class = Resolv::DNS::Resource::IN::A, options = {}) click to toggle source

Yields a list of `Resolv::IPv4` and `Resolv::IPv6` addresses for the given `name` and `resource_class`. Raises a ResolutionFailure if no severs respond.

# File lib/async/dns/resolver.rb, line 93
def addresses_for(name, resource_class = Resolv::DNS::Resource::IN::A, options = {})
        name = fully_qualified_name(name)
        
        cache = options.fetch(:cache, {})
        retries = options.fetch(:retries, DEFAULT_RETRIES)
        delay = options.fetch(:delay, DEFAULT_DELAY)
        
        records = lookup(name, resource_class, cache) do |lookup_name, lookup_resource_class|
                response = nil
                
                retries.times do |i|
                        # Wait 10ms before trying again:
                        sleep delay if delay and i > 0
                        
                        response = query(lookup_name, lookup_resource_class)
                        
                        break if response
                end
                
                response or raise ResolutionFailure.new("Could not resolve #{name} after #{retries} attempt(s).")
        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, record.class, options.merge(cache: cache))
                        end
                end
        end
        
        if addresses.size > 0
                return addresses
        else
                raise ResolutionFailure.new("Could not find any addresses for #{name}.")
        end
end
dispatch_request(message, task: Async::Task.current) click to toggle source

Send the message to available servers. If no servers respond correctly, nil is returned. This result indicates a failure of the resolver to correctly contact any server and get a valid response.

# File lib/async/dns/resolver.rb, line 136
def dispatch_request(message, task: Async::Task.current)
        request = Request.new(message, @endpoints)
        
        request.each do |endpoint|
                @logger.debug "[#{message.id}] Sending request #{message.question.inspect} to address #{endpoint.inspect}" if @logger
                
                begin
                        response = nil
                        
                        task.with_timeout(@timeout) do
                                @logger.debug "[#{message.id}] -> Try address #{endpoint}" if @logger
                                response = try_server(request, endpoint)
                                @logger.debug "[#{message.id}] <- Try address #{endpoint} = #{response}" if @logger
                        end
                        
                        if valid_response(message, response)
                                return response
                        end
                rescue Async::TimeoutError
                        @logger.debug "[#{message.id}] Request timed out!" if @logger
                rescue InvalidResponseError
                        @logger.warn "[#{message.id}] Invalid response from network: #{$!}!" if @logger
                rescue DecodeError
                        @logger.warn "[#{message.id}] Error while decoding data from network: #{$!}!" if @logger
                rescue IOError, Errno::ECONNRESET
                        @logger.warn "[#{message.id}] Error while reading from network: #{$!}!" if @logger
                rescue EOFError
                        @logger.warn "[#{message.id}] Could not read complete response from network: #{$!}" if @logger
                end
        end
        
        return nil
end
fully_qualified_name(name) click to toggle source
# File lib/async/dns/resolver.rb, line 59
def fully_qualified_name(name)
        # If we are passed an existing deconstructed name:
        if Resolv::DNS::Name === name
                if name.absolute?
                        return name
                else
                        return name.with_origin(@origin)
                end
        end
        
        # ..else if we have a string, we need to do some basic processing:
        if name.end_with? '.'
                return Resolv::DNS::Name.create(name)
        else
                return Resolv::DNS::Name.create(name).with_origin(@origin)
        end
end
next_id!() click to toggle source

Provides the next sequence identification number which is used to keep track of DNS messages.

# File lib/async/dns/resolver.rb, line 78
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
query(name, resource_class = Resolv::DNS::Resource::IN::A) click to toggle source

Look up a named resource of the given resource_class.

# File lib/async/dns/resolver.rb, line 84
def query(name, resource_class = Resolv::DNS::Resource::IN::A)
        message = Resolv::DNS::Message.new(next_id!)
        message.rd = 1
        message.add_question fully_qualified_name(name), resource_class
        
        dispatch_request(message)
end

Private Instance Methods

lookup(name, resource_class = Resolv::DNS::Resource::IN::A, records = {}) { |name, resource_class| ... } click to toggle source

Lookup a name/resource_class record but use the records cache if possible reather than making a new request if possible.

# File lib/async/dns/resolver.rb, line 173
def lookup(name, resource_class = Resolv::DNS::Resource::IN::A, records = {})
        records.fetch(name) do
                response = yield(name, resource_class)
                
                if response
                        response.answer.each do |name_in_answer, ttl, record|
                                (records[name_in_answer] ||= []) << record
                        end
                end
                
                records[name]
        end
end
try_datagram_server(request, socket) click to toggle source
# File lib/async/dns/resolver.rb, line 214
def try_datagram_server(request, socket)
        socket.sendmsg(request.packet, 0)
        
        data, peer = socket.recvmsg(UDP_TRUNCATION_SIZE)
        
        return Async::DNS::decode_message(data)
end
try_server(request, endpoint) click to toggle source
# File lib/async/dns/resolver.rb, line 187
def try_server(request, endpoint)
        endpoint.connect do |socket|
                case socket.type
                when Socket::SOCK_DGRAM
                        try_datagram_server(request, socket)
                when Socket::SOCK_STREAM
                        try_stream_server(request, socket)
                else
                        raise InvalidProtocolError.new(endpoint)
                end
        end
end
try_stream_server(request, socket) click to toggle source
# File lib/async/dns/resolver.rb, line 222
def try_stream_server(request, socket)
        transport = Transport.new(socket)
        
        transport.write_chunk(request.packet)
        
        input_data = transport.read_chunk
        
        return Async::DNS::decode_message(input_data)
end
valid_response(message, response) click to toggle source
# File lib/async/dns/resolver.rb, line 200
def valid_response(message, response)
        if response.tc != 0
                @logger.warn "[#{message.id}] Received truncated response!" if @logger
        elsif response.id != message.id
                @logger.warn "[#{message.id}] Received response with incorrect message id: #{response.id}!" if @logger
        else
                @logger.debug "[#{message.id}] Received valid response with #{response.answer.size} answer(s)." if @logger
                
                return true
        end
        
        return false
end