refactor(client-routes): replace CachingDnsResolver with FallbackDnsResolver

The JVM (Java 8+) already caches DNS lookups internally (~30s TTL), making the
500ms TTL layer in CachingDnsResolver redundant — the JVM's cache always wins.
The semaphore storm-prevention machinery is similarly superfluous since the JVM
serializes concurrent lookups to the same hostname internally.

The only genuine value-add is the last-known-good fallback: returning a stale IP
when DNS temporarily fails.

Remove CachingDnsResolver (TTL cache, CacheEntry, SemaphoreEntry, semaphore
logic, cacheDurationMillis constructor arg). Replace with FallbackDnsResolver
that delegates directly to InetAddress.getByName() and keeps a lastKnownGood map.

Remove dnsCacheDurationMillis from ClientRoutesConfig (field, getter,
withDnsCacheDuration() builder method, DEFAULT_DNS_CACHE_DURATION_MILLIS).

Update ClientRoutesTopologyMonitor to use new FallbackDnsResolver().

Replace CachingDnsResolverTest with FallbackDnsResolverTest; delete TTL and
semaphore tests, keep fallback, evict, and clearCache coverage.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: nikagra

core/src/main/java/com/datastax/oss/driver/api/core/config/ClientRoutesConfig.java

@@ -46,7 +46,6 @@
  *     .addEndpoint(new ClientRoutesEndpoint(
  *         UUID.fromString("12345678-1234-1234-1234-123456789012"),
  *         "my-cluster-endpoint.example.com:9042"))
- *     .withDnsCacheDuration(1000L)  // Cache DNS for 1 second (default: 500ms)
  *     .build();
  *
  * CqlSession session = CqlSession.builder()
@@ -61,23 +60,16 @@
 public class ClientRoutesConfig {
 
   private static final String DEFAULT_TABLE_NAME = "system.client_routes";
-  private static final long DEFAULT_DNS_CACHE_DURATION_MILLIS = 500L;
 
   private final List<ClientRoutesEndpoint> endpoints;
   private final String tableName;
-  private final long dnsCacheDurationMillis;
 
-  private ClientRoutesConfig(
-      List<ClientRoutesEndpoint> endpoints, String tableName, long dnsCacheDurationMillis) {
+  private ClientRoutesConfig(List<ClientRoutesEndpoint> endpoints, String tableName) {
     if (endpoints == null || endpoints.isEmpty()) {
       throw new IllegalArgumentException("At least one endpoint must be specified");
     }
-    if (dnsCacheDurationMillis < 0) {
-      throw new IllegalArgumentException("DNS cache duration must be non-negative");
-    }
     this.endpoints = Collections.unmodifiableList(new ArrayList<>(endpoints));
     this.tableName = tableName;
-    this.dnsCacheDurationMillis = dnsCacheDurationMillis;
   }
 
   /**
@@ -100,19 +92,6 @@ public String getTableName() {
     return tableName;
   }
 
-  /**
-   * Returns the DNS cache duration in milliseconds.
-   *
-   * <p>This controls how long resolved DNS entries are cached before being re-resolved. A shorter
-   * duration is appropriate for dynamic environments where DNS mappings change frequently, while a
-   * longer duration can reduce DNS lookup overhead in stable environments.
-   *
-   * @return the DNS cache duration in milliseconds (default: 500ms).
-   */
-  public long getDnsCacheDurationMillis() {
-    return dnsCacheDurationMillis;
-  }
-
   /**
    * Creates a new builder for constructing a {@link ClientRoutesConfig}.
    *
@@ -132,14 +111,12 @@ public boolean equals(Object o) {
       return false;
     }
     ClientRoutesConfig that = (ClientRoutesConfig) o;
-    return dnsCacheDurationMillis == that.dnsCacheDurationMillis
-        && endpoints.equals(that.endpoints)
-        && Objects.equals(tableName, that.tableName);
+    return endpoints.equals(that.endpoints) && Objects.equals(tableName, that.tableName);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(endpoints, tableName, dnsCacheDurationMillis);
+    return Objects.hash(endpoints, tableName);
   }
 
   @Override
@@ -150,16 +127,13 @@ public String toString() {
         + ", tableName='"
         + tableName
         + '\''
-        + ", dnsCacheDurationMillis="
-        + dnsCacheDurationMillis
         + '}';
   }
 
   /** Builder for {@link ClientRoutesConfig}. */
   public static class Builder {
     private final List<ClientRoutesEndpoint> endpoints = new ArrayList<>();
     private String tableName = DEFAULT_TABLE_NAME;
-    private long dnsCacheDurationMillis = DEFAULT_DNS_CACHE_DURATION_MILLIS;
 
     /**
      * Adds an endpoint to the configuration.
@@ -208,29 +182,6 @@ public Builder withTableName(@Nullable String tableName) {
       return this;
     }
 
-    /**
-     * Sets the DNS cache duration in milliseconds.
-     *
-     * <p>This controls how long resolved DNS entries are cached before being re-resolved. A shorter
-     * duration is appropriate for dynamic environments where DNS mappings change frequently (e.g.,
-     * during rolling updates), while a longer duration can reduce DNS lookup overhead in stable
-     * environments.
-     *
-     * <p>Default: 500ms
-     *
-     * @param durationMillis the cache duration in milliseconds (must be non-negative).
-     * @return this builder.
-     * @throws IllegalArgumentException if the duration is negative.
-     */
-    @NonNull
-    public Builder withDnsCacheDuration(long durationMillis) {
-      if (durationMillis < 0) {
-        throw new IllegalArgumentException("DNS cache duration must be non-negative");
-      }
-      this.dnsCacheDurationMillis = durationMillis;
-      return this;
-    }
-
     /**
      * Builds the {@link ClientRoutesConfig} with the configured endpoints and table name.
      *
@@ -239,7 +190,7 @@ public Builder withDnsCacheDuration(long durationMillis) {
      */
     @NonNull
     public ClientRoutesConfig build() {
-      return new ClientRoutesConfig(endpoints, tableName, dnsCacheDurationMillis);
+      return new ClientRoutesConfig(endpoints, tableName);
     }
   }
 }

core/src/main/java/com/datastax/oss/driver/internal/core/clientroutes/CachingDnsResolver.java

@@ -22,32 +22,30 @@
 import java.net.UnknownHostException;
 
 /**
- * Interface for DNS resolution with caching support.
+ * Interface for DNS resolution with last-known-good fallback support.
  *
- * <p>Implementations should provide caching to avoid DNS storms during application startup and
- * should handle resolution failures gracefully (e.g., by returning the last known good IP).
+ * <p>Implementations delegate to the JVM's DNS resolver (which already provides internal caching)
+ * and retain the last successfully resolved address per hostname so that transient DNS failures can
+ * be handled gracefully.
  *
  * <p>This interface is part of the internal API and is not intended for public use.
  */
 public interface DnsResolver {
 
   /**
-   * Resolves a hostname to an IP address, potentially using a cache.
+   * Resolves a hostname to an IP address.
    *
    * <p>Implementations should:
    *
    * <ul>
-   *   <li>Cache successful resolutions for a configurable duration (default: 500ms per
-   *       Description.md)
-   *   <li>Return cached results when available and not expired
+   *   <li>On success, store the resolved address as the last-known-good for the hostname
    *   <li>On failure, return the last known good IP if available
-   *   <li>Limit concurrency to avoid DNS storms (default: 1 concurrent resolution per hostname)
    * </ul>
    *
    * @param hostname the hostname to resolve (must not be null)
    * @return the resolved IP address
-   * @throws UnknownHostException if the hostname cannot be resolved and no cached value is
-   *     available
+   * @throws UnknownHostException if the hostname cannot be resolved and no last-known-good address
+   *     is available
    */
   @NonNull
   InetAddress resolve(@NonNull String hostname) throws UnknownHostException;
@@ -65,15 +63,10 @@ public interface DnsResolver {
   void evict(@NonNull String hostname);
 
   /**
-   * Clears all cached DNS entries, but intentionally retains last-known-good addresses so that the
-   * fallback mechanism continues to work after a cache flush.
+   * Clears all last-known-good addresses.
    *
    * <p>This method is called exactly once, by {@code ClientRoutesHandler.close()}, when the session
-   * is shut down. It is <strong>not</strong> called during route-map refreshes (triggered by {@code
-   * CLIENT_ROUTES_CHANGE} events or control-connection reconnects); those refreshes re-query the
-   * routes table but let the TTL-based DNS cache expire naturally.
-   *
-   * <p>This method is not intended for manual or administrative use outside of session close.
+   * is shut down.
    */
   void clearCache();
 }