[pull] develop from tronprotocol:develop

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'

common/src/main/java/org/tron/common/parameter/CommonParameter.java

@@ -9,7 +9,6 @@
 import lombok.Setter;
 import org.slf4j.bridge.SLF4JBridgeHandler;
 import org.tron.common.args.GenesisBlock;
-import org.tron.common.config.DbBackupConfig;
 import org.tron.common.cron.CronExpression;
 import org.tron.common.logsfilter.EventPluginConfig;
 import org.tron.common.logsfilter.FilterQuery;
@@ -425,8 +424,6 @@ public class CommonParameter {
   @Setter
   public double rateLimiterDisconnect; // clearParam: 1.0
   @Getter
-  public DbBackupConfig dbBackupConfig;
-  @Getter
   public RocksDbSettings rocksDBCustomSettings;
   @Getter
   public GenesisBlock genesisBlock;

common/src/main/java/org/tron/core/config/args/StorageConfig.java

@@ -25,7 +25,6 @@ public class StorageConfig {
   private TransHistoryConfig transHistory = new TransHistoryConfig();
   private boolean needToUpdateAsset = true;
   private DbSettingsConfig dbSettings = new DbSettingsConfig();
-  private BackupConfig backup = new BackupConfig();
   private BalanceConfig balance = new BalanceConfig();
   private CheckpointConfig checkpoint = new CheckpointConfig();
   private SnapshotConfig snapshot = new SnapshotConfig();
@@ -129,16 +128,6 @@ void postProcess() {
     }
   }
 
-  @Getter
-  @Setter
-  public static class BackupConfig {
-    private boolean enable = false;
-    private String propPath = "prop.properties";
-    private String bak1path = "bak1/database/";
-    private String bak2path = "bak2/database/";
-    private int frequency = 10000;
-  }
-
   @Getter
   @Setter
   public static class BalanceConfig {

common/src/main/resources/reference.conf

@@ -120,15 +120,6 @@ storage {
   # Number of blocks flushed to db in each batch during node syncing.
   snapshot.maxFlushCount = 1
 
-  # Database backup settings (RocksDB only)
-  backup = {
-    enable = false
-    propPath = "prop.properties"
-    bak1path = "bak1/database/"
-    bak2path = "bak2/database/"
-    frequency = 10000
-  }
-
   # Data root setting, for check data, currently only reward-vi is used.
   # merkleRoot = {
   #   reward-vi = 9debcb9924055500aaae98cdee10501c5c39d4daa75800a996f4bdda73dbccd8 // main-net

common/src/test/java/org/tron/core/config/args/StorageConfigTest.java

@@ -28,8 +28,6 @@ public void testDefaults() {
     assertEquals("database", sc.getDb().getDirectory());
     assertEquals("index", sc.getIndex().getDirectory());
     assertTrue(sc.isNeedToUpdateAsset());
-    assertFalse(sc.getBackup().isEnable());
-    assertEquals(10000, sc.getBackup().getFrequency());
     assertEquals(7, sc.getDbSettings().getLevelNumber());
     assertEquals(5000, sc.getDbSettings().getMaxOpenFiles());
   }
@@ -44,8 +42,6 @@ public void testFromConfig() {
     assertEquals("ROCKSDB", sc.getDb().getEngine());
     assertTrue(sc.getDb().isSync());
     assertEquals("mydb", sc.getDb().getDirectory());
-    assertTrue(sc.getBackup().isEnable());
-    assertEquals(5000, sc.getBackup().getFrequency());
     assertEquals(5, sc.getDbSettings().getLevelNumber());
     assertEquals(3000, sc.getDbSettings().getMaxOpenFiles());
   }

framework/build.gradle

@@ -114,7 +114,6 @@ def configureTestTask = { Task t ->
     }
     if (isWindows()) {
         t.exclude '**/ShieldedTransferActuatorTest.class'
-        t.exclude '**/BackupDbUtilTest.class'
         t.exclude '**/ManagerTest.class'
         t.exclude 'org/tron/core/zksnark/**'
         t.exclude 'org/tron/common/runtime/vm/PrecompiledContractsVerifyProofTest.class'
@@ -161,7 +160,6 @@ tasks.register('testWithRocksDb', Test) {
     include 'org/tron/core/config/args/ArgsTest.class'
     include 'org/tron/core/db/DBIteratorTest.class'
     include 'org/tron/core/db/TronDatabaseTest.class'
-    include 'org/tron/core/db/backup/BackupDbUtilTest.class'
     include 'org/tron/core/db2/ChainbaseTest.class'
     exclude '**/LevelDbDataSourceImplTest.class'
 }

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/DefaultConfig.java

@@ -5,14 +5,11 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
 import org.tron.common.utils.StorageUtils;
 import org.tron.core.config.args.Args;
 import org.tron.core.db.RevokingDatabase;
-import org.tron.core.db.backup.BackupRocksDBAspect;
-import org.tron.core.db.backup.NeedBeanCondition;
 import org.tron.core.db2.core.SnapshotManager;
 import org.tron.core.services.interfaceOnPBFT.RpcApiServiceOnPBFT;
 import org.tron.core.services.interfaceOnPBFT.http.PBFT.HttpApiOnPBFTService;
@@ -88,9 +85,4 @@ public HttpApiOnPBFTService getHttpApiOnPBFTService() {
     return null;
   }
 
-  @Bean
-  @Conditional(NeedBeanCondition.class)
-  public BackupRocksDBAspect backupRocksDBAspect() {
-    return new BackupRocksDBAspect();
-  }
 }