optimize InetUtil and BackupManager

Author: 317787106

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

@@ -52,8 +52,7 @@ public class BackupManager implements EventHandler {
       ExecutorServiceManager.newSingleThreadScheduledExecutor(esName);
 
   private final String dnsEsName = "backup-dns-refresh";
-  private final ScheduledExecutorService dnsExecutorService =
-      ExecutorServiceManager.newSingleThreadScheduledExecutor(dnsEsName);
+  private ScheduledExecutorService dnsExecutorService;
 
   @Setter
   private MessageHandler messageHandler;
@@ -128,6 +127,7 @@ public void init() {
     }, 1000, keepAliveInterval, TimeUnit.MILLISECONDS);
 
     if (!domainIpCache.isEmpty()) {
+      dnsExecutorService = ExecutorServiceManager.newSingleThreadScheduledExecutor(dnsEsName);
       dnsExecutorService.scheduleWithFixedDelay(() -> {
         try {
           refreshMemberIps();
@@ -174,7 +174,9 @@ public void handleEvent(UdpEvent udpEvent) {
 
   public void stop() {
     ExecutorServiceManager.shutdownAndAwaitTermination(executorService, esName);
-    ExecutorServiceManager.shutdownAndAwaitTermination(dnsExecutorService, dnsEsName);
+    if (dnsExecutorService != null) {
+      ExecutorServiceManager.shutdownAndAwaitTermination(dnsExecutorService, dnsEsName);
+    }
   }
 
   @Override

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

@@ -5,11 +5,15 @@
 import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.BiFunction;
 import lombok.extern.slf4j.Slf4j;
 import org.tron.common.es.ExecutorServiceManager;
 import org.tron.p2p.dns.lookup.LookUpTxt;
@@ -20,6 +24,13 @@ public class InetUtil {
 
   private static final String DNS_POOL_NAME = "args-dns-lookup";
   private static final int DNS_POOL_MAX_SIZE = 10;
+  // Per-lookup wall-clock budget. After this, the entry is treated as unresolvable.
+  private static final long DNS_LOOKUP_TIMEOUT_SECONDS = 10;
+
+  // Overridable in tests so worker threads (parallel path) can use a non-network lookup.
+  // Reset to LookUpTxt::lookUpIp after each test that overrides it.
+  public static volatile BiFunction<String, Boolean, InetAddress> dnsLookup =
+      LookUpTxt::lookUpIp;
 
   /**
    * Converts a list of {@code ipOrDomain:port} config strings into resolved {@link
@@ -48,10 +59,13 @@ public static List<InetSocketAddress> resolveInetSocketAddressList(
       return result;
     }
 
-    // Collect entries whose host part is a domain name (not an IP literal).
+    // Single pass: parse every entry once; collect domain entries for DNS resolution.
+    LinkedHashMap<String, InetSocketAddress> parsedMap = new LinkedHashMap<>();
     List<String> domainEntries = new ArrayList<>();
     for (String item : ipOrDomainWithPortList) {
-      if (!isIpLiteral(NetUtil.parseInetSocketAddress(item).getHostString())) {
+      InetSocketAddress parsed = NetUtil.parseInetSocketAddress(item);
+      parsedMap.put(item, parsed);
+      if (!isIpLiteral(parsed.getHostString())) {
         domainEntries.add(item);
       }
     }
@@ -69,12 +83,17 @@ public static List<InetSocketAddress> resolveInetSocketAddressList(
       for (int i = 0; i < domainEntries.size(); i++) {
         String entry = domainEntries.get(i);
         try {
-          resolvedDomains.put(entry, futures.get(i).get());
+          resolvedDomains.put(entry,
+              futures.get(i).get(DNS_LOOKUP_TIMEOUT_SECONDS, TimeUnit.SECONDS));
         } catch (InterruptedException e) {
           Thread.currentThread().interrupt();
           logger.warn("DNS lookup interrupted for: {}", entry);
+          break;
         } catch (ExecutionException e) {
           logger.warn("Failed to resolve address, skip: {}", entry);
+        } catch (TimeoutException e) {
+          logger.warn("DNS lookup timed out after {}s, skip: {}", DNS_LOOKUP_TIMEOUT_SECONDS,
+              entry);
         }
       }
       ExecutorServiceManager.shutdownAndAwaitTermination(dnsPool, DNS_POOL_NAME);
@@ -84,8 +103,9 @@ public static List<InetSocketAddress> resolveInetSocketAddressList(
     }
 
     // Build the result list preserving the original config order.
-    for (String item : ipOrDomainWithPortList) {
-      InetSocketAddress parsed = NetUtil.parseInetSocketAddress(item);
+    for (Map.Entry<String, InetSocketAddress> entry : parsedMap.entrySet()) {
+      String item = entry.getKey();
+      InetSocketAddress parsed = entry.getValue();
       InetSocketAddress resolved = isIpLiteral(parsed.getHostString())
           ? parsed
           : resolvedDomains.get(item);
@@ -109,9 +129,9 @@ private static InetSocketAddress resolveInetSocketAddress(String ipOrDomainWithP
     InetSocketAddress parsed = NetUtil.parseInetSocketAddress(ipOrDomainWithPort);
     String host = parsed.getHostString();
     int port = parsed.getPort();
-    InetAddress address = LookUpTxt.lookUpIp(host, true);
+    InetAddress address = dnsLookup.apply(host, true);
     if (address == null) {
-      address = LookUpTxt.lookUpIp(host, false);
+      address = dnsLookup.apply(host, false);
     }
     if (address == null) {
       return null;
@@ -138,9 +158,9 @@ public static InetAddress resolveInetAddress(String ipOrDomain) {
         return null;
       }
     }
-    InetAddress address = LookUpTxt.lookUpIp(ipOrDomain, true);
+    InetAddress address = dnsLookup.apply(ipOrDomain, true);
     if (address == null) {
-      address = LookUpTxt.lookUpIp(ipOrDomain, false);
+      address = dnsLookup.apply(ipOrDomain, false);
     }
     return address;
   }

framework/src/test/java/org/tron/common/backup/BackupManagerTest.java

@@ -1,7 +1,5 @@
 package org.tron.common.backup;
 
-import static org.mockito.Mockito.mockStatic;
-
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.net.InetAddress;
@@ -13,13 +11,13 @@
 import java.util.Set;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.function.BiFunction;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
-import org.mockito.MockedStatic;
 import org.tron.common.TestConstants;
 import org.tron.common.backup.BackupManager.BackupStatusEnum;
 import org.tron.common.backup.message.KeepAliveMessage;
@@ -28,14 +26,15 @@
 import org.tron.common.parameter.CommonParameter;
 import org.tron.common.utils.PublicMethod;
 import org.tron.core.config.args.Args;
-import org.tron.p2p.dns.lookup.LookUpTxt;
+import org.tron.core.config.args.InetUtil;
 
 public class BackupManagerTest {
 
   @Rule
   public TemporaryFolder temporaryFolder = new TemporaryFolder();
   private BackupManager manager;
   private BackupServer backupServer;
+  private BiFunction<String, Boolean, InetAddress> savedLookup;
 
   @Before
   public void setUp() throws Exception {
@@ -44,10 +43,12 @@ public void setUp() throws Exception {
     CommonParameter.getInstance().setBackupPort(PublicMethod.chooseRandomPort());
     manager = new BackupManager();
     backupServer = new BackupServer(manager);
+    savedLookup = InetUtil.dnsLookup;
   }
 
   @After
   public void tearDown() {
+    InetUtil.dnsLookup = savedLookup;
     Args.clearParam();
   }
 
@@ -157,10 +158,9 @@ public void testInitResolvesDomainsToMembers() throws Exception {
     CommonParameter.getInstance().setBackupMembers(
         Collections.singletonList("node.example.com"));
     InetAddress resolved = InetAddress.getByName("1.2.3.4");
-    try (MockedStatic<LookUpTxt> mock = mockStatic(LookUpTxt.class)) {
-      mock.when(() -> LookUpTxt.lookUpIp("node.example.com", true)).thenReturn(resolved);
-      manager.init();
-    }
+    InetUtil.dnsLookup = (host, ipv4) ->
+        ("node.example.com".equals(host) && ipv4) ? resolved : null;
+    manager.init();
     Set<String> members = getField(manager, "members");
     Map<String, String> cache = getField(manager, "domainIpCache");
     Assert.assertTrue(members.contains("1.2.3.4"));
@@ -172,11 +172,8 @@ public void testInitResolvesDomainsToMembers() throws Exception {
   public void testInitSkipsUnresolvableDomain() throws Exception {
     CommonParameter.getInstance().setBackupMembers(
         Collections.singletonList("bad.invalid.domain"));
-    try (MockedStatic<LookUpTxt> mock = mockStatic(LookUpTxt.class)) {
-      mock.when(() -> LookUpTxt.lookUpIp("bad.invalid.domain", true)).thenReturn(null);
-      mock.when(() -> LookUpTxt.lookUpIp("bad.invalid.domain", false)).thenReturn(null);
-      manager.init();
-    }
+    InetUtil.dnsLookup = (host, ipv4) -> null;
+    manager.init();
     Set<String> members = getField(manager, "members");
     Map<String, String> cache = getField(manager, "domainIpCache");
     Assert.assertTrue("unresolvable domain should be silently dropped", members.isEmpty());
@@ -190,10 +187,9 @@ public void testInitSkipsDomainResolvingToLocalIp() throws Exception {
     CommonParameter.getInstance().setBackupMembers(
         Collections.singletonList("self.local.host"));
     InetAddress selfAddr = InetAddress.getByName(localIp);
-    try (MockedStatic<LookUpTxt> mock = mockStatic(LookUpTxt.class)) {
-      mock.when(() -> LookUpTxt.lookUpIp("self.local.host", true)).thenReturn(selfAddr);
-      manager.init();
-    }
+    InetUtil.dnsLookup = (host, ipv4) ->
+        ("self.local.host".equals(host) && ipv4) ? selfAddr : null;
+    manager.init();
     Set<String> members = getField(manager, "members");
     Assert.assertFalse("domain resolving to local IP should not be in members",
         members.contains(localIp));
@@ -210,10 +206,9 @@ public void testRefreshMemberIpsIpChanged() throws Exception {
     cache.put("peer.tron.network", "1.1.1.1");
 
     InetAddress newAddr = InetAddress.getByName("2.2.2.2");
-    try (MockedStatic<LookUpTxt> mock = mockStatic(LookUpTxt.class)) {
-      mock.when(() -> LookUpTxt.lookUpIp("peer.tron.network", true)).thenReturn(newAddr);
-      invokeRefreshMemberIps(manager);
-    }
+    InetUtil.dnsLookup = (host, ipv4) ->
+        ("peer.tron.network".equals(host) && ipv4) ? newAddr : null;
+    invokeRefreshMemberIps(manager);
     Assert.assertFalse(members.contains("1.1.1.1"));
     Assert.assertTrue(members.contains("2.2.2.2"));
     Assert.assertEquals("2.2.2.2", cache.get("peer.tron.network"));
@@ -227,10 +222,9 @@ public void testRefreshMemberIpsIpUnchanged() throws Exception {
     cache.put("peer.tron.network", "1.1.1.1");
 
     InetAddress sameAddr = InetAddress.getByName("1.1.1.1");
-    try (MockedStatic<LookUpTxt> mock = mockStatic(LookUpTxt.class)) {
-      mock.when(() -> LookUpTxt.lookUpIp("peer.tron.network", true)).thenReturn(sameAddr);
-      invokeRefreshMemberIps(manager);
-    }
+    InetUtil.dnsLookup = (host, ipv4) ->
+        ("peer.tron.network".equals(host) && ipv4) ? sameAddr : null;
+    invokeRefreshMemberIps(manager);
     Assert.assertTrue(members.contains("1.1.1.1"));
     Assert.assertEquals("1.1.1.1", cache.get("peer.tron.network"));
   }
@@ -242,11 +236,8 @@ public void testRefreshMemberIpsDnsFailure() throws Exception {
     members.add("1.1.1.1");
     cache.put("peer.tron.network", "1.1.1.1");
 
-    try (MockedStatic<LookUpTxt> mock = mockStatic(LookUpTxt.class)) {
-      mock.when(() -> LookUpTxt.lookUpIp("peer.tron.network", true)).thenReturn(null);
-      mock.when(() -> LookUpTxt.lookUpIp("peer.tron.network", false)).thenReturn(null);
-      invokeRefreshMemberIps(manager);
-    }
+    InetUtil.dnsLookup = (host, ipv4) -> null;
+    invokeRefreshMemberIps(manager);
     Assert.assertTrue("old IP should be kept on DNS failure", members.contains("1.1.1.1"));
     Assert.assertEquals("1.1.1.1", cache.get("peer.tron.network"));
   }

framework/src/test/java/org/tron/core/config/args/ArgsTest.java

@@ -15,8 +15,6 @@
 
 package org.tron.core.config.args;
 
-import static org.mockito.Mockito.mockStatic;
-
 import com.google.common.collect.Lists;
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigFactory;
@@ -28,13 +26,14 @@
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.function.BiFunction;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.After;
 import org.junit.Assert;
+import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
-import org.mockito.MockedStatic;
 import org.tron.common.TestConstants;
 import org.tron.common.args.GenesisBlock;
 import org.tron.common.parameter.CommonParameter;
@@ -44,20 +43,26 @@
 import org.tron.common.utils.PublicMethod;
 import org.tron.core.config.Configuration;
 import org.tron.core.exception.TronError;
-import org.tron.p2p.dns.lookup.LookUpTxt;
 
 @Slf4j
 public class ArgsTest {
 
   private final String privateKey = PublicMethod.getRandomPrivateKey();
   private String address;
   private LocalWitnesses localWitnesses;
+  private BiFunction<String, Boolean, InetAddress> savedLookup;
 
   @Rule
   public ExpectedException thrown = ExpectedException.none();
 
+  @Before
+  public void saveLookup() {
+    savedLookup = InetUtil.dnsLookup;
+  }
+
   @After
   public void destroy() {
+    InetUtil.dnsLookup = savedLookup;
     Args.clearParam();
   }
 
@@ -440,17 +445,14 @@ public void testCheckBackupMembersUnresolvableDomainThrows() throws Exception {
         Arrays.asList("bad.invalid.domain"));
     Method method = Args.class.getDeclaredMethod("checkBackupMembers");
     method.setAccessible(true);
-    try (MockedStatic<LookUpTxt> mock = mockStatic(LookUpTxt.class)) {
-      mock.when(() -> LookUpTxt.lookUpIp("bad.invalid.domain", true)).thenReturn(null);
-      mock.when(() -> LookUpTxt.lookUpIp("bad.invalid.domain", false)).thenReturn(null);
-      try {
-        method.invoke(null);
-        Assert.fail("Expected InvocationTargetException wrapping TronError");
-      } catch (InvocationTargetException ex) {
-        Assert.assertTrue(ex.getCause() instanceof TronError);
-        Assert.assertEquals(TronError.ErrCode.PARAMETER_INIT,
-            ((TronError) ex.getCause()).getErrCode());
-      }
+    InetUtil.dnsLookup = (host, ipv4) -> null;
+    try {
+      method.invoke(null);
+      Assert.fail("Expected InvocationTargetException wrapping TronError");
+    } catch (InvocationTargetException ex) {
+      Assert.assertTrue(ex.getCause() instanceof TronError);
+      Assert.assertEquals(TronError.ErrCode.PARAMETER_INIT,
+          ((TronError) ex.getCause()).getErrCode());
     }
   }
 
@@ -462,10 +464,9 @@ public void testCheckBackupMembersResolvableDomainPasses() throws Exception {
     Method method = Args.class.getDeclaredMethod("checkBackupMembers");
     method.setAccessible(true);
     InetAddress mockAddr = InetAddress.getByName("5.5.5.5");
-    try (MockedStatic<LookUpTxt> mock = mockStatic(LookUpTxt.class)) {
-      mock.when(() -> LookUpTxt.lookUpIp("peer.tron.network", true)).thenReturn(mockAddr);
-      method.invoke(null);
-    }
+    InetUtil.dnsLookup = (host, ipv4) ->
+        ("peer.tron.network".equals(host) && ipv4) ? mockAddr : null;
+    method.invoke(null);
   }
 }