Expose RoundRobinInetAddressResolver
Motivation: Make small refactoring for recently merged PR #5867 to make the code more flexible and expose aggressive round robin as a NameResolver too with proper code reuse. Modifications: Round robin is a method of hostname resolving - so Round robin related code fully moved to RoundRobinInetAddressResolver implements NameResolver<InetAddress>, RoundRobinInetSocketAddressResolver is deleted as a separate class, instance with the same functionality could be created by calling #asAddressResolver. Result: New forced Round Robin code exposed not only as an AddressResolver but as a NameResolver too, more proper code and semantic reusing of InetNameResolver and InetSocketAddressResolver classes.
This commit is contained in:
Dmitry Spikhalskiy
Norman Maurer
parent
8269e0f046
commit
eb7f8e4dc5
@ -21,7 +21,7 @@ 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.RoundRobinInetSocketAddressResolver;
|
||||
import io.netty.resolver.RoundRobinInetAddressResolver;
|
||||
import io.netty.resolver.NameResolver;
|
||||
import io.netty.util.internal.UnstableApi;
|
||||
|
||||
@ -48,10 +48,16 @@ public class RoundRobinDnsAddressResolverGroup extends DnsAddressResolverGroup {
|
||||
super(channelFactory, nameServerAddresses);
|
||||
}
|
||||
|
||||
/**
|
||||
* We need to override this method, not
|
||||
* {@link #newNameResolver(EventLoop, ChannelFactory, DnsServerAddresses)},
|
||||
* because we need to eliminate possible caching of {@link io.netty.resolver.NameResolver#resolve}
|
||||
* by {@link InflightNameResolver} created in {@link #newResolver(EventLoop, ChannelFactory, DnsServerAddresses)}.
|
||||
*/
|
||||
@Override
|
||||
protected final AddressResolver<InetSocketAddress> newAddressResolver(EventLoop eventLoop,
|
||||
NameResolver<InetAddress> resolver)
|
||||
throws Exception {
|
||||
return new RoundRobinInetSocketAddressResolver(eventLoop, resolver);
|
||||
return new RoundRobinInetAddressResolver(eventLoop, resolver).asAddressResolver();
|
||||
}
|
||||
}
|
||||
|
||||
@ -26,7 +26,7 @@ import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* A {@link AbstractAddressResolver} that resolves {@link InetAddress}.
|
||||
* A {@link AbstractAddressResolver} that resolves {@link InetSocketAddress}.
|
||||
*/
|
||||
public class InetSocketAddressResolver extends AbstractAddressResolver<InetSocketAddress> {
|
||||
|
||||
|
||||
@ -0,0 +1,80 @@
|
||||
/*
|
||||
* Copyright 2016 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;
|
||||
|
||||
import io.netty.util.concurrent.EventExecutor;
|
||||
import io.netty.util.concurrent.Future;
|
||||
import io.netty.util.concurrent.FutureListener;
|
||||
import io.netty.util.concurrent.Promise;
|
||||
import io.netty.util.internal.ThreadLocalRandom;
|
||||
import io.netty.util.internal.UnstableApi;
|
||||
|
||||
import java.net.InetAddress;
|
||||
import java.net.InetSocketAddress;
|
||||
import java.net.UnknownHostException;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* A {@link NameResolver} that resolves {@link InetAddress} and force Round Robin by choosing a single address
|
||||
* randomly in {@link #resolve(String)} and {@link #resolve(String, Promise)}
|
||||
* if multiple are returned by the {@link NameResolver}.
|
||||
* Use {@link #asAddressResolver()} to create a {@link InetSocketAddress} resolver
|
||||
*/
|
||||
@UnstableApi
|
||||
public class RoundRobinInetAddressResolver extends InetNameResolver {
|
||||
private final NameResolver<InetAddress> nameResolver;
|
||||
|
||||
/**
|
||||
* @param executor the {@link EventExecutor} which is used to notify the listeners of the {@link Future} returned by
|
||||
* {@link #resolve(String)}
|
||||
* @param nameResolver the {@link NameResolver} used for name resolution
|
||||
*/
|
||||
public RoundRobinInetAddressResolver(EventExecutor executor, NameResolver<InetAddress> nameResolver) {
|
||||
super(executor);
|
||||
this.nameResolver = nameResolver;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void doResolve(final String inetHost, final Promise<InetAddress> promise) throws Exception {
|
||||
// hijack the doResolve request, but do a doResolveAll request under the hood.
|
||||
// Note that InetSocketAddress.getHostName() will never incur a reverse lookup here,
|
||||
// because an unresolved address always has a host name.
|
||||
resolveAll(inetHost).addListener(new FutureListener<List<InetAddress>>() {
|
||||
@Override
|
||||
public void operationComplete(Future<List<InetAddress>> future) throws Exception {
|
||||
if (future.isSuccess()) {
|
||||
List<InetAddress> inetAddresses = future.getNow();
|
||||
int numAddresses = inetAddresses.size();
|
||||
if (numAddresses == 0) {
|
||||
promise.setFailure(new UnknownHostException(inetHost));
|
||||
} else {
|
||||
// if there are multiple addresses: we shall pick one at random
|
||||
// this is to support the round robin distribution
|
||||
promise.setSuccess(inetAddresses.get(
|
||||
numAddresses == 1 ? 0 : ThreadLocalRandom.current().nextInt(numAddresses)));
|
||||
}
|
||||
} else {
|
||||
promise.setFailure(future.cause());
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void doResolveAll(String inetHost, Promise<List<InetAddress>> promise) throws Exception {
|
||||
nameResolver.resolveAll(inetHost, promise);
|
||||
}
|
||||
}
|
||||
@ -1,75 +0,0 @@
|
||||
/*
|
||||
* Copyright 2016 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;
|
||||
|
||||
import io.netty.util.concurrent.EventExecutor;
|
||||
import io.netty.util.concurrent.Future;
|
||||
import io.netty.util.concurrent.FutureListener;
|
||||
import io.netty.util.concurrent.Promise;
|
||||
import io.netty.util.internal.ThreadLocalRandom;
|
||||
import io.netty.util.internal.UnstableApi;
|
||||
|
||||
import java.net.InetAddress;
|
||||
import java.net.InetSocketAddress;
|
||||
import java.net.UnknownHostException;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* A {@link AbstractAddressResolver} that resolves {@link InetAddress} and chooses a single address randomly if multiple
|
||||
* are returned by the {@link NameResolver}.
|
||||
*/
|
||||
@UnstableApi
|
||||
public class RoundRobinInetSocketAddressResolver extends InetSocketAddressResolver {
|
||||
|
||||
/**
|
||||
* @param executor the {@link EventExecutor} which is used to notify the listeners of the {@link Future} returned by
|
||||
* {@link #resolve(java.net.SocketAddress)}
|
||||
* @param nameResolver the {@link NameResolver} used for name resolution
|
||||
*/
|
||||
public RoundRobinInetSocketAddressResolver(EventExecutor executor, NameResolver<InetAddress> nameResolver) {
|
||||
super(executor, nameResolver);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void doResolve(final InetSocketAddress unresolvedAddress, final Promise<InetSocketAddress> promise)
|
||||
throws Exception {
|
||||
// hijack the doResolve request, but do a doResolveAll request under the hood
|
||||
// Note that InetSocketAddress.getHostName() will never incur a reverse lookup here,
|
||||
// because an unresolved address always has a host name.
|
||||
nameResolver.resolveAll(unresolvedAddress.getHostName())
|
||||
.addListener(new FutureListener<List<InetAddress>>() {
|
||||
@Override
|
||||
public void operationComplete(Future<List<InetAddress>> future) throws Exception {
|
||||
if (future.isSuccess()) {
|
||||
List<InetAddress> inetAddresses = future.getNow();
|
||||
int numAddresses = inetAddresses.size();
|
||||
if (numAddresses == 0) {
|
||||
promise.setFailure(new UnknownHostException(unresolvedAddress.getHostName()));
|
||||
} else {
|
||||
// if there are multiple addresses: we shall pick one at random
|
||||
// this is to support the round robin distribution
|
||||
int index =
|
||||
(numAddresses == 1)? 0 : ThreadLocalRandom.current().nextInt(numAddresses);
|
||||
promise.setSuccess(new InetSocketAddress(inetAddresses.get(index),
|
||||
unresolvedAddress.getPort()));
|
||||
}
|
||||
} else {
|
||||
promise.setFailure(future.cause());
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user