ZOOKEEPER-4956: Provide a HostProvider that uses DNS SRV record for dynamic server discovery

Author: Li Wang <[email protected]>

Author: liwang

pom.xml

@@ -573,6 +573,7 @@
     <enforcer.version>3.0.0-M3</enforcer.version>
     <commons-io.version>2.17.0</commons-io.version>
     <burningwave.mockdns.version>0.25.4</burningwave.mockdns.version>
+    <dnsjava.version>3.5.1</dnsjava.version>
     <clover-maven-plugin.version>4.4.1</clover-maven-plugin.version>
     <sonar-maven-plugin.version>3.7.0.1746</sonar-maven-plugin.version>
 
@@ -774,6 +775,11 @@
         <artifactId>tools</artifactId>
         <version>${burningwave.mockdns.version}</version>
       </dependency>
+      <dependency>
+        <groupId>dnsjava</groupId>
+        <artifactId>dnsjava</artifactId>
+        <version>${dnsjava.version}</version>
+      </dependency>
     </dependencies>
   </dependencyManagement>
 

zookeeper-docs/src/main/resources/markdown/zookeeperAdmin.md

@@ -1315,6 +1315,14 @@ of servers -- that is, when deploying clusters of servers.
     leader election. If you want to test multiple servers on a single machine, then
     different ports can be used for each server.
 
+* *hostProvider.dnsSrvRefreshIntervalSecond* :
+    (Java system property: **zookeeper.hostProvider.dnsSrvRefreshIntervalSeconds**)
+    **New in 3.10.0:**
+    The refresh interval in seconds for DNS SRV record lookups when using DnsSrvHostProvider.
+    This property controls how frequently the DNS SRV records are queried to update the server list.
+    A value of 0 disables periodic refresh. 
+   
+    The default value is 60 (60 seconds).
 
     <a name="id_multi_address"></a>
     Since ZooKeeper 3.6.0 it is possible to specify **multiple addresses** for each

zookeeper-server/pom.xml

@@ -190,6 +190,10 @@
       <artifactId>commons-io</artifactId>
       <scope>compile</scope>
     </dependency>
+    <dependency>
+      <groupId>dnsjava</groupId>
+      <artifactId>dnsjava</artifactId>
+    </dependency>
   </dependencies>
 
   <build>

zookeeper-server/src/main/java/org/apache/zookeeper/ZooKeeper.java

@@ -46,6 +46,7 @@
 import org.apache.zookeeper.client.Chroot;
 import org.apache.zookeeper.client.ConnectStringParser;
 import org.apache.zookeeper.client.HostProvider;
+import org.apache.zookeeper.client.HostProviderFactory;
 import org.apache.zookeeper.client.StaticHostProvider;
 import org.apache.zookeeper.client.ZKClientConfig;
 import org.apache.zookeeper.client.ZooKeeperBuilder;
@@ -1140,10 +1141,9 @@ public ZooKeeper(ZooKeeperOptions options) throws IOException {
         if (options.getHostProvider() != null) {
             hostProvider = options.getHostProvider().apply(connectStringParser.getServerAddresses());
         } else {
-            hostProvider = new StaticHostProvider(connectStringParser.getServerAddresses(), clientConfig);
+           hostProvider = HostProviderFactory.create(connectStringParser, clientConfig);
         }
         this.hostProvider = hostProvider;
-
         chroot = Chroot.ofNullable(connectStringParser.getChrootPath());
         cnxn = createConnection(
             hostProvider,
@@ -1329,6 +1329,11 @@ public synchronized void close() throws InterruptedException {
             LOG.debug("Ignoring unexpected exception during close", e);
         }
 
+        // Close the host provider to release any resources
+        if (hostProvider != null) {
+            hostProvider.close();
+        }
+
         LOG.info("Session: 0x{} closed", Long.toHexString(getSessionId()));
     }
 

zookeeper-server/src/main/java/org/apache/zookeeper/client/ConnectStringParser.java

@@ -24,6 +24,7 @@
 import java.util.List;
 import org.apache.zookeeper.common.NetUtils;
 import org.apache.zookeeper.common.PathUtils;
+import org.apache.zookeeper.common.StringUtils;
 
 /**
  * A parser for ZooKeeper Client connect strings.
@@ -37,39 +38,82 @@
  */
 public final class ConnectStringParser {
 
-    private static final int DEFAULT_PORT = 2181;
+    public enum ConnectionType {
+        DNS_SRV,
+        HOST_PORT
+    }
 
-    private final String chrootPath;
+    private static final String DNS_SRV_PREFIX = "dns-srv://";
+    private static final int DEFAULT_PORT = 2181;
 
+    private final String connectString;
+    private final ConnectionType connectionType;
+    private String chrootPath;
     private final ArrayList<InetSocketAddress> serverAddresses = new ArrayList<>();
 
     /**
-     * Parse host and port by splitting client connectString
-     * with support for IPv6 literals
-     * @throws IllegalArgumentException
-     *             for an invalid chroot path.
+     * Constructs a ConnectStringParser with given connection string.
+     *
+     * <p>Supports two connection string formats:</p>
+     * <ul>
+     * <li><strong>Host:Port format:</strong> "host1:2181,host2:2181/chroot"</li>
+     * <li><strong>DNS SRV format:</strong> "dns-srv://service.domain.com/chroot"</li>
+     * </ul>
+     *
+     * @param connectString the connection string to parse
+     * @throws IllegalArgumentException if connectString is null/empty or contains invalid chroot path
      */
-    public ConnectStringParser(String connectString) {
-        // parse out chroot, if any
-        int off = connectString.indexOf('/');
-        if (off >= 0) {
-            String chrootPath = connectString.substring(off);
-            // ignore "/" chroot spec, same as null
-            if (chrootPath.length() == 1) {
-                this.chrootPath = null;
-            } else {
-                PathUtils.validatePath(chrootPath);
-                this.chrootPath = chrootPath;
-            }
-            connectString = connectString.substring(0, off);
+    public ConnectStringParser(final String connectString) {
+        if (StringUtils.isBlank(connectString)) {
+            throw new IllegalArgumentException("Connect string cannot be null or empty");
+        }
+
+        this.connectString = connectString;
+        if (connectString.startsWith(DNS_SRV_PREFIX)) {
+            connectionType = ConnectionType.DNS_SRV;
+            parseDnsSrvFormat(connectString);
         } else {
-            this.chrootPath = null;
+            connectionType = ConnectionType.HOST_PORT;
+            parseHostPortFormat(connectString);
         }
+    }
+
+    public String getChrootPath() {
+        return chrootPath;
+    }
+
+    public ArrayList<InetSocketAddress> getServerAddresses() {
+        return serverAddresses;
+    }
 
-        List<String> hostsList = split(connectString, ",");
+    public String getConnectString() {
+        return connectString;
+    }
+
+    public ConnectionType getConnectionType() {
+        return connectionType;
+    }
+
+    private void parseDnsSrvFormat(final String connectString) {
+        final String dnsName = connectString.substring(DNS_SRV_PREFIX.length());
+        final String[] parts = extractChrootPath(dnsName);
+        final String dnsServiceName = parts[0];
+
+        chrootPath = parts[1];
+        // The DNS service name is stored as a placeholder address
+        // The actual resolution will be handled by DnsSrvHostProvider
+        serverAddresses.add(InetSocketAddress.createUnresolved(dnsServiceName, DEFAULT_PORT));
+    }
+
+    private void parseHostPortFormat(String connectString) {
+        final String[] parts = extractChrootPath(connectString);
+        final String serverPart = parts[0];
+        chrootPath = parts[1];
+
+        final List<String> hostsList = split(serverPart, ",");
         for (String host : hostsList) {
             int port = DEFAULT_PORT;
-            String[] hostAndPort = NetUtils.getIPV6HostAndPort(host);
+            final String[] hostAndPort = NetUtils.getIPV6HostAndPort(host);
             if (hostAndPort.length != 0) {
                 host = hostAndPort[0];
                 if (hostAndPort.length == 2) {
@@ -89,12 +133,23 @@ public ConnectStringParser(String connectString) {
         }
     }
 
-    public String getChrootPath() {
-        return chrootPath;
-    }
+    private String[] extractChrootPath(final String connectionString) {
+        String serverPart = connectionString;
+        String chrootPath = null;
 
-    public ArrayList<InetSocketAddress> getServerAddresses() {
-        return serverAddresses;
+        // parse out chroot, if any
+        final int chrootIndex = connectionString.indexOf('/');
+        if (chrootIndex >= 0) {
+            chrootPath = connectionString.substring(chrootIndex);
+            // ignore "/" chroot spec, same as null
+            if (chrootPath.length() == 1) {
+                chrootPath = null;
+            } else {
+                PathUtils.validatePath(chrootPath);
+            }
+            serverPart = connectionString.substring(0, chrootIndex);
+        }
+        return new String[]{serverPart, chrootPath};
     }
 
 }