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.317787106', name: 'libp2p', version: 'v0.10.0',{
+    //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,46 @@
 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 final ScheduledExecutorService dnsExecutorService =
+      ExecutorServiceManager.newSingleThreadScheduledExecutor(dnsEsName);
+
+  @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 +83,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 +126,16 @@ public void init() {
         logger.error("Exception in send keep alive", t);
       }
     }, 1000, keepAliveInterval, TimeUnit.MILLISECONDS);
+
+    if (!domainIpCache.isEmpty()) {
+      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,7 @@ public void handleEvent(UdpEvent udpEvent) {
 
   public void stop() {
     ExecutorServiceManager.shutdownAndAwaitTermination(executorService, esName);
+    ExecutorServiceManager.shutdownAndAwaitTermination(dnsExecutorService, dnsEsName);
   }
 
   @Override
@@ -162,4 +188,28 @@ 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);
+        if (!localIp.equals(newIp)) {
+          members.add(newIp);
+        }
+        domainIpCache.put(domain, newIp);
+      }
+    }
+  }
 }

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

@@ -12,6 +12,7 @@
 import static org.tron.core.Constant.MIN_PROPOSAL_EXPIRE_TIME;
 import static org.tron.core.config.Parameter.ChainConstant.BLOCK_PRODUCE_TIMEOUT_PERCENT;
 import static org.tron.core.config.Parameter.ChainConstant.MAX_ACTIVE_WITNESS_NUM;
+import static org.tron.core.config.args.InetUtil.resolveInetAddress;
 import static org.tron.core.exception.TronError.ErrCode.PARAMETER_INIT;
 
 import com.beust.jcommander.JCommander;
@@ -37,7 +38,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.Properties;
 import java.util.Set;
 import java.util.concurrent.BlockingQueue;
@@ -1301,15 +1301,12 @@ private static RateLimiterInitialization getRateLimiterFromConfig(
     return initialization;
   }
 
+
   public static List<InetSocketAddress> getInetSocketAddress(
       final com.typesafe.config.Config config, String path, boolean filter) {
     List<InetSocketAddress> ret = new ArrayList<>();
-    if (!config.hasPath(path)) {
-      return ret;
-    }
-    List<String> list = config.getStringList(path);
-    for (String configString : list) {
-      InetSocketAddress inetSocketAddress = NetUtil.parseInetSocketAddress(configString);
+    List<InetSocketAddress> socketAddressList = getInetSockerAddress(config, path);
+    for (InetSocketAddress inetSocketAddress : socketAddressList) {
       if (filter) {
         String ip = inetSocketAddress.getAddress().getHostAddress();
         int port = inetSocketAddress.getPort();
@@ -1326,15 +1323,27 @@ public static List<InetSocketAddress> getInetSocketAddress(
     return ret;
   }
 
-  public static List<InetAddress> getInetAddress(
+  private static List<InetSocketAddress> getInetSockerAddress(
       final com.typesafe.config.Config config, String path) {
-    List<InetAddress> ret = new ArrayList<>();
+    List<InetSocketAddress> socketAddressList = new ArrayList<>();
     if (!config.hasPath(path)) {
-      return ret;
+      return socketAddressList;
     }
     List<String> list = config.getStringList(path);
-    for (String configString : list) {
-      InetSocketAddress inetSocketAddress = NetUtil.parseInetSocketAddress(configString);
+    try {
+      socketAddressList = InetUtil.resolveInetSocketAddressList(list);
+    } catch (RuntimeException e) {
+      throw new TronError(String.format("config %s contains %s", path, e.getMessage()),
+          TronError.ErrCode.PARAMETER_INIT);
+    }
+    return socketAddressList;
+  }
+
+  public static List<InetAddress> getInetAddress(
+      final com.typesafe.config.Config config, String path) {
+    List<InetAddress> ret = new ArrayList<>();
+    List<InetSocketAddress> socketAddressList = getInetSockerAddress(config, path);
+    for (InetSocketAddress inetSocketAddress : socketAddressList) {
       ret.add(inetSocketAddress.getAddress());
     }
     return ret;
@@ -1660,6 +1669,17 @@ private static void initBackupProperty(Config config) {
 
     PARAMETER.backupMembers = config.hasPath(ConfigKey.NODE_BACKUP_MEMBERS)
         ? config.getStringList(ConfigKey.NODE_BACKUP_MEMBERS) : new ArrayList<>();
+    checkBackupMembers();
+  }
+
+  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() {