andreacavalli/netty5
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Implement RoundRobin logic in RoundRobinInetAddressResolver#resolveAll

Browse Source 
Motivation:
Now the ```resolveAll``` method of RoundRobinInetAddressResolver returns results without any rotation and shuffling. As a result, it doesn't force any round-robin for clients that get a result of ```resolveAll``` and use addresses from the result one by one for a connection establishing until success. This commit implements round-robin in RoundRobinInetAddressResolver#resolveAll. These improvements inspired by the discussion here: https://github.com/AsyncHttpClient/async-http-client/issues/1285

Modifications:
Rotate collection from internal ```resolveAll``` call by index, which is incremented every call to RoundRobinInetAddressResolver#resolveAll method.
Random replaced by an incrementing counter, which makes code cheaper and guarantees predictable address order in tests.

Result:
Improved ```RoundRobinInetAddressResolver``` is compatible with clients that use ```resolveAll``` result.
This commit is contained in:
Dmitry Spikhalskiy 2016-11-03 03:22:24 +03:00 committed by Norman Maurer
parent b4e5965424
commit 5eebe9a06c
1 changed files with 41 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
resolver/src/main/java/io/netty/resolver/RoundRobinInetAddressResolver.java
View File

@ -19,13 +19,15 @@ 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.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
* A {@link NameResolver} that resolves {@link InetAddress} and force Round Robin by choosing a single address
@ -36,6 +38,7 @@ import java.util.List;
@UnstableApi
public class RoundRobinInetAddressResolver extends InetNameResolver {
private final NameResolver<InetAddress> nameResolver;
private final AtomicInteger index = new AtomicInteger();
/**
* @param executor the {@link EventExecutor} which is used to notify the listeners of the {@link Future} returned by
@ -52,29 +55,46 @@ public class RoundRobinInetAddressResolver extends InetNameResolver {
// 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());
}
nameResolver.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) {
// if there are multiple addresses: we shall pick one by one
// to support the round robin distribution
promise.setSuccess(inetAddresses.get(index.getAndIncrement() % numAddresses));
} else {
promise.setFailure(new UnknownHostException(inetHost));
}
});
} else {
promise.setFailure(future.cause());
}
}
});
}
@Override
protected void doResolveAll(String inetHost, Promise<List<InetAddress>> promise) throws Exception {
nameResolver.resolveAll(inetHost, promise);
protected void doResolveAll(String inetHost, final Promise<List<InetAddress>> promise) throws Exception {
nameResolver.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();
if (!inetAddresses.isEmpty()) {
// create a copy to make sure that it's modifiable random access collection
List<InetAddress> result = new ArrayList<InetAddress>(inetAddresses);
// rotate by different distance each time to force round robin distribution
Collections.rotate(result, index.getAndIncrement());
promise.setSuccess(result);
} else {
promise.setSuccess(inetAddresses);
}
} else {
promise.setFailure(future.cause());
}
}
});
}
}