@Override void doSearchDomainQuery(String hostname, Promise<List<InetAddress>> nextPromise) { // Query the cache for the hostname first and only do a query if we could not find it in the cache. if (!DnsNameResolver.doResolveAllCached( hostname, additionals, nextPromise, resolveCache, parent.resolvedInternetProtocolFamiliesUnsafe())) { super.doSearchDomainQuery(hostname, nextPromise); } }
private static void cache(AuthoritativeNameServer server, AuthoritativeDnsServerCache cache, EventLoop loop) { // Cache NS record if not for a root server as we should never cache for root servers. if (!server.isRootServer()) { cache.cache(server.domainName, server.address, server.ttl, loop); } }
public DnsAddressResolverGroup( ChannelFactory<? extends DatagramChannel> channelFactory, DnsServerAddressStreamProvider nameServerProvider) { this(new DnsNameResolverBuilder()); dnsResolverBuilder.channelFactory(channelFactory).nameServerProvider(nameServerProvider); }
private void doResolveAllUncached0(String hostname, DnsRecord[] additionals, Promise<List<InetAddress>> promise, DnsCache resolveCache) { assert executor().inEventLoop(); final DnsServerAddressStream nameServerAddrs = dnsServerAddressStreamProvider.nameServerAddressStream(hostname); new DnsAddressResolveContext(this, hostname, additionals, nameServerAddrs, resolveCache, authoritativeDnsServerCache).resolve(promise); }
@Override public DnsCacheEntry cache(String hostname, DnsRecord[] additionals, Throwable cause, EventLoop loop) { checkNotNull(hostname, "hostname"); checkNotNull(cause, "cause"); checkNotNull(loop, "loop"); DefaultDnsCacheEntry e = new DefaultDnsCacheEntry(hostname, cause); if (negativeTtl == 0 || !emptyAdditionals(additionals)) { return e; } resolveCache.cache(appendDot(hostname), e, negativeTtl, loop); return e; }
/** * Returns the {@link DnsServerAddresses} that yields the specified {@code addresses} in a rotational sequential * order. It is similar to {@link #sequential(Iterable)}, but each {@link DnsServerAddressStream} starts from * a different starting point. For example, the first {@link #stream()} will start from the first address, the * second one will start from the second address, and so on. */ public static DnsServerAddresses rotational(Iterable<? extends InetSocketAddress> addresses) { return rotational0(sanitize(addresses)); }
private static void putIfAbsent(Map<String, DnsServerAddresses> domainToNameServerStreamMap, String domainName, List<InetSocketAddress> addresses) { // TODO(scott): sortlist is being ignored. putIfAbsent(domainToNameServerStreamMap, domainName, DnsServerAddresses.sequential(addresses)); }
@Override InetAddress convertRecord(DnsRecord record, String hostname, DnsRecord[] additionals, EventLoop eventLoop) { return decodeAddress(record, hostname, parent.isDecodeIdn()); }
@Override public DnsQueryLifecycleObserver newDnsQueryLifecycleObserver(DnsQuestion question) { return new BiDnsQueryLifecycleObserver(a.newDnsQueryLifecycleObserver(question), b.newDnsQueryLifecycleObserver(question)); } }
private DnsServerAddressStream getNameServers(String hostname) { DnsServerAddressStream stream = getNameServersFromCache(hostname); return stream == null ? nameServerAddrs.duplicate() : stream; }
private DnsQueryLifecycleObserver newDnsQueryLifecycleObserver(DnsQuestion question) { return parent.dnsQueryLifecycleObserverFactory().newDnsQueryLifecycleObserver(question); }
/** * Create a new instance. * @param addresses The addresses which will be be returned in sequential order via * {@link #nameServerAddressStream(String)} */ public SequentialDnsServerAddressStreamProvider(InetSocketAddress... addresses) { super(sequential(addresses)); }
@Override public Throwable fillInStackTrace() { setStackTrace(EmptyArrays.EMPTY_STACK_TRACE); return this; } }
/** * Create a new instance. * @param address The singleton address to use for every DNS resolution. */ public SingletonDnsServerAddressStreamProvider(final InetSocketAddress address) { super(DnsServerAddresses.singleton(address)); } }
@Override public DnsCacheEntry cache(String hostname, DnsRecord[] additional, InetAddress address, long originalTtl, EventLoop loop) { return new NoopDnsCacheEntry(address); }
@Override public void queryWritten(InetSocketAddress dnsServerAddress, ChannelFuture future) { try { a.queryWritten(dnsServerAddress, future); } finally { b.queryWritten(dnsServerAddress, future); } }
@Override DnsResolveContext<DnsRecord> newResolverContext(DnsNameResolver parent, String hostname, int dnsClass, DnsRecordType[] expectedTypes, DnsRecord[] additionals, DnsServerAddressStream nameServerAddrs) { return new DnsRecordResolveContext(parent, hostname, dnsClass, expectedTypes, additionals, nameServerAddrs); }
/** * The {@link DnsCache} to use while resolving. */ DnsCache resolveCache() { return parent.resolveCache(); }
/** * Returns the {@link DnsServerAddresses} that yields the specified {@code addresses} in a rotational sequential * order. It is similar to {@link #sequential(Iterable)}, but each {@link DnsServerAddressStream} starts from * a different starting point. For example, the first {@link #stream()} will start from the first address, the * second one will start from the second address, and so on. */ public static DnsServerAddresses rotational(InetSocketAddress... addresses) { return rotational0(sanitize(addresses)); }