diff --git a/common/build.gradle b/common/build.gradle index acde43a1ea9..4309d3dc69a 100644 --- a/common/build.gradle +++ b/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' diff --git a/framework/src/main/java/org/tron/common/backup/BackupManager.java b/framework/src/main/java/org/tron/common/backup/BackupManager.java index a8812a62bb4..a870c183a8d 100644 --- a/framework/src/main/java/org/tron/common/backup/BackupManager.java +++ b/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 members = new ConcurrentSet<>(); + private final Set members = new ConcurrentSet<>(); - private final String esName = "backup-manager"; + private final Map 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 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); + } + } + } } diff --git a/framework/src/main/java/org/tron/core/config/args/Args.java b/framework/src/main/java/org/tron/core/config/args/Args.java index 12cb9b35188..abd625a462a 100644 --- a/framework/src/main/java/org/tron/core/config/args/Args.java +++ b/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 seeds = new ArrayList<>(); - for (String s : cmd.seedNodes) { - seeds.add(NetUtil.parseInetSocketAddress(s)); - } + List seeds = resolveInetSocketAddressList(cmd.seedNodes); PARAMETER.seedNode.setAddressList(seeds); } } @@ -984,8 +982,7 @@ public static void clearParam() { public static List filterInetSocketAddress( List addressList, boolean filter) { List 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"); diff --git a/framework/src/main/java/org/tron/core/config/args/InetUtil.java b/framework/src/main/java/org/tron/core/config/args/InetUtil.java new file mode 100644 index 00000000000..cdde93c73ed --- /dev/null +++ b/framework/src/main/java/org/tron/core/config/args/InetUtil.java @@ -0,0 +1,194 @@ +package org.tron.core.config.args; + +import java.net.InetAddress; +import java.net.InetSocketAddress; +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.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +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; +import org.tron.p2p.utils.NetUtil; + +@Slf4j(topic = "app") +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 dnsLookup = + LookUpTxt::lookUpIp; + + /** + * Converts a list of {@code ipOrDomain:port} config strings into resolved {@link + * InetSocketAddress} objects, preserving the original order. + * + *

IP literals (IPv4 and IPv6) are used as-is. Domain names are resolved via DNS: when there + * are multiple domains, they are resolved in parallel using a dedicated thread pool; a single + * domain is resolved inline. Entries that fail DNS resolution are silently dropped. + * + *

Supported formats: + *

    + *
  • {@code 192.168.100.0:18888} + *
  • {@code [fe80::48ff:fe00:1122]:18888} + *
  • {@code example.com:18888} + *
  • {@code hostname:18888} + *
+ * + * @param ipOrDomainWithPortList list of address strings in {@code ipOrDomain:port} format, + * may mix IP literals and domain names + * @return resolved addresses in the same order as the input, omitting unresolvable entries + */ + public static List resolveInetSocketAddressList( + List ipOrDomainWithPortList) { + List result = new ArrayList<>(); + if (ipOrDomainWithPortList.isEmpty()) { + return result; + } + + // Single pass: parse every entry once; collect domain entries for DNS resolution. + LinkedHashMap parsedMap = new LinkedHashMap<>(); + List domainEntries = new ArrayList<>(); + for (String item : ipOrDomainWithPortList) { + InetSocketAddress parsed = NetUtil.parseInetSocketAddress(item); + parsedMap.put(item, parsed); + if (!isIpLiteral(parsed.getHostString())) { + domainEntries.add(item); + } + } + + // Resolve domain names: spin up a thread pool only when there are multiple domains. + Map resolvedDomains = resolveDomainsInParallel(domainEntries); + + // Build the result list preserving the original config order. + for (Map.Entry entry : parsedMap.entrySet()) { + String item = entry.getKey(); + InetSocketAddress parsed = entry.getValue(); + InetSocketAddress resolved = isIpLiteral(parsed.getHostString()) + ? parsed + : resolvedDomains.get(item); + if (resolved != null) { + result.add(resolved); + } + } + return result; + } + + private static Map resolveDomainsInParallel( + List domainEntries) { + Map resolved = new HashMap<>(); + if (domainEntries.isEmpty()) { + return resolved; + } + + int poolSize = StrictMath.min(domainEntries.size(), DNS_POOL_MAX_SIZE); + ExecutorService dnsPool = ExecutorServiceManager + .newFixedThreadPool(DNS_POOL_NAME, poolSize, true); + + try { + LinkedHashMap> futures = + new LinkedHashMap<>(); + for (String entry : domainEntries) { + futures.put(entry, CompletableFuture.supplyAsync( + () -> resolveInetSocketAddress(entry), dnsPool)); + } + + // Single global deadline for all lookups combined. + try { + CompletableFuture + .allOf(futures.values().toArray(new CompletableFuture[0])) + .get(DNS_LOOKUP_TIMEOUT_SECONDS, TimeUnit.SECONDS); + } catch (TimeoutException e) { + logger.warn("DNS lookup budget {}s exceeded, dropping unresolved entries", + DNS_LOOKUP_TIMEOUT_SECONDS); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + } catch (ExecutionException ignored) { + // per-entry exceptions handled below + } + + // Collect whatever finished; drop pending/failed entries. + for (Map.Entry> e : futures.entrySet()) { + CompletableFuture f = e.getValue(); + if (f.isDone() && !f.isCompletedExceptionally()) { + InetSocketAddress addr = f.getNow(null); + if (addr != null) { + resolved.put(e.getKey(), addr); + } + } else { + logger.warn("DNS unresolved or timed out, skip: {}", e.getKey()); + } + } + } finally { + ExecutorServiceManager.shutdownAndAwaitTermination(dnsPool, DNS_POOL_NAME); + } + logger.debug("DNS look up, src: {}, dst: {}", domainEntries.size(), resolved.size()); + return resolved; + } + + /** + * Resolves a {@code ipOrDomain:port} config string to an {@link InetSocketAddress} via DNS. + * + *

The host is looked up first over IPv4, then over IPv6 as a fallback. Returns {@code null} + * if DNS resolution fails for both address families. + * + * @param ipOrDomainWithPort address string in {@code ipOrDomain:port} format + * @return resolved {@link InetSocketAddress}, or {@code null} if the host cannot be resolved + */ + private static InetSocketAddress resolveInetSocketAddress(String ipOrDomainWithPort) { + InetSocketAddress parsed = NetUtil.parseInetSocketAddress(ipOrDomainWithPort); + String host = parsed.getHostString(); + int port = parsed.getPort(); + InetAddress address = dnsLookup.apply(host, true); + if (address == null) { + address = dnsLookup.apply(host, false); + } + if (address == null) { + return null; + } + logger.info("Resolve {} to {}", host, address.getHostAddress()); + return new InetSocketAddress(address, port); + } + + /** + * Resolves {@code ipOrDomain} to an {@link InetAddress}. + * + *

IP literals are converted directly without a DNS lookup. Domain names are first resolved + * over IPv4, then retried over IPv6 if the first attempt fails. + * + * @param ipOrDomain IPv4/IPv6 literal or a domain name to resolve + * @return the resolved {@link InetAddress}, or {@code null} if resolution fails + */ + public static InetAddress resolveInetAddress(String ipOrDomain) { + // Fast path: already a numeric address — no lookup needed. + if (isIpLiteral(ipOrDomain)) { + try { + return InetAddress.getByName(ipOrDomain); + } catch (UnknownHostException e) { + return null; + } + } + InetAddress address = dnsLookup.apply(ipOrDomain, true); + if (address == null) { + address = dnsLookup.apply(ipOrDomain, false); + } + return address; + } + + private static boolean isIpLiteral(String host) { + return NetUtil.validIpV4(host) || NetUtil.validIpV6(host); + } +} diff --git a/framework/src/test/java/org/tron/common/backup/BackupManagerTest.java b/framework/src/test/java/org/tron/common/backup/BackupManagerTest.java index 71d1bae447b..5ff02fc8cb5 100644 --- a/framework/src/test/java/org/tron/common/backup/BackupManagerTest.java +++ b/framework/src/test/java/org/tron/common/backup/BackupManagerTest.java @@ -1,11 +1,17 @@ package org.tron.common.backup; import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.net.InetAddress; import java.net.InetSocketAddress; import java.util.ArrayList; +import java.util.Collections; import java.util.List; +import java.util.Map; +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; @@ -20,6 +26,7 @@ import org.tron.common.parameter.CommonParameter; import org.tron.common.utils.PublicMethod; import org.tron.core.config.args.Args; +import org.tron.core.config.args.InetUtil; public class BackupManagerTest { @@ -27,6 +34,7 @@ public class BackupManagerTest { public TemporaryFolder temporaryFolder = new TemporaryFolder(); private BackupManager manager; private BackupServer backupServer; + private BiFunction savedLookup; @Before public void setUp() throws Exception { @@ -35,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(); } @@ -140,4 +150,108 @@ public void testSendKeepAliveMessage() throws Exception { Assert.assertEquals(BackupManager.BackupStatusEnum.INIT, manager.getStatus()); } + + // ===== domain-handling tests for init() ===== + + @Test(timeout = 5000) + public void testInitResolvesDomainsToMembers() throws Exception { + CommonParameter.getInstance().setBackupMembers( + Collections.singletonList("node.example.com")); + InetAddress resolved = InetAddress.getByName("1.2.3.4"); + InetUtil.dnsLookup = (host, ipv4) -> + ("node.example.com".equals(host) && ipv4) ? resolved : null; + manager.init(); + Set members = getField(manager, "members"); + Map cache = getField(manager, "domainIpCache"); + Assert.assertTrue(members.contains("1.2.3.4")); + Assert.assertEquals("1.2.3.4", cache.get("node.example.com")); + manager.stop(); + } + + @Test(timeout = 5000) + public void testInitSkipsUnresolvableDomain() throws Exception { + CommonParameter.getInstance().setBackupMembers( + Collections.singletonList("bad.invalid.domain")); + InetUtil.dnsLookup = (host, ipv4) -> null; + manager.init(); + Set members = getField(manager, "members"); + Map cache = getField(manager, "domainIpCache"); + Assert.assertTrue("unresolvable domain should be silently dropped", members.isEmpty()); + Assert.assertTrue(cache.isEmpty()); + manager.stop(); + } + + @Test(timeout = 5000) + public void testInitSkipsDomainResolvingToLocalIp() throws Exception { + String localIp = InetAddress.getLocalHost().getHostAddress(); + CommonParameter.getInstance().setBackupMembers( + Collections.singletonList("self.local.host")); + InetAddress selfAddr = InetAddress.getByName(localIp); + InetUtil.dnsLookup = (host, ipv4) -> + ("self.local.host".equals(host) && ipv4) ? selfAddr : null; + manager.init(); + Set members = getField(manager, "members"); + Assert.assertFalse("domain resolving to local IP should not be in members", + members.contains(localIp)); + manager.stop(); + } + + // ===== refreshMemberIps() tests ===== + + @Test(timeout = 5000) + public void testRefreshMemberIpsIpChanged() throws Exception { + Set members = getField(manager, "members"); + Map cache = getField(manager, "domainIpCache"); + members.add("1.1.1.1"); + cache.put("peer.tron.network", "1.1.1.1"); + + InetAddress newAddr = InetAddress.getByName("2.2.2.2"); + 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")); + } + + @Test(timeout = 5000) + public void testRefreshMemberIpsIpUnchanged() throws Exception { + Set members = getField(manager, "members"); + Map cache = getField(manager, "domainIpCache"); + members.add("1.1.1.1"); + cache.put("peer.tron.network", "1.1.1.1"); + + InetAddress sameAddr = InetAddress.getByName("1.1.1.1"); + 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")); + } + + @Test(timeout = 5000) + public void testRefreshMemberIpsDnsFailure() throws Exception { + Set members = getField(manager, "members"); + Map cache = getField(manager, "domainIpCache"); + members.add("1.1.1.1"); + cache.put("peer.tron.network", "1.1.1.1"); + + 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")); + } + + @SuppressWarnings("unchecked") + private T getField(Object obj, String name) throws Exception { + Field f = obj.getClass().getDeclaredField(name); + f.setAccessible(true); + return (T) f.get(obj); + } + + private void invokeRefreshMemberIps(BackupManager mgr) throws Exception { + Method m = mgr.getClass().getDeclaredMethod("refreshMemberIps"); + m.setAccessible(true); + m.invoke(mgr); + } } diff --git a/framework/src/test/java/org/tron/core/config/args/ArgsTest.java b/framework/src/test/java/org/tron/core/config/args/ArgsTest.java index a67414bd388..bb3d1c4b210 100644 --- a/framework/src/test/java/org/tron/core/config/args/ArgsTest.java +++ b/framework/src/test/java/org/tron/core/config/args/ArgsTest.java @@ -23,11 +23,11 @@ import io.grpc.netty.NettyServerBuilder; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; +import java.net.InetAddress; import java.util.Arrays; import java.util.HashMap; import java.util.Map; import lombok.extern.slf4j.Slf4j; -import org.junit.After; import org.junit.Assert; import org.junit.Rule; import org.junit.Test; @@ -45,17 +45,9 @@ public class ArgsTest { private final String privateKey = PublicMethod.getRandomPrivateKey(); - private String address; - private LocalWitnesses localWitnesses; - @Rule public ExpectedException thrown = ExpectedException.none(); - @After - public void destroy() { - Args.clearParam(); - } - @Test public void get() { Args.setParam(new String[] {"-c", TestConstants.TEST_CONF, "--keystore-factory"}, @@ -65,11 +57,11 @@ public void get() { Args.logConfig(); - localWitnesses = new LocalWitnesses(); + LocalWitnesses localWitnesses = new LocalWitnesses(); localWitnesses.setPrivateKeys(Arrays.asList(privateKey)); localWitnesses.initWitnessAccountAddress(null, true); Args.setLocalWitnesses(localWitnesses); - address = ByteArray.toHexString(Args.getLocalWitnesses() + String address = ByteArray.toHexString(Args.getLocalWitnesses() .getWitnessAccountAddress()); Assert.assertEquals("41", DecodeUtil.addressPreFixString); Assert.assertEquals(TestConstants.TEST_CONF, Args.getConfigFilePath()); @@ -495,7 +487,7 @@ public void testEventConfigEnabledWithInvalidFromBlockLeavesFilterNull() { Assert.assertNull(Args.getInstance().getEventFilter()); Args.clearParam(); } - + @Test public void testAllowShieldedTransactionApiDefault() { Args.setParam(new String[]{}, TestConstants.TEST_CONF); @@ -679,4 +671,46 @@ public void testMaxMessageSizeNonNumeric() { () -> Args.applyConfigParams(config)); Assert.assertTrue(e.getMessage().contains("No number in size-in-bytes value")); } + + // ===== checkBackupMembers() tests ===== + + @Test + public void testCheckBackupMembersWithIpPasses() throws Exception { + Args.setParam(new String[]{}, TestConstants.TEST_CONF); + CommonParameter.getInstance().setBackupMembers(Arrays.asList("1.2.3.4", "10.0.0.1")); + Method method = Args.class.getDeclaredMethod("checkBackupMembers"); + method.setAccessible(true); + method.invoke(null); + } + + @Test(timeout = 5000) + public void testCheckBackupMembersUnresolvableDomainThrows() throws Exception { + Args.setParam(new String[]{}, TestConstants.TEST_CONF); + CommonParameter.getInstance().setBackupMembers( + Arrays.asList("bad.invalid.domain")); + Method method = Args.class.getDeclaredMethod("checkBackupMembers"); + method.setAccessible(true); + 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()); + } + } + + @Test(timeout = 5000) + public void testCheckBackupMembersResolvableDomainPasses() throws Exception { + Args.setParam(new String[]{}, TestConstants.TEST_CONF); + CommonParameter.getInstance().setBackupMembers( + Arrays.asList("peer.tron.network")); + Method method = Args.class.getDeclaredMethod("checkBackupMembers"); + method.setAccessible(true); + InetAddress mockAddr = InetAddress.getByName("5.5.5.5"); + InetUtil.dnsLookup = (host, ipv4) -> + ("peer.tron.network".equals(host) && ipv4) ? mockAddr : null; + method.invoke(null); + } } diff --git a/framework/src/test/java/org/tron/core/config/args/InetUtilTest.java b/framework/src/test/java/org/tron/core/config/args/InetUtilTest.java new file mode 100644 index 00000000000..4611947211c --- /dev/null +++ b/framework/src/test/java/org/tron/core/config/args/InetUtilTest.java @@ -0,0 +1,306 @@ +package org.tron.core.config.args; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; + +import java.net.InetAddress; +import java.net.InetSocketAddress; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.function.BiFunction; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +public class InetUtilTest { + + private BiFunction savedLookup; + + @Before + public void saveLookup() { + savedLookup = InetUtil.dnsLookup; + } + + @After + public void restoreLookup() { + InetUtil.dnsLookup = savedLookup; + } + + // ===== resolveInetSocketAddressList ===== + + @Test + public void testResolveListEmpty() { + List result = + InetUtil.resolveInetSocketAddressList(Collections.emptyList()); + assertTrue(result.isEmpty()); + } + + @Test + public void testResolveListIpv4Literals() { + List input = Arrays.asList("192.168.1.1:18888", "10.0.0.2:8080"); + List result = InetUtil.resolveInetSocketAddressList(input); + assertEquals(2, result.size()); + assertEquals("192.168.1.1", result.get(0).getAddress().getHostAddress()); + assertEquals(18888, result.get(0).getPort()); + assertEquals("10.0.0.2", result.get(1).getAddress().getHostAddress()); + assertEquals(8080, result.get(1).getPort()); + } + + @Test + public void testResolveListIpv4LiteralOrderPreserved() { + List input = Arrays.asList("10.0.0.3:1", "10.0.0.1:2", "10.0.0.2:3"); + List result = InetUtil.resolveInetSocketAddressList(input); + assertEquals(3, result.size()); + assertEquals("10.0.0.3", result.get(0).getAddress().getHostAddress()); + assertEquals("10.0.0.1", result.get(1).getAddress().getHostAddress()); + assertEquals("10.0.0.2", result.get(2).getAddress().getHostAddress()); + } + + @Test + public void testResolveListIpv6Loopback() { + // Bracketed IPv6 loopback — treated as IP literal, no DNS lookup. + List result = InetUtil.resolveInetSocketAddressList( + Collections.singletonList("[::1]:18888")); + assertEquals(1, result.size()); + assertTrue(result.get(0).getAddress().getHostAddress().contains(":")); + assertEquals(18888, result.get(0).getPort()); + } + + @Test + public void testResolveListIpv6FullAddress() { + // Full IPv6 address in bracketed format. + List result = InetUtil.resolveInetSocketAddressList( + Collections.singletonList("[2001:db8::1]:18888")); + assertEquals(1, result.size()); + assertTrue(result.get(0).getAddress().getHostAddress().contains(":")); + assertEquals(18888, result.get(0).getPort()); + } + + @Test + public void testResolveListMixedIpv4AndIpv6Literals() { + // Mix of IPv4 and IPv6 literals — both treated as IP literals, order preserved. + List input = Arrays.asList("192.168.0.1:18888", "[2001:db8::2]:18889"); + List result = InetUtil.resolveInetSocketAddressList(input); + assertEquals(2, result.size()); + assertEquals("192.168.0.1", result.get(0).getAddress().getHostAddress()); + assertEquals(18888, result.get(0).getPort()); + assertTrue(result.get(1).getAddress().getHostAddress().contains(":")); + assertEquals(18889, result.get(1).getPort()); + } + + @Test(timeout = 5000) + public void testResolveListSingleDomainResolved() throws Exception { + InetAddress mockAddr = InetAddress.getByName("1.2.3.4"); + InetUtil.dnsLookup = (host, ipv4) -> + ("node.example.com".equals(host) && ipv4) ? mockAddr : null; + List result = InetUtil.resolveInetSocketAddressList( + Collections.singletonList("node.example.com:18888")); + assertEquals(1, result.size()); + assertEquals("1.2.3.4", result.get(0).getAddress().getHostAddress()); + assertEquals(18888, result.get(0).getPort()); + } + + @Test(timeout = 5000) + public void testResolveListSingleDomainUnresolvable() { + InetUtil.dnsLookup = (host, ipv4) -> null; + List result = InetUtil.resolveInetSocketAddressList( + Collections.singletonList("bad.invalid:18888")); + assertTrue("unresolvable domain should be silently dropped", result.isEmpty()); + } + + @Test(timeout = 5000) + public void testResolveListDomainFirstOrderPreservedBeforeIp() throws Exception { + // Domain in position 0, IP literal in position 1 — verifies the final ordering loop + // places the resolved domain before the IP literal. + InetAddress domainAddr = InetAddress.getByName("3.3.3.3"); + InetUtil.dnsLookup = (host, ipv4) -> + ("first.node".equals(host) && ipv4) ? domainAddr : null; + List result = InetUtil.resolveInetSocketAddressList( + Arrays.asList("first.node:18888", "10.0.0.2:8080")); + assertEquals(2, result.size()); + assertEquals("3.3.3.3", result.get(0).getAddress().getHostAddress()); + assertEquals(18888, result.get(0).getPort()); + assertEquals("10.0.0.2", result.get(1).getAddress().getHostAddress()); + assertEquals(8080, result.get(1).getPort()); + } + + @Test(timeout = 5000) + public void testResolveListUnresolvableDomainFirstIpLiteralKept() { + // Unresolvable domain in position 0 is dropped; trailing IP literal is kept. + InetUtil.dnsLookup = (host, ipv4) -> null; + List result = InetUtil.resolveInetSocketAddressList( + Arrays.asList("bad.invalid:18888", "1.1.1.1:8080")); + assertEquals(1, result.size()); + assertEquals("1.1.1.1", result.get(0).getAddress().getHostAddress()); + assertEquals(8080, result.get(0).getPort()); + } + + @Test(timeout = 5000) + public void testResolveListMixedIpAndDomain() throws Exception { + InetAddress domainAddr = InetAddress.getByName("5.5.5.5"); + InetUtil.dnsLookup = (host, ipv4) -> + ("my.node".equals(host) && ipv4) ? domainAddr : null; + List result = InetUtil.resolveInetSocketAddressList( + Arrays.asList("192.168.0.1:18888", "my.node:8080", "10.0.0.1:9090")); + assertEquals(3, result.size()); + assertEquals("192.168.0.1", result.get(0).getAddress().getHostAddress()); + assertEquals("5.5.5.5", result.get(1).getAddress().getHostAddress()); + assertEquals("10.0.0.1", result.get(2).getAddress().getHostAddress()); + } + + // ===== resolveInetSocketAddressList — parallel path (domainEntries.size() > 1) ===== + + /** Two domain entries, both resolvable: parallel pool is used, original order preserved. */ + @Test(timeout = 5000) + public void testResolveListTwoDomainsParallelBothResolved() throws Exception { + InetAddress addr1 = InetAddress.getByName("1.1.1.1"); + InetAddress addr2 = InetAddress.getByName("2.2.2.2"); + InetUtil.dnsLookup = (host, ipv4) -> { + if (!ipv4) { + return null; + } + if ("node-a.example.com".equals(host)) { + return addr1; + } + if ("node-b.example.com".equals(host)) { + return addr2; + } + return null; + }; + List result = InetUtil.resolveInetSocketAddressList( + Arrays.asList("node-a.example.com:18888", "node-b.example.com:18889")); + assertEquals(2, result.size()); + assertEquals("1.1.1.1", result.get(0).getAddress().getHostAddress()); + assertEquals(18888, result.get(0).getPort()); + assertEquals("2.2.2.2", result.get(1).getAddress().getHostAddress()); + assertEquals(18889, result.get(1).getPort()); + } + + /** Two domain entries, one fails: the failing entry is dropped, the other is kept. */ + @Test(timeout = 5000) + public void testResolveListTwoDomainsParallelOneFails() throws Exception { + InetAddress goodAddr = InetAddress.getByName("3.3.3.3"); + InetUtil.dnsLookup = (host, ipv4) -> + ("good.node".equals(host) && ipv4) ? goodAddr : null; + List result = InetUtil.resolveInetSocketAddressList( + Arrays.asList("good.node:18888", "bad.invalid:18889")); + assertEquals(1, result.size()); + assertEquals("3.3.3.3", result.get(0).getAddress().getHostAddress()); + assertEquals(18888, result.get(0).getPort()); + } + + /** + * Two domain entries interleaved with IP literals: parallel pool resolves the domains + * while IP literals pass through, and original config order is preserved in the result. + */ + @Test(timeout = 5000) + public void testResolveListTwoDomainsParallelOrderWithIpsPreserved() throws Exception { + InetAddress addr1 = InetAddress.getByName("4.4.4.4"); + InetAddress addr2 = InetAddress.getByName("5.5.5.5"); + InetUtil.dnsLookup = (host, ipv4) -> { + if (!ipv4) { + return null; + } + if ("alpha.node".equals(host)) { + return addr1; + } + if ("beta.node".equals(host)) { + return addr2; + } + return null; + }; + List result = InetUtil.resolveInetSocketAddressList( + Arrays.asList("10.0.0.1:8001", "alpha.node:8002", "10.0.0.2:8003", "beta.node:8004")); + assertEquals(4, result.size()); + assertEquals("10.0.0.1", result.get(0).getAddress().getHostAddress()); + assertEquals("4.4.4.4", result.get(1).getAddress().getHostAddress()); + assertEquals("10.0.0.2", result.get(2).getAddress().getHostAddress()); + assertEquals("5.5.5.5", result.get(3).getAddress().getHostAddress()); + } + + /** + * One domain times out (lookup hangs beyond DNS_LOOKUP_TIMEOUT_SECONDS), the other resolves: + * the timed-out entry is dropped, the successful entry is kept, and the test itself completes + * well within the per-lookup budget because {@code dnsLookup} returns immediately. + */ + @Test(timeout = 5000) + public void testResolveListTwoDomainsParallelOneTimesOut() throws Exception { + InetAddress goodAddr = InetAddress.getByName("6.6.6.6"); + InetUtil.dnsLookup = (host, ipv4) -> { + if ("slow.node".equals(host)) { + // Simulate a hang that would exceed the 10-second per-lookup timeout. + // In this test the lookup returns immediately with null so the test itself is fast; + // the TimeoutException path is exercised when future.get() times out in production. + // Here we verify the structural handling: a null result drops the entry. + return null; + } + return ("fast.node".equals(host) && ipv4) ? goodAddr : null; + }; + List result = InetUtil.resolveInetSocketAddressList( + Arrays.asList("slow.node:18888", "fast.node:18889")); + assertEquals("timed-out/unresolvable domain should be dropped", 1, result.size()); + assertEquals("6.6.6.6", result.get(0).getAddress().getHostAddress()); + assertEquals(18889, result.get(0).getPort()); + } + + // ===== resolveInetAddress ===== + + @Test + public void testResolveInetAddressIpv4Literal() { + InetAddress result = InetUtil.resolveInetAddress("127.0.0.1"); + assertNotNull(result); + assertEquals("127.0.0.1", result.getHostAddress()); + } + + @Test + public void testResolveInetAddressIpv6Loopback() { + // ::1 is an IPv6 literal — resolved without DNS. + InetAddress result = InetUtil.resolveInetAddress("::1"); + assertNotNull(result); + assertTrue(result.getHostAddress().contains(":")); + } + + @Test + public void testResolveInetAddressIpv6FullLiteral() { + // Full-form IPv6 address — treated as IP literal, no DNS lookup. + InetAddress result = InetUtil.resolveInetAddress("2001:db8::1"); + assertNotNull(result); + assertTrue(result.getHostAddress().contains(":")); + } + + @Test + public void testResolveInetAddressIpv6CompressedLiteral() { + // Compressed IPv6 with multiple groups — still a literal, no DNS. + InetAddress result = InetUtil.resolveInetAddress("fe80::1"); + assertNotNull(result); + assertTrue(result.getHostAddress().contains(":")); + } + + @Test(timeout = 5000) + public void testResolveInetAddressDomainResolved() throws Exception { + InetAddress mockAddr = InetAddress.getByName("3.3.3.3"); + InetUtil.dnsLookup = (host, ipv4) -> + ("peer.tron.network".equals(host) && ipv4) ? mockAddr : null; + InetAddress result = InetUtil.resolveInetAddress("peer.tron.network"); + assertNotNull(result); + assertEquals("3.3.3.3", result.getHostAddress()); + } + + @Test(timeout = 5000) + public void testResolveInetAddressDomainIpv4FallsBackToIpv6() throws Exception { + InetAddress ipv6Addr = InetAddress.getByName("::1"); + InetUtil.dnsLookup = (host, ipv4) -> ipv4 ? null : ipv6Addr; + InetAddress result = InetUtil.resolveInetAddress("ipv6only.host"); + assertNotNull(result); + } + + @Test(timeout = 5000) + public void testResolveInetAddressUnresolvableReturnsNull() { + InetUtil.dnsLookup = (host, ipv4) -> null; + InetAddress result = InetUtil.resolveInetAddress("bad.invalid"); + assertNull(result); + } +} diff --git a/gradle/verification-metadata.xml b/gradle/verification-metadata.xml index 11c585cab6c..8c55e3b52b0 100644 --- a/gradle/verification-metadata.xml +++ b/gradle/verification-metadata.xml @@ -1789,6 +1789,9 @@ + + + @@ -1874,12 +1877,12 @@ - - - + + + - - + +