Add Resolver interface and implementations (#332)

* Add CcmBridge#getNodeIpAddress(int)

Adds tiny utility method to CcmBridge.

* Add Resolver interface and implementations

Adds a middleman between driver and all direct calls to InetAddress.
This is meant to help with testing in case there is a need to substitute
name resolution with resolution by specific ip address without modifying
system environment or providing custom DNS server.

Default implementation redirects all calls to InetAddress class which
should not introduce change in behaviour.
One introduced downside is that if the methods are to be customizable
then the interface cannot have them `static`.

Adds also implementation of MockResolver that has its own mapping of hostnames
to addresses.

Adds MockResolverIT.

Author: Bouncheck

core/src/main/java/com/datastax/oss/driver/internal/core/ContactPoints.java

@@ -19,6 +19,8 @@
 
 import com.datastax.oss.driver.api.core.metadata.EndPoint;
 import com.datastax.oss.driver.internal.core.metadata.DefaultEndPoint;
+import com.datastax.oss.driver.internal.core.resolver.Resolver;
+import com.datastax.oss.driver.internal.core.resolver.ResolverProvider;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableSet;
 import com.datastax.oss.driver.shaded.guava.common.collect.Sets;
 import java.net.InetAddress;
@@ -35,6 +37,7 @@
 /** Utility class to handle the initial contact points passed to the driver. */
 public class ContactPoints {
   private static final Logger LOG = LoggerFactory.getLogger(ContactPoints.class);
+  private static Resolver RESOLVER = ResolverProvider.getResolver(ContactPoints.class);
 
   public static Set<EndPoint> merge(
       Set<EndPoint> programmaticContactPoints, List<String> configContactPoints, boolean resolve) {
@@ -72,7 +75,7 @@ private static Set<InetSocketAddress> extract(String spec, boolean resolve) {
       return ImmutableSet.of(InetSocketAddress.createUnresolved(host, port));
     } else {
       try {
-        InetAddress[] inetAddresses = InetAddress.getAllByName(host);
+        InetAddress[] inetAddresses = RESOLVER.getAllByName(host);
         if (inetAddresses.length > 1) {
           LOG.info(
               "Contact point {} resolves to multiple addresses, will use them all ({})",

core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/Ec2MultiRegionAddressTranslator.java

@@ -19,6 +19,8 @@
 
 import com.datastax.oss.driver.api.core.addresstranslation.AddressTranslator;
 import com.datastax.oss.driver.api.core.context.DriverContext;
+import com.datastax.oss.driver.internal.core.resolver.Resolver;
+import com.datastax.oss.driver.internal.core.resolver.ResolverProvider;
 import com.datastax.oss.driver.internal.core.util.Loggers;
 import com.datastax.oss.driver.shaded.guava.common.annotations.VisibleForTesting;
 import edu.umd.cs.findbugs.annotations.NonNull;
@@ -57,6 +59,8 @@
 public class Ec2MultiRegionAddressTranslator implements AddressTranslator {
 
   private static final Logger LOG = LoggerFactory.getLogger(Ec2MultiRegionAddressTranslator.class);
+  private static Resolver RESOLVER =
+      ResolverProvider.getResolver(Ec2MultiRegionAddressTranslator.class);
 
   private final DirContext ctx;
   private final String logPrefix;
@@ -94,7 +98,7 @@ public InetSocketAddress translate(@NonNull InetSocketAddress socketAddress) {
         return socketAddress;
       }
 
-      InetAddress translatedAddress = InetAddress.getByName(domainName);
+      InetAddress translatedAddress = RESOLVER.getByName(domainName);
       LOG.debug("[{}] Resolved {} to {}", logPrefix, address, translatedAddress);
       return new InetSocketAddress(translatedAddress, socketAddress.getPort());
     } catch (Exception e) {

core/src/main/java/com/datastax/oss/driver/internal/core/channel/ChannelFactory.java

@@ -42,6 +42,8 @@
 import com.datastax.oss.driver.internal.core.metrics.SessionMetricUpdater;
 import com.datastax.oss.driver.internal.core.protocol.FrameDecoder;
 import com.datastax.oss.driver.internal.core.protocol.FrameEncoder;
+import com.datastax.oss.driver.internal.core.resolver.Resolver;
+import com.datastax.oss.driver.internal.core.resolver.ResolverProvider;
 import com.datastax.oss.driver.shaded.guava.common.annotations.VisibleForTesting;
 import com.datastax.oss.driver.shaded.guava.common.base.Preconditions;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
@@ -68,6 +70,8 @@ public class ChannelFactory {
 
   private static final Logger LOG = LoggerFactory.getLogger(ChannelFactory.class);
 
+  private static Resolver RESOLVER = ResolverProvider.getResolver(ChannelFactory.class);
+
   /**
    * A value for {@link #productType} that indicates that we are connected to DataStax Cloud. This
    * value matches the one defined at DSE DB server side at {@code ProductType.java}.
@@ -204,7 +208,7 @@ private void connect(
 
     nettyOptions.afterBootstrapInitialized(bootstrap);
 
-    ChannelFuture connectFuture = bootstrap.connect(endPoint.resolve());
+    ChannelFuture connectFuture = bootstrap.connect(RESOLVER.resolve(endPoint.resolve()));
 
     connectFuture.addListener(
         cf -> {

core/src/main/java/com/datastax/oss/driver/internal/core/metadata/SniEndPoint.java

@@ -18,6 +18,8 @@
 package com.datastax.oss.driver.internal.core.metadata;
 
 import com.datastax.oss.driver.api.core.metadata.EndPoint;
+import com.datastax.oss.driver.internal.core.resolver.Resolver;
+import com.datastax.oss.driver.internal.core.resolver.ResolverProvider;
 import com.datastax.oss.driver.shaded.guava.common.primitives.UnsignedBytes;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import java.net.InetAddress;
@@ -30,6 +32,7 @@
 
 public class SniEndPoint implements EndPoint {
   private static final AtomicLong OFFSET = new AtomicLong();
+  private static Resolver RESOLVER = ResolverProvider.getResolver(SniEndPoint.class);
 
   private final InetSocketAddress proxyAddress;
   private final String serverName;
@@ -55,7 +58,7 @@ public String getServerName() {
   @Override
   public InetSocketAddress resolve() {
     try {
-      InetAddress[] aRecords = InetAddress.getAllByName(proxyAddress.getHostName());
+      InetAddress[] aRecords = RESOLVER.getAllByName(proxyAddress.getHostName());
       if (aRecords.length == 0) {
         // Probably never happens, but the JDK docs don't explicitly say so
         throw new IllegalArgumentException(

core/src/main/java/com/datastax/oss/driver/internal/core/resolver/AbstractResolverFactory.java

@@ -0,0 +1,5 @@
+package com.datastax.oss.driver.internal.core.resolver;
+
+public interface AbstractResolverFactory {
+  public Resolver getResolver(Class<?> clazz);
+}

core/src/main/java/com/datastax/oss/driver/internal/core/resolver/Resolver.java

@@ -0,0 +1,48 @@
+package com.datastax.oss.driver.internal.core.resolver;
+
+import com.datastax.oss.driver.internal.core.resolver.defaultResolver.DefaultResolver;
+import java.net.InetAddress;
+import java.net.SocketAddress;
+import java.net.UnknownHostException;
+
+/**
+ * Resolver is a "middleman" class that is meant to serve as a hook point for testing.
+ * Any time core driver tries to resolve a host defined by hostname, such attempt will
+ * go through the Resolver first. At that moment Resolver may return custom result it
+ * was configured to return or simply forward the call to the corresponding InetAddress class
+ * method.
+ *
+ * Some classes are exempt from running through the Resolver and they still call InetAddress directly
+ * (e.g. {@link com.datastax.dse.driver.internal.core.insights.InsightsClient}).
+ * By default, driver should use {@link DefaultResolver}
+ * which should introduce no change in behaviour and redirect all calls to {@link InetAddress).
+ */
+public interface Resolver {
+
+  /**
+   * Replaces calls to {@link InetAddress#getByName(String)}.
+   *
+   * @param host host to resolve.
+   * @return an IP address for the given host name.
+   * @throws UnknownHostException
+   */
+  InetAddress getByName(String host) throws UnknownHostException;
+
+  /**
+   * Replaces calls to {@link InetAddress#getAllByName(String)}
+   *
+   * @param host host to resolve.
+   * @return an array of all the IP addresses for a given host name.
+   * @throws UnknownHostException
+   */
+  InetAddress[] getAllByName(String host) throws UnknownHostException;
+
+  /**
+   * Resolves {@link SocketAddress} returning {@link SocketAddress} To be called just before passing
+   * {@link SocketAddress}, that may be unresolved, to an another library that is going resolve it.
+   *
+   * @param addr SocketAddress with host details
+   * @return SocketAddress instance with possibly modified contents
+   */
+  SocketAddress resolve(SocketAddress addr);
+}

core/src/main/java/com/datastax/oss/driver/internal/core/resolver/ResolverProvider.java

@@ -0,0 +1,32 @@
+package com.datastax.oss.driver.internal.core.resolver;
+
+import com.datastax.oss.driver.internal.core.resolver.defaultResolver.DefaultResolverFactory;
+
+/**
+ * Entry point for driver components to getting the {@link Resolver} instances. By default returns
+ * instances of {@link DefaultResolverFactory}.
+ */
+public class ResolverProvider {
+
+  private static AbstractResolverFactory defaultResolverFactoryImpl = new DefaultResolverFactory();
+
+  /**
+   * Asks factory for new {@link Resolver}.
+   *
+   * @param clazz Class that is requesting the {@link Resolver}.
+   * @return new {@link Resolver}.
+   */
+  public static Resolver getResolver(Class<?> clazz) {
+    return defaultResolverFactoryImpl.getResolver(clazz);
+  }
+
+  /**
+   * Replaces resolver factory with another, possibly producing different implementation of {@link
+   * Resolver}.
+   *
+   * @param resolverFactoryImpl new {@link Resolver} factory.
+   */
+  public static void setDefaultResolverFactory(AbstractResolverFactory resolverFactoryImpl) {
+    defaultResolverFactoryImpl = resolverFactoryImpl;
+  }
+}

core/src/main/java/com/datastax/oss/driver/internal/core/resolver/defaultResolver/DefaultResolver.java

@@ -0,0 +1,47 @@
+package com.datastax.oss.driver.internal.core.resolver.defaultResolver;
+
+import com.datastax.oss.driver.internal.core.resolver.Resolver;
+import java.net.InetAddress;
+import java.net.SocketAddress;
+import java.net.UnknownHostException;
+
+/**
+ * Resolver implementation that forwards all calls to {@link InetAddress} or returns the arguments
+ * unmodified.
+ */
+public class DefaultResolver implements Resolver {
+
+  DefaultResolver() {}
+
+  /**
+   * Equivalent to {@link InetAddress#getByName(String)}.
+   *
+   * @throws UnknownHostException
+   */
+  @Override
+  public InetAddress getByName(String host) throws UnknownHostException {
+    return InetAddress.getByName(host);
+  }
+
+  /**
+   * Equivalent to {@link InetAddress#getAllByName(String)}.
+   *
+   * @throws UnknownHostException
+   */
+  @Override
+  public InetAddress[] getAllByName(String host) throws UnknownHostException {
+    return InetAddress.getAllByName(host);
+  }
+
+  /**
+   * Returns {@link SocketAddress} as is. No reason to resolve it here, it is supposed to be done by
+   * a library that is going to consume the result.
+   *
+   * @param addr {@link SocketAddress}.
+   * @return the very same addr.
+   */
+  @Override
+  public SocketAddress resolve(SocketAddress addr) {
+    return addr;
+  }
+}

core/src/main/java/com/datastax/oss/driver/internal/core/resolver/defaultResolver/DefaultResolverFactory.java

@@ -0,0 +1,23 @@
+package com.datastax.oss.driver.internal.core.resolver.defaultResolver;
+
+import com.datastax.oss.driver.internal.core.resolver.AbstractResolverFactory;
+
+/**
+ * Produces instances of {@link
+ * com.datastax.oss.driver.internal.core.resolver.defaultResolver.DefaultResolver}.
+ */
+public class DefaultResolverFactory implements AbstractResolverFactory {
+
+  /**
+   * Returns new {@link
+   * com.datastax.oss.driver.internal.core.resolver.defaultResolver.DefaultResolver} instance.
+   *
+   * @param clazz Class for which the instance is being created.
+   * @return new {@link
+   *     com.datastax.oss.driver.internal.core.resolver.defaultResolver.DefaultResolver} instance.
+   */
+  @Override
+  public DefaultResolver getResolver(Class<?> clazz) {
+    return new DefaultResolver();
+  }
+}

core/src/main/java/com/datastax/oss/driver/internal/core/resolver/mockResolver/MockResolver.java

@@ -0,0 +1,81 @@
+package com.datastax.oss.driver.internal.core.resolver.mockResolver;
+
+import com.datastax.oss.driver.internal.core.resolver.Resolver;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.UnknownHostException;
+
+/** Resolver implementation that allows returning custom results. */
+public class MockResolver implements Resolver {
+  private final MockResolverResultSource resultSource;
+
+  MockResolver(MockResolverResultSource resultSource) {
+    this.resultSource = resultSource;
+  }
+
+  /**
+   * Returns first {@link InetAddress} from overrided results {@link Response} if one is present.
+   * Otherwise forwards the call to {@link InetAddress#getByName(String)}
+   *
+   * @param host host to resolve.
+   * @return address.
+   * @throws UnknownHostException
+   */
+  @Override
+  public InetAddress getByName(String host) throws UnknownHostException {
+    Response response = this.resultSource.getResponse(host);
+    if (response == null) {
+      return InetAddress.getByName(host);
+    }
+    return response.result()[0];
+  }
+
+  /**
+   * Returns overrided results for provided {@code host}, if one is present, otherwise the call to
+   * Otherwise forwards the call to {@link InetAddress#getAllByName(String)}
+   *
+   * @param host host to resolve.
+   * @return address.
+   * @throws UnknownHostException
+   */
+  @Override
+  public InetAddress[] getAllByName(String host) throws UnknownHostException {
+    Response response = this.resultSource.getResponse(host);
+    if (response == null) {
+      return InetAddress.getAllByName(host);
+    }
+    return response.result();
+  }
+
+  /**
+   * If {@code addr} is an resolved {@link InetSocketAddress}, or there is no response overriding
+   * for the it's host, or {@code addr} is something else, it returns {@code addr} as is. Otherwise
+   * it returns overrided response, if overrided response throws {@link UnknownHostException}, it
+   * emulates it by returning unresolved {@link InetSocketAddress} with bogus host.
+   *
+   * @param addr SocketAddress to modify.
+   * @return possibly new SocketAddress.
+   */
+  @Override
+  public SocketAddress resolve(SocketAddress addr) {
+    if (!(addr instanceof InetSocketAddress)) {
+      return addr;
+    }
+    InetSocketAddress inetSockAddr = ((InetSocketAddress) addr);
+    if (!inetSockAddr.isUnresolved()) {
+      return addr;
+    }
+    String hostname = inetSockAddr.getHostName();
+    int port = inetSockAddr.getPort();
+    Response response = this.resultSource.getResponse(hostname);
+    if (response == null) {
+      return addr;
+    }
+    try {
+      return new InetSocketAddress(response.result()[0], port);
+    } catch (UnknownHostException e) {
+      return InetSocketAddress.createUnresolved(hostname + ".bad.host.115t87", port);
+    }
+  }
+}