feat: Automatically configure connections using DNS. Part of #2043.

Author: hessjcg

core/src/main/java/com/google/cloud/sql/core/ConnectionConfig.java

@@ -200,6 +200,18 @@ public ConnectionConfig withConnectorConfig(ConnectorConfig config) {
         config);
   }
 
+  /** Creates a new instance of the ConnectionConfig with an updated cloudSqlInstance. */
+  public ConnectionConfig withCloudSqlInstance(String newCloudSqlInstance) {
+    return new ConnectionConfig(
+        newCloudSqlInstance,
+        namedConnector,
+        unixSocketPath,
+        ipTypes,
+        authType,
+        unixSocketPathSuffix,
+        connectorConfig);
+  }
+
   public String getNamedConnector() {
     return namedConnector;
   }

core/src/main/java/com/google/cloud/sql/core/Connector.java

@@ -48,6 +48,8 @@ class Connector {
   private final int serverProxyPort;
   private final ConnectorConfig config;
 
+  private final InstanceConnectionNameResolver instanceNameResolver;
+
   Connector(
       ConnectorConfig config,
       ConnectionInfoRepositoryFactory connectionInfoRepositoryFactory,
@@ -56,7 +58,8 @@ class Connector {
       ListenableFuture<KeyPair> localKeyPair,
       long minRefreshDelayMs,
       long refreshTimeoutMs,
-      int serverProxyPort) {
+      int serverProxyPort,
+      InstanceConnectionNameResolver instanceNameResolver) {
     this.config = config;
 
     this.adminApi =
@@ -66,6 +69,7 @@ class Connector {
     this.localKeyPair = localKeyPair;
     this.minRefreshDelayMs = minRefreshDelayMs;
     this.serverProxyPort = serverProxyPort;
+    this.instanceNameResolver = instanceNameResolver;
   }
 
   public ConnectorConfig getConfig() {
@@ -139,9 +143,20 @@ Socket connect(ConnectionConfig config, long timeoutMs) throws IOException {
     }
   }
 
-  ConnectionInfoCache getConnection(ConnectionConfig config) {
+  ConnectionInfoCache getConnection(final ConnectionConfig config) {
+    CloudSqlInstanceName name = null;
+    try {
+      name = instanceNameResolver.resolve(config.getCloudSqlInstance());
+    } catch (IllegalArgumentException e) {
+      throw new IllegalArgumentException(
+          String.format(
+              "Cloud SQL connection name is invalid: \"%s\"", config.getCloudSqlInstance()),
+          e);
+    }
+    final ConnectionConfig updatedConfig = config.withCloudSqlInstance(name.getConnectionName());
+
     ConnectionInfoCache instance =
-        instances.computeIfAbsent(config, k -> createConnectionInfo(config));
+        instances.computeIfAbsent(updatedConfig, k -> createConnectionInfo(updatedConfig));
 
     // If the client certificate has expired (as when the computer goes to
     // sleep, and the refresh cycle cannot run), force a refresh immediately.

core/src/main/java/com/google/cloud/sql/core/DnsInstanceConnectionNameResolver.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Licensed 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 com.google.cloud.sql.core;
+
+import java.util.Collection;
+import java.util.Objects;
+import javax.naming.NameNotFoundException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * An implementation of InstanceConnectionNameResolver that uses DNS SRV records to resolve an
+ * instance name from a domain name.
+ */
+class DnsInstanceConnectionNameResolver implements InstanceConnectionNameResolver {
+  private static final Logger logger =
+      LoggerFactory.getLogger(DnsInstanceConnectionNameResolver.class);
+
+  private final DnsResolver dnsResolver;
+
+  public DnsInstanceConnectionNameResolver(DnsResolver dnsResolver) {
+    this.dnsResolver = dnsResolver;
+  }
+
+  @Override
+  public CloudSqlInstanceName resolve(final String name) {
+    // Attempt to parse the instance name
+    try {
+      return new CloudSqlInstanceName(name);
+    } catch (IllegalArgumentException e) {
+      // Not a well-formed instance name.
+    }
+
+    // Next, attempt to resolve DNS name.
+    Collection<DnsSrvRecord> instanceNames;
+    try {
+      instanceNames = this.dnsResolver.resolveSrv(name);
+    } catch (NameNotFoundException ne) {
+      // No DNS record found. This is not a valid instance name.
+      throw new IllegalArgumentException(
+          String.format("Unable to resolve SRV record for \"%s\".", name));
+    }
+
+    // Use the first valid instance name from the list
+    // or throw an IllegalArgumentException if none of the values can be parsed.
+    return instanceNames.stream()
+        .map(
+            r -> {
+              String target = r.getTarget();
+              // Trim trailing '.' from target field
+              if (target.endsWith(".")) {
+                target = target.substring(0, target.length() - 1);
+              }
+              try {
+                return new CloudSqlInstanceName(target);
+              } catch (IllegalArgumentException e) {
+                logger.info(
+                    "Unable to parse instance name in SRV record for "
+                        + "domain name \"{}\" with target \"{}\"",
+                    name,
+                    target,
+                    e);
+                return null;
+              }
+            })
+        .filter(Objects::nonNull)
+        .findFirst()
+        .orElseThrow(
+            () ->
+                new IllegalArgumentException(
+                    String.format("Unable to parse values of SRV record for \"%s\".", name)));
+  }
+}

core/src/main/java/com/google/cloud/sql/core/DnsResolver.java

@@ -19,6 +19,7 @@
 import java.util.Collection;
 import javax.naming.NameNotFoundException;
 
+/** Wraps the Java DNS API. */
 interface DnsResolver {
-  Collection<DnsSrvRecord> resolveSrv(String domainName) throws NameNotFoundException;
+  Collection<DnsSrvRecord> resolveSrv(String name) throws NameNotFoundException;
 }

core/src/main/java/com/google/cloud/sql/core/DnsSrvRecord.java

@@ -20,17 +20,18 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-public class DnsSrvRecord {
-  private static final Pattern RECORD_FORMAT=Pattern.compile("(\\d+) +(\\d+) +(\\d+) +(.*)");
+/** This represents the value of an SRV DNS Record. */
+class DnsSrvRecord {
+  private static final Pattern RECORD_FORMAT = Pattern.compile("(\\d+) +(\\d+) +(\\d+) +(.*)");
   private final int priority;
   private final int weight;
   private final int port;
   private final String target;
 
   DnsSrvRecord(String record) {
     Matcher m = RECORD_FORMAT.matcher(record);
-    if(! m.find()) {
-      throw new IllegalArgumentException("Malformed SRV record: "+record);
+    if (!m.find()) {
+      throw new IllegalArgumentException("Malformed SRV record: " + record);
     }
 
     this.priority = Integer.parseInt(m.group(1));
@@ -57,13 +58,17 @@ public String getTarget() {
 
   @Override
   public boolean equals(Object o) {
-    if (this == o)
+    if (this == o) {
       return true;
-    if (!(o instanceof DnsSrvRecord))
+    }
+    if (!(o instanceof DnsSrvRecord)) {
       return false;
+    }
     DnsSrvRecord that = (DnsSrvRecord) o;
-    return priority == that.priority && weight == that.weight && port == that.port && target.equals(
-        that.target);
+    return priority == that.priority
+        && weight == that.weight
+        && port == that.port
+        && target.equals(that.target);
   }
 
   @Override

core/src/main/java/com/google/cloud/sql/core/InstanceConnectionNameResolver.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Licensed 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 com.google.cloud.sql.core;
+
+/** Resolves the Cloud SQL Instance for a particular */
+interface InstanceConnectionNameResolver {
+
+  /**
+   * Resolves the CloudSqlInstanceName from a configuration string value.
+   *
+   * @param name the configuration string
+   * @return the CloudSqlInstanceName
+   * @throws IllegalArgumentException if the name cannot be resolved.
+   */
+  CloudSqlInstanceName resolve(String name);
+}

core/src/main/java/com/google/cloud/sql/core/InternalConnectorRegistry.java

@@ -332,7 +332,8 @@ private Connector createConnector(ConnectorConfig config) {
         localKeyPair,
         MIN_REFRESH_DELAY_MS,
         connectTimeoutMs,
-        serverProxyPort);
+        serverProxyPort,
+        new DnsInstanceConnectionNameResolver(new JndiDnsResolver()));
   }
 
   /** Register the configuration for a named connector. */

core/src/main/java/com/google/cloud/sql/core/JndiDnsResolver.java

@@ -25,42 +25,41 @@
 import javax.naming.directory.Attribute;
 import javax.naming.directory.InitialDirContext;
 
-/**
- * Implements DnsResolver using the Java JNDI built-in DNS directory.
- */
+/** Implements DnsResolver using the Java JNDI built-in DNS directory. */
 class JndiDnsResolver implements DnsResolver {
   private final String jndiPrefix;
 
-  /**
-   * Creates a resolver using the system DNS settings.
-   */
+  /** Creates a resolver using the system DNS settings. */
   JndiDnsResolver() {
     this.jndiPrefix = "dns:";
   }
 
   /**
    * Creates a DNS resolver that uses a specific DNS server.
+   *
    * @param dnsServer the DNS server hostname
    * @param port the DNS server port (DNS servers usually use port 53)
    */
   JndiDnsResolver(String dnsServer, int port) {
-    this.jndiPrefix = "dns://"+dnsServer+":"+port+"/";
+    this.jndiPrefix = "dns://" + dnsServer + ":" + port + "/";
   }
 
   /**
    * Returns DNS records for a domain name, sorted by priority, then target alphabetically.
+   *
    * @param domainName the domain name to lookup
    * @return the list of record
    * @throws javax.naming.NameNotFoundException when the domain name did not resolve.
    */
   @Override
-  public Collection<DnsSrvRecord> resolveSrv(String domainName) throws javax.naming.NameNotFoundException{
+  public Collection<DnsSrvRecord> resolveSrv(String domainName)
+      throws javax.naming.NameNotFoundException {
     try {
       // Notice: This is old Java 1.2 style code. It uses the ancient JNDI DNS Provider api.
       // See https://docs.oracle.com/javase/7/docs/technotes/guides/jndi/jndi-dns.html
       Attribute attr =
           new InitialDirContext()
-              .getAttributes(jndiPrefix+domainName, new String[] {"SRV"})
+              .getAttributes(jndiPrefix + domainName, new String[] {"SRV"})
               .get("SRV");
       // attr.getAll() returns a Vector containing strings, one for each record returned by dns.
       return Collections.list(attr.getAll()).stream()
@@ -69,9 +68,8 @@ public Collection<DnsSrvRecord> resolveSrv(String domainName) throws javax.namin
           .collect(Collectors.toList());
     } catch (NameNotFoundException e) {
       throw e;
-    }
-    catch (NamingException e) {
-      throw new RuntimeException("Unable to look up domain name "+domainName, e);
+    } catch (NamingException e) {
+      throw new RuntimeException("Unable to look up domain name " + domainName, e);
     }
   }
 }