netty5/resolver-dns/src/main/java/io/netty/resolver/dns/DnsAddressResolverGroup.java

125 lines
5.3 KiB
Java
Raw Normal View History

/*
* Copyright 2014 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.resolver.dns;
import io.netty.channel.ChannelFactory;
import io.netty.channel.EventLoop;
import io.netty.channel.socket.DatagramChannel;
import io.netty.resolver.AddressResolver;
import io.netty.resolver.AddressResolverGroup;
import io.netty.resolver.InetSocketAddressResolver;
import io.netty.resolver.NameResolver;
import io.netty.util.concurrent.EventExecutor;
import io.netty.util.concurrent.Promise;
import io.netty.util.internal.StringUtil;
import io.netty.util.internal.UnstableApi;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
/**
* A {@link AddressResolverGroup} of {@link DnsNameResolver}s.
*/
@UnstableApi
public class DnsAddressResolverGroup extends AddressResolverGroup<InetSocketAddress> {
private final DnsNameResolverBuilder dnsResolverBuilder;
private final ConcurrentMap<String, Promise<InetAddress>> resolvesInProgress = new ConcurrentHashMap<>();
private final ConcurrentMap<String, Promise<List<InetAddress>>> resolveAllsInProgress = new ConcurrentHashMap<>();
public DnsAddressResolverGroup(DnsNameResolverBuilder dnsResolverBuilder) {
this.dnsResolverBuilder = dnsResolverBuilder.copy();
}
public DnsAddressResolverGroup(
Class<? extends DatagramChannel> channelType,
DnsServerAddressStreamProvider nameServerProvider) {
this(new DnsNameResolverBuilder());
dnsResolverBuilder.channelType(channelType).nameServerProvider(nameServerProvider);
}
public DnsAddressResolverGroup(
ChannelFactory<? extends DatagramChannel> channelFactory,
DnsServerAddressStreamProvider nameServerProvider) {
this(new DnsNameResolverBuilder());
dnsResolverBuilder.channelFactory(channelFactory).nameServerProvider(nameServerProvider);
}
@SuppressWarnings("deprecation")
@Override
protected final AddressResolver<InetSocketAddress> newResolver(EventExecutor executor) throws Exception {
if (!(executor instanceof EventLoop)) {
throw new IllegalStateException(
"unsupported executor type: " + StringUtil.simpleClassName(executor) +
" (expected: " + StringUtil.simpleClassName(EventLoop.class));
}
// we don't really need to pass channelFactory and nameServerProvider separately,
// but still keep this to ensure backward compatibility with (potentially) override methods
return newResolver((EventLoop) executor,
dnsResolverBuilder.channelFactory(),
dnsResolverBuilder.nameServerProvider());
}
/**
* @deprecated Override {@link #newNameResolver(EventLoop, ChannelFactory, DnsServerAddressStreamProvider)}.
*/
@Deprecated
protected AddressResolver<InetSocketAddress> newResolver(
EventLoop eventLoop, ChannelFactory<? extends DatagramChannel> channelFactory,
DnsServerAddressStreamProvider nameServerProvider) throws Exception {
final NameResolver<InetAddress> resolver = new InflightNameResolver<>(
eventLoop,
newNameResolver(eventLoop, channelFactory, nameServerProvider),
resolvesInProgress,
resolveAllsInProgress);
Support aggressive round-robin dns Motivation: Suppose the domain `foo.example.com` resolves to the following ip addresses `10.0.0.1`, `10.0.0.2`, `10.0.0.3`. Round robin DNS works by having each client probabilistically getting a different ordering of the set of target IP’s, so connections from different clients (across the world) would be split up across each of the addresses. Example: In a `ChannelPool` to manage connections to `foo.example.com`, it may be desirable for high QPS applications to spread the requests across all available network addresses. Currently, Netty’s resolver would return only the first address (`10.0.0.1`) to use. Let say we are making dozens of connections. The name would be resolved to a single IP and all of the connections would be made to `10.0.0.1`. The other two addresses would not see any connections. (they may see it later if new connections are made and `10.0.0.2` is the first in the list at that time of a subsequent resolution). In these changes, I add support to select a random one of the resolved addresses to use on each resolve call, all while leveraging the existing caching and inflight request detection. This way in my example, the connections would be make to random selections of the resolved IP addresses. Modifications: I added another method `newAddressResolver` to `DnsAddressResolverGroup` which can be overriden much like `newNameResolver`. The current functionality which creates `InetSocketAddressResolver` is still used. I added `RoundRobinDnsAddressResolverGroup` which extends DnsAddressResolverGroup and overrides the `newAddressResolver` method to return a subclass of the `InetSocketAddressResolver`. This subclass is called `RoundRobinInetSocketAddressResolver` and it contains logic that takes a `resolve` request, does a `resolveAll` under the hood, and returns a single element at random from the result of the `resolveAll`. Result: The existing functionality of `DnsAddressResolverGroup` is left unchanged. All new functionality is in the `RoundRobinInetSocketAddressResolver` which users will now have the option to use.
2016-09-27 02:45:41 +02:00
return newAddressResolver(eventLoop, resolver);
}
/**
* Creates a new {@link NameResolver}. Override this method to create an alternative {@link NameResolver}
* implementation or override the default configuration.
*/
protected NameResolver<InetAddress> newNameResolver(EventLoop eventLoop,
ChannelFactory<? extends DatagramChannel> channelFactory,
DnsServerAddressStreamProvider nameServerProvider)
throws Exception {
// once again, channelFactory and nameServerProvider are most probably set in builder already,
// but I do reassign them again to avoid corner cases with override methods
return dnsResolverBuilder.eventLoop(eventLoop)
.channelFactory(channelFactory)
.nameServerProvider(nameServerProvider)
.build();
}
Support aggressive round-robin dns Motivation: Suppose the domain `foo.example.com` resolves to the following ip addresses `10.0.0.1`, `10.0.0.2`, `10.0.0.3`. Round robin DNS works by having each client probabilistically getting a different ordering of the set of target IP’s, so connections from different clients (across the world) would be split up across each of the addresses. Example: In a `ChannelPool` to manage connections to `foo.example.com`, it may be desirable for high QPS applications to spread the requests across all available network addresses. Currently, Netty’s resolver would return only the first address (`10.0.0.1`) to use. Let say we are making dozens of connections. The name would be resolved to a single IP and all of the connections would be made to `10.0.0.1`. The other two addresses would not see any connections. (they may see it later if new connections are made and `10.0.0.2` is the first in the list at that time of a subsequent resolution). In these changes, I add support to select a random one of the resolved addresses to use on each resolve call, all while leveraging the existing caching and inflight request detection. This way in my example, the connections would be make to random selections of the resolved IP addresses. Modifications: I added another method `newAddressResolver` to `DnsAddressResolverGroup` which can be overriden much like `newNameResolver`. The current functionality which creates `InetSocketAddressResolver` is still used. I added `RoundRobinDnsAddressResolverGroup` which extends DnsAddressResolverGroup and overrides the `newAddressResolver` method to return a subclass of the `InetSocketAddressResolver`. This subclass is called `RoundRobinInetSocketAddressResolver` and it contains logic that takes a `resolve` request, does a `resolveAll` under the hood, and returns a single element at random from the result of the `resolveAll`. Result: The existing functionality of `DnsAddressResolverGroup` is left unchanged. All new functionality is in the `RoundRobinInetSocketAddressResolver` which users will now have the option to use.
2016-09-27 02:45:41 +02:00
/**
* Creates a new {@link AddressResolver}. Override this method to create an alternative {@link AddressResolver}
* implementation or override the default configuration.
*/
protected AddressResolver<InetSocketAddress> newAddressResolver(EventLoop eventLoop,
NameResolver<InetAddress> resolver)
throws Exception {
return new InetSocketAddressResolver(eventLoop, resolver);
}
}