module HTTPX::Resolver

   # File lib/httpx/resolver.rb
58 def cached_lookup(hostname)
59   now = Utils.now
60   lookup_synchronize do |lookups|
61     lookup(hostname, lookups, now)
62   end
63 end

   # File lib/httpx/resolver.rb
86 def cached_lookup_evict(hostname, ip)
87   ip = ip.to_s
88 
89   lookup_synchronize do |lookups|
90     entries = lookups[hostname]
91 
92     return unless entries
93 
94     lookups.delete_if { |entry| entry["data"] == ip }
95   end
96 end

   # File lib/httpx/resolver.rb
65 def cached_lookup_set(hostname, family, entries)
66   lookup_synchronize do |lookups|
67     case family
68     when Socket::AF_INET6
69       lookups[hostname].concat(entries)
70     when Socket::AF_INET
71       lookups[hostname].unshift(*entries)
72     end
73     entries.each do |entry|
74       next unless entry["name"] != hostname
75 
76       case family
77       when Socket::AF_INET6
78         lookups[entry["name"]] << entry
79       when Socket::AF_INET
80         lookups[entry["name"]].unshift(entry)
81       end
82     end
83   end
84 end

    # File lib/httpx/resolver.rb
128 def decode_dns_answer(payload)
129   begin
130     message = Resolv::DNS::Message.decode(payload)
131   rescue Resolv::DNS::DecodeError => e
132     return :decode_error, e
133   end
134 
135   # no domain was found
136   return :no_domain_found if message.rcode == Resolv::DNS::RCode::NXDomain
137 
138   return :message_truncated if message.tc == 1
139 
140   return :dns_error, message.rcode if message.rcode != Resolv::DNS::RCode::NoError
141 
142   addresses = []
143 
144   now = Utils.now
145   message.each_answer do |question, _, value|
146     case value
147     when Resolv::DNS::Resource::IN::CNAME
148       addresses << {
149         "name" => question.to_s,
150         "TTL" => (now + value.ttl),
151         "alias" => value.name.to_s,
152       }
153     when Resolv::DNS::Resource::IN::A,
154          Resolv::DNS::Resource::IN::AAAA
155       addresses << {
156         "name" => question.to_s,
157         "TTL" => (now + value.ttl),
158         "data" => value.address.to_s,
159       }
160     end
161   end
162 
163   [:ok, addresses]
164 end

    # File lib/httpx/resolver.rb
121 def encode_dns_query(hostname, type: Resolv::DNS::Resource::IN::A, message_id: generate_id)
122   Resolv::DNS::Message.new(message_id).tap do |query|
123     query.rd = 1
124     query.add_question(hostname, type)
125   end.encode
126 end

    # File lib/httpx/resolver.rb
117 def generate_id
118   id_synchronize { @identifier = (@identifier + 1) & 0xFFFF }
119 end

   # File lib/httpx/resolver.rb
50 def hosts_resolve(hostname)
51   ips = @hosts_resolver.getaddresses(hostname)
52   return if ips.empty?
53 
54   ips.map { |ip| Entry.new(ip) }
55 rescue IOError
56 end

    # File lib/httpx/resolver.rb
170 def id_synchronize(&block)
171   @identifier_mutex.synchronize(&block)
172 end

   # File lib/httpx/resolver.rb
43 def ip_resolve(hostname)
44   [Entry.new(hostname)]
45 rescue ArgumentError
46 end

    # File lib/httpx/resolver.rb
 99 def lookup(hostname, lookups, ttl)
100   return unless lookups.key?(hostname)
101 
102   entries = lookups[hostname] = lookups[hostname].select do |address|
103     address["TTL"] > ttl
104   end
105 
106   ips = entries.flat_map do |address|
107     if (als = address["alias"])
108       lookup(als, lookups, ttl)
109     else
110       Entry.new(address["data"], address["TTL"])
111     end
112   end.compact
113 
114   ips unless ips.empty?
115 end

    # File lib/httpx/resolver.rb
166 def lookup_synchronize
167   @lookup_mutex.synchronize { yield(@lookups) }
168 end

   # File lib/httpx/resolver.rb
38 def nolookup_resolve(hostname)
39   ip_resolve(hostname) || cached_lookup(hostname) || hosts_resolve(hostname)
40 end

   # File lib/httpx/resolver.rb
25 def resolver_for(resolver_type, options)
26   case resolver_type
27   when Symbol
28     meth = :"resolver_#{resolver_type}_class"
29 
30     return options.__send__(meth) if options.respond_to?(meth)
31   when Class
32     return resolver_type if resolver_type < Resolver
33   end
34 
35   raise Error, "unsupported resolver type (#{resolver_type})"
36 end