1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package io.netty.resolver.dns;
17
18 import static io.netty.resolver.dns.DnsAddressDecoder.decodeAddress;
19
20 import java.net.InetAddress;
21 import java.net.UnknownHostException;
22 import java.util.Collections;
23 import java.util.List;
24
25 import io.netty.channel.Channel;
26 import io.netty.channel.EventLoop;
27 import io.netty.handler.codec.dns.DnsRecord;
28 import io.netty.handler.codec.dns.DnsRecordType;
29 import io.netty.util.concurrent.Promise;
30
31 final class DnsAddressResolveContext extends DnsResolveContext<InetAddress> {
32
33 private final DnsCache resolveCache;
34 private final AuthoritativeDnsServerCache authoritativeDnsServerCache;
35 private final boolean completeEarlyIfPossible;
36
37 DnsAddressResolveContext(DnsNameResolver parent, Channel channel,
38 Promise<?> originalPromise, String hostname, DnsRecord[] additionals,
39 DnsServerAddressStream nameServerAddrs, int allowedQueries, DnsCache resolveCache,
40 AuthoritativeDnsServerCache authoritativeDnsServerCache,
41 boolean completeEarlyIfPossible) {
42 super(parent, channel, originalPromise, hostname, DnsRecord.CLASS_IN,
43 parent.resolveRecordTypes(), additionals, nameServerAddrs, allowedQueries);
44 this.resolveCache = resolveCache;
45 this.authoritativeDnsServerCache = authoritativeDnsServerCache;
46 this.completeEarlyIfPossible = completeEarlyIfPossible;
47 }
48
49 @Override
50 DnsResolveContext<InetAddress> newResolverContext(DnsNameResolver parent, Channel channel,
51 Promise<?> originalPromise,
52 String hostname,
53 int dnsClass, DnsRecordType[] expectedTypes,
54 DnsRecord[] additionals,
55 DnsServerAddressStream nameServerAddrs, int allowedQueries) {
56 return new DnsAddressResolveContext(parent, channel, originalPromise, hostname, additionals,
57 nameServerAddrs, allowedQueries, resolveCache, authoritativeDnsServerCache, completeEarlyIfPossible);
58 }
59
60 @Override
61 InetAddress convertRecord(DnsRecord record, String hostname, DnsRecord[] additionals, EventLoop eventLoop) {
62 return decodeAddress(record, hostname, parent.isDecodeIdn());
63 }
64
65 @Override
66 List<InetAddress> filterResults(List<InetAddress> unfiltered) {
67 Collections.sort(unfiltered, PreferredAddressTypeComparator.comparator(parent.preferredAddressType()));
68 return unfiltered;
69 }
70
71 @Override
72 boolean isCompleteEarly(InetAddress resolved) {
73 return completeEarlyIfPossible &&
74 DnsNameResolver.addressType(parent.preferredAddressType()) == resolved.getClass();
75 }
76
77 @Override
78 boolean isDuplicateAllowed() {
79
80 return false;
81 }
82
83 @Override
84 void cache(String hostname, DnsRecord[] additionals,
85 DnsRecord result, InetAddress convertedResult) {
86 resolveCache.cache(hostname, additionals, convertedResult, result.timeToLive(),
87 channel().eventLoop());
88 }
89
90 @Override
91 void cache(String hostname, DnsRecord[] additionals, UnknownHostException cause) {
92 resolveCache.cache(hostname, additionals, cause, channel().eventLoop());
93 }
94
95 @Override
96 void doSearchDomainQuery(String hostname, Promise<List<InetAddress>> nextPromise) {
97
98 if (!DnsNameResolver.doResolveAllCached(hostname, additionals, nextPromise, resolveCache,
99 parent.searchDomains(), parent.ndots(), parent.resolvedInternetProtocolFamiliesUnsafe())) {
100 super.doSearchDomainQuery(hostname, nextPromise);
101 }
102 }
103
104 @Override
105 DnsCache resolveCache() {
106 return resolveCache;
107 }
108
109 @Override
110 AuthoritativeDnsServerCache authoritativeDnsServerCache() {
111 return authoritativeDnsServerCache;
112 }
113 }