feat(net): support domain names in peer configuration

common/build.gradle

@@ -21,7 +21,8 @@ dependencies {
     api 'org.aspectj:aspectjrt:1.9.8'
     api 'org.aspectj:aspectjweaver:1.9.8'
     api 'org.aspectj:aspectjtools:1.9.8'
-    api group: 'io.github.tronprotocol', name: 'libp2p', version: '2.2.7',{
+    api group: 'com.github.tronprotocol', name: 'libp2p', version: 'release-v2.2.8-SNAPSHOT',{
+    //api group: 'io.github.tronprotocol', name: 'libp2p', version: '2.2.7',{
         exclude group: 'io.grpc', module: 'grpc-context'
         exclude group: 'io.grpc', module: 'grpc-core'
         exclude group: 'io.grpc', module: 'grpc-netty'

framework/src/main/java/org/tron/common/backup/BackupManager.java

@@ -4,13 +4,18 @@
 import static org.tron.common.backup.BackupManager.BackupStatusEnum.MASTER;
 import static org.tron.common.backup.BackupManager.BackupStatusEnum.SLAVER;
 import static org.tron.common.backup.message.UdpMessageTypeEnum.BACKUP_KEEP_ALIVE;
+import static org.tron.core.config.args.InetUtil.resolveInetAddress;
 
 import io.netty.util.internal.ConcurrentSet;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
+import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
+import lombok.Getter;
+import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import org.tron.common.backup.message.KeepAliveMessage;
@@ -20,46 +25,45 @@
 import org.tron.common.backup.socket.UdpEvent;
 import org.tron.common.es.ExecutorServiceManager;
 import org.tron.common.parameter.CommonParameter;
+import org.tron.p2p.utils.NetUtil;
 
 @Slf4j(topic = "backup")
 @Component
 public class BackupManager implements EventHandler {
 
-  private CommonParameter parameter = CommonParameter.getInstance();
+  private final CommonParameter parameter = CommonParameter.getInstance();
 
-  private int priority = parameter.getBackupPriority();
+  private final int priority = parameter.getBackupPriority();
 
-  private int port = parameter.getBackupPort();
+  private final int port = parameter.getBackupPort();
 
-  private int keepAliveInterval = parameter.getKeepAliveInterval();
+  private final int keepAliveInterval = parameter.getKeepAliveInterval();
 
-  private int keepAliveTimeout = keepAliveInterval * 6;
+  private final int keepAliveTimeout = keepAliveInterval * 6;
 
   private String localIp = "";
 
-  private Set<String> members = new ConcurrentSet<>();
+  private final Set<String> members = new ConcurrentSet<>();
 
-  private final String esName = "backup-manager";
+  private final Map<String, String> domainIpCache = new ConcurrentHashMap<>();
 
-  private ScheduledExecutorService executorService =
+  private final String esName = "backup-manager";
+  private final ScheduledExecutorService executorService =
       ExecutorServiceManager.newSingleThreadScheduledExecutor(esName);
 
+  private final String dnsEsName = "backup-dns-refresh";
+  private ScheduledExecutorService dnsExecutorService;
+
+  @Setter
   private MessageHandler messageHandler;
 
+  @Getter
   private BackupStatusEnum status = MASTER;
 
   private volatile long lastKeepAliveTime;
 
   private volatile boolean isInit = false;
 
-  public void setMessageHandler(MessageHandler messageHandler) {
-    this.messageHandler = messageHandler;
-  }
-
-  public BackupStatusEnum getStatus() {
-    return status;
-  }
-
   public void setStatus(BackupStatusEnum status) {
     logger.info("Change backup status to {}", status);
     this.status = status;
@@ -78,10 +82,20 @@ public void init() {
       logger.warn("Failed to get local ip");
     }
 
-    for (String member : parameter.getBackupMembers()) {
-      if (!localIp.equals(member)) {
-        members.add(member);
+    for (String ipOrDomain : parameter.getBackupMembers()) {
+      InetAddress inetAddress = resolveInetAddress(ipOrDomain);
+      if (inetAddress == null) {
+        logger.warn("Failed to resolve backup member domain: {}", ipOrDomain);
+        continue;
+      }
+      String ip = inetAddress.getHostAddress();
+      if (localIp.equals(ip)) {
+        continue;
+      }
+      if (!NetUtil.validIpV4(ipOrDomain) && !NetUtil.validIpV6(ipOrDomain)) {
+        domainIpCache.put(ipOrDomain, ip);
       }
+      members.add(ip);
     }
 
     logger.info("Backup localIp:{}, members: size= {}, {}", localIp, members.size(), members);
@@ -111,6 +125,17 @@ public void init() {
         logger.error("Exception in send keep alive", t);
       }
     }, 1000, keepAliveInterval, TimeUnit.MILLISECONDS);
+
+    if (!domainIpCache.isEmpty()) {
+      dnsExecutorService = ExecutorServiceManager.newSingleThreadScheduledExecutor(dnsEsName);
+      dnsExecutorService.scheduleWithFixedDelay(() -> {
+        try {
+          refreshMemberIps();
+        } catch (Throwable t) {
+          logger.error("Exception in backup DNS refresh", t);
+        }
+      }, 60_000L, 60_000L, TimeUnit.MILLISECONDS);
+    }
   }
 
   @Override
@@ -149,6 +174,9 @@ public void handleEvent(UdpEvent udpEvent) {
 
   public void stop() {
     ExecutorServiceManager.shutdownAndAwaitTermination(executorService, esName);
+    if (dnsExecutorService != null) {
+      ExecutorServiceManager.shutdownAndAwaitTermination(dnsExecutorService, dnsEsName);
+    }
   }
 
   @Override
@@ -162,4 +190,26 @@ public enum BackupStatusEnum {
     MASTER
   }
 
+  /**
+   * Re-resolves all tracked domain entries. If an IP has changed, the old IP is
+   * removed from {@link #members} and the new IP is added.
+   */
+  private void refreshMemberIps() {
+    for (Map.Entry<String, String> entry : domainIpCache.entrySet()) {
+      String domain = entry.getKey();
+      String oldIp = entry.getValue();
+      InetAddress inetAddress = resolveInetAddress(domain);
+      if (inetAddress == null) {
+        logger.warn("DNS refresh: failed to re-resolve backup member domain {}, keep it", domain);
+        continue;
+      }
+      String newIp = inetAddress.getHostAddress();
+      if (!newIp.equals(oldIp)) {
+        logger.info("DNS refresh: backup member {} IP changed {} -> {}", domain, oldIp, newIp);
+        members.remove(oldIp);
+        members.add(newIp);
+        domainIpCache.put(domain, newIp);
+      }
+    }
+  }
 }

framework/src/main/java/org/tron/core/config/args/Args.java

@@ -4,6 +4,8 @@
 import static org.tron.common.math.Maths.max;
 import static org.tron.core.Constant.ADD_PRE_FIX_BYTE_MAINNET;
 import static org.tron.core.Constant.ENERGY_LIMIT_IN_CONSTANT_TX;
+import static org.tron.core.config.args.InetUtil.resolveInetAddress;
+import static org.tron.core.config.args.InetUtil.resolveInetSocketAddressList;
 
 import com.beust.jcommander.JCommander;
 import com.beust.jcommander.ParameterDescription;
@@ -13,6 +15,7 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.text.ParseException;
 import java.util.ArrayList;
@@ -252,6 +255,7 @@ private static void applyNodeBackupConfig(NodeConfig nc) {
     PARAMETER.backupPort = b.getPort();
     PARAMETER.keepAliveInterval = b.getKeepAliveInterval();
     PARAMETER.backupMembers = b.getMembers();
+    checkBackupMembers();
   }
 
   /**
@@ -306,10 +310,7 @@ private static void applyMiscConfig(MiscConfig mc) {
     // seed.node — top-level config section, not under "node"
     // Config structure is arguably misplaced but preserved for backward compatibility
     PARAMETER.seedNode = new SeedNode();
-    PARAMETER.seedNode.setAddressList(
-        mc.getSeedNodeIpList().stream()
-            .map(s -> org.tron.p2p.utils.NetUtil.parseInetSocketAddress(s))
-            .collect(Collectors.toList()));
+    PARAMETER.seedNode.setAddressList(resolveInetSocketAddressList(mc.getSeedNodeIpList()));
   }
 
   /**
@@ -908,10 +909,7 @@ private static void applyCLIParams(CLIParameter cmd, JCommander jc) {
     if (!cmd.seedNodes.isEmpty()) {
       logger.warn("Positional seed-node arguments are deprecated. "
           + "Please use seed.node.ip.list in the config file instead.");
-      List<InetSocketAddress> seeds = new ArrayList<>();
-      for (String s : cmd.seedNodes) {
-        seeds.add(NetUtil.parseInetSocketAddress(s));
-      }
+      List<InetSocketAddress> seeds = resolveInetSocketAddressList(cmd.seedNodes);
       PARAMETER.seedNode.setAddressList(seeds);
     }
   }
@@ -984,8 +982,7 @@ public static void clearParam() {
   public static List<InetSocketAddress> filterInetSocketAddress(
       List<String> addressList, boolean filter) {
     List<InetSocketAddress> ret = new ArrayList<>();
-    for (String configString : addressList) {
-      InetSocketAddress inetSocketAddress = NetUtil.parseInetSocketAddress(configString);
+    for (InetSocketAddress inetSocketAddress : resolveInetSocketAddressList(addressList)) {
       if (filter) {
         String ip = inetSocketAddress.getAddress().getHostAddress();
         int port = inetSocketAddress.getPort();
@@ -1133,6 +1130,16 @@ private static void externalIp(NodeConfig nodeConfig) {
   // initRocksDbSettings, initRocksDbBackupProperty, initBackupProperty
   // removed — logic moved to applyStorageConfig() and applyNodeBackupConfig()
 
+  private static void checkBackupMembers() {
+    for (String member : PARAMETER.backupMembers) {
+      InetAddress inetAddress = resolveInetAddress(member);
+      if (inetAddress == null) {
+        throw new TronError("Failed to resolve backup member: " + member,
+            TronError.ErrCode.PARAMETER_INIT);
+      }
+    }
+  }
+
   public static void logConfig() {
     CommonParameter parameter = CommonParameter.getInstance();
     logger.info("\n");