Expose RoundRobinInetAddressResolver

Motivation:
Make small refactoring for recently merged PR netty#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.

resolver-dns/src/main/java/io/netty/resolver/dns/RoundRobinDnsAddressResolverGroup.java

@@ -21,7 +21,7 @@
 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 RoundRobinDnsAddressResolverGroup(
         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();
     }
 }

resolver/src/main/java/io/netty/resolver/InetSocketAddressResolver.java

@@ -26,7 +26,7 @@
 import java.util.List;
 
 /**
- * A {@link AbstractAddressResolver} that resolves {@link InetAddress}.
+ * A {@link AbstractAddressResolver} that resolves {@link InetSocketAddress}.
  */
 public class InetSocketAddressResolver extends AbstractAddressResolver<InetSocketAddress> {
 

resolver/src/main/java/io/netty/resolver/RoundRobinInetAddressResolver.java

@@ -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);
+    }
+}