com.arangodb.shaded.vertx.core.impl.resolver.DnsResolverProvider Maven / Gradle / Ivy
/*
* Copyright (c) 2011-2021 Contributors to the Eclipse Foundation
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
* which is available at https://www.apache.org/licenses/LICENSE-2.0.
*
* SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
*/
package com.arangodb.shaded.vertx.core.impl.resolver;
import com.arangodb.shaded.netty.channel.ChannelFactory;
import com.arangodb.shaded.netty.channel.EventLoop;
import com.arangodb.shaded.netty.channel.socket.DatagramChannel;
import com.arangodb.shaded.netty.channel.socket.SocketChannel;
import com.arangodb.shaded.netty.resolver.*;
import com.arangodb.shaded.netty.resolver.dns.*;
import com.arangodb.shaded.netty.util.NetUtil;
import com.arangodb.shaded.netty.util.concurrent.EventExecutor;
import com.arangodb.shaded.vertx.core.Context;
import com.arangodb.shaded.vertx.core.Handler;
import com.arangodb.shaded.vertx.core.Vertx;
import com.arangodb.shaded.vertx.core.VertxException;
import com.arangodb.shaded.vertx.core.dns.AddressResolverOptions;
import com.arangodb.shaded.vertx.core.impl.AddressResolver;
import com.arangodb.shaded.vertx.core.impl.VertxImpl;
import com.arangodb.shaded.vertx.core.spi.resolver.ResolverProvider;
import java.io.File;
import java.io.IOException;
import java.io.StringReader;
import java.net.*;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import static com.arangodb.shaded.netty.util.internal.ObjectUtil.intValue;
/**
* @author Julien Viet
*/
public class DnsResolverProvider implements ResolverProvider {
private final Vertx vertx;
private final List resolvers = Collections.synchronizedList(new ArrayList<>());
private AddressResolverGroup resolverGroup;
private final List serverList = new ArrayList<>();
/**
* @return a list of DNS servers available to use
*/
public List nameServerAddresses() {
return serverList;
}
public DnsResolverProvider(VertxImpl vertx, AddressResolverOptions options) {
List dnsServers = options.getServers();
if (dnsServers != null && dnsServers.size() > 0) {
for (String dnsServer : dnsServers) {
int sep = dnsServer.indexOf(':');
String ipAddress;
int port;
if (sep != -1) {
ipAddress = dnsServer.substring(0, sep);
port = Integer.parseInt(dnsServer.substring(sep + 1));
} else {
ipAddress = dnsServer;
port = 53;
}
try {
serverList.add(new InetSocketAddress(InetAddress.getByAddress(NetUtil.createByteArrayFromIpAddressString(ipAddress)), port));
} catch (UnknownHostException e) {
throw new VertxException(e);
}
}
} else {
DnsServerAddressStream stream = DefaultDnsServerAddressStreamProvider.defaultAddresses().stream();
Set all = new HashSet<>();
while (true) {
InetSocketAddress address = stream.next();
if (all.contains(address)) {
break;
}
serverList.add(address);
all.add(address);
}
}
DnsServerAddresses nameServerAddresses = options.isRotateServers() ? DnsServerAddresses.rotational(serverList) : DnsServerAddresses.sequential(serverList);
DnsServerAddressStreamProvider nameServerAddressProvider = hostname -> {
return nameServerAddresses.stream();
};
HostsFileEntries entries;
if (options.getHostsPath() != null) {
File file = vertx.resolveFile(options.getHostsPath()).getAbsoluteFile();
try {
if (!file.exists() || !file.isFile()) {
throw new IOException();
}
entries = HostsFileParser.parse(file);
} catch (IOException e) {
throw new VertxException("Cannot read hosts file " + file.getAbsolutePath());
}
} else if (options.getHostsValue() != null) {
try {
entries = HostsFileParser.parse(new StringReader(options.getHostsValue().toString()));
} catch (IOException e) {
throw new VertxException("Cannot read hosts config ", e);
}
} else {
entries = HostsFileParser.parseSilently();
}
int minTtl = intValue(options.getCacheMinTimeToLive(), 0);
int maxTtl = intValue(options.getCacheMaxTimeToLive(), Integer.MAX_VALUE);
int negativeTtl = intValue(options.getCacheNegativeTimeToLive(), 0);
DnsCache resolveCache = new DefaultDnsCache(minTtl, maxTtl, negativeTtl);
DnsCache authoritativeDnsServerCache = new DefaultDnsCache(minTtl, maxTtl, negativeTtl);
this.vertx = vertx;
DnsNameResolverBuilder builder = new DnsNameResolverBuilder();
builder.hostsFileEntriesResolver(new HostsFileEntriesResolver() {
@Override
public InetAddress address(String inetHost, ResolvedAddressTypes resolvedAddressTypes) {
if (inetHost.endsWith(".")) {
inetHost = inetHost.substring(0, inetHost.length() - 1);
}
InetAddress address = lookup(inetHost, resolvedAddressTypes);
if (address == null) {
address = lookup(inetHost.toLowerCase(Locale.ENGLISH), resolvedAddressTypes);
}
return address;
}
InetAddress lookup(String inetHost, ResolvedAddressTypes resolvedAddressTypes) {
switch (resolvedAddressTypes) {
case IPV4_ONLY:
return entries.inet4Entries().get(inetHost);
case IPV6_ONLY:
return entries.inet6Entries().get(inetHost);
case IPV4_PREFERRED:
Inet4Address inet4Address = entries.inet4Entries().get(inetHost);
return inet4Address != null? inet4Address : entries.inet6Entries().get(inetHost);
case IPV6_PREFERRED:
Inet6Address inet6Address = entries.inet6Entries().get(inetHost);
return inet6Address != null? inet6Address : entries.inet4Entries().get(inetHost);
default:
throw new IllegalArgumentException("Unknown ResolvedAddressTypes " + resolvedAddressTypes);
}
}
});
builder.channelFactory(() -> vertx.transport().datagramChannel());
builder.socketChannelFactory(() -> (SocketChannel) vertx.transport().channelFactory(false).newChannel());
builder.nameServerProvider(nameServerAddressProvider);
builder.optResourceEnabled(options.isOptResourceEnabled());
builder.resolveCache(resolveCache);
builder.authoritativeDnsServerCache(authoritativeDnsServerCache);
builder.queryTimeoutMillis(options.getQueryTimeout());
builder.maxQueriesPerResolve(options.getMaxQueries());
builder.recursionDesired(options.getRdFlag());
if (options.getSearchDomains() != null) {
builder.searchDomains(options.getSearchDomains());
int ndots = options.getNdots();
if (ndots == -1) {
ndots = AddressResolver.DEFAULT_NDOTS_RESOLV_OPTION;
}
builder.ndots(ndots);
}
this.resolverGroup = new DnsAddressResolverGroup(builder) {
@Override
protected com.arangodb.shaded.netty.resolver.AddressResolver newAddressResolver(EventLoop eventLoop, NameResolver resolver) throws Exception {
io.netty.resolver.AddressResolver addressResolver;
if (options.isRoundRobinInetAddress()) {
addressResolver = new RoundRobinInetAddressResolver(eventLoop, resolver).asAddressResolver();
} else {
addressResolver = super.newAddressResolver(eventLoop, resolver);
}
resolvers.add(new ResolverRegistration(addressResolver, eventLoop));
return addressResolver;
}
};
}
private static class ResolverRegistration {
private final com.arangodb.shaded.netty.resolver.AddressResolver resolver;
private final EventLoop executor;
ResolverRegistration(com.arangodb.shaded.netty.resolver.AddressResolver resolver, EventLoop executor) {
this.resolver = resolver;
this.executor = executor;
}
}
@Override
public AddressResolverGroup resolver(AddressResolverOptions options) {
return resolverGroup;
}
@Override
public void close(Handler doneHandler) {
Context context = vertx.getOrCreateContext();
ResolverRegistration[] registrations = this.resolvers.toArray(new ResolverRegistration[0]);
if (registrations.length == 0) {
context.runOnContext(doneHandler);
return;
}
AtomicInteger count = new AtomicInteger(registrations.length);
for (ResolverRegistration registration : registrations) {
Runnable task = () -> {
registration.resolver.close();
if (count.decrementAndGet() == 0) {
context.runOnContext(doneHandler);
}
};
if (registration.executor.inEventLoop()) {
task.run();
} else {
registration.executor.execute(task);
}
}
}
}