fix(db): fix storage config properties (tronprotocol#6806)

Author: 317787106

common/src/main/java/org/tron/core/config/README.md

@@ -28,10 +28,7 @@ storage {
     {
       name = "account",
       path = "/path/to/accout",   // relative or absolute path
-      createIfMissing = true,
-      paranoidChecks = true,
-      verifyChecksums = true,
-      compressionType = 1,        // 0 - no compression,  1 - compressed with snappy
+      # following are only used for LevelDB
       blockSize = 4096,           // 4  KB =         4 * 1024 B
       writeBufferSize = 10485760, // 10 MB = 10 * 1024 * 1024 B
       cacheSize = 10485760,       // 10 MB = 10 * 1024 * 1024 B
@@ -43,7 +40,7 @@ storage {
 
 ```
 
-As shown in the example above, the `accout` database will be stored in the path of `/path/to/accout/database` while the index be stored in `/path/to/accout/index`. And, the example also shows our default value of LevelDB options(Start from `createIfMissing` and end at `maxOpenFiles`). Please refer to the docs of [LevelDB](https://github.com/google/leveldb/blob/master/doc/index.md#performance) to figure out the details of these options.
+As shown in the example above, the `accout` database will be stored in the path of `/path/to/accout/database` while the index be stored in `/path/to/accout/index`. And, the example also shows our default value of LevelDB options(Start from `blockSize` and end at `maxOpenFiles`). Please refer to the docs of [LevelDB](https://github.com/google/leveldb/blob/master/doc/index.md#performance) to figure out the details of these options.
 
 ## gRPC
 

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

@@ -25,7 +25,6 @@
 import lombok.Getter;
 import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
-import org.iq80.leveldb.CompressionType;
 import org.iq80.leveldb.Options;
 import org.tron.common.cache.CacheStrategies;
 import org.tron.common.cache.CacheType;
@@ -170,26 +169,13 @@ private Property createPropertyFromBean(StorageConfig.PropertyConfig pc) {
     }
 
     Options dbOptions = newDefaultDbOptions(property.getName());
-    applyPropertyOptions(pc, dbOptions);
+    // PropertyConfig is-a DbOptionOverride: apply only user-specified (non-null) overrides
+    // so unset fields keep the per-tier defaults already applied by newDefaultDbOptions.
+    applyDbOptionOverride(pc, dbOptions);
     property.setDbOptions(dbOptions);
     return property;
   }
 
-  /**
-   * Apply LevelDB options from PropertyConfig bean values.
-   */
-  private static void applyPropertyOptions(StorageConfig.PropertyConfig pc, Options dbOptions) {
-    dbOptions.createIfMissing(pc.isCreateIfMissing());
-    dbOptions.paranoidChecks(pc.isParanoidChecks());
-    dbOptions.verifyChecksums(pc.isVerifyChecksums());
-    dbOptions.compressionType(
-        CompressionType.getCompressionTypeByPersistentId(pc.getCompressionType()));
-    dbOptions.blockSize(pc.getBlockSize());
-    dbOptions.writeBufferSize(pc.getWriteBufferSize());
-    dbOptions.cacheSize(pc.getCacheSize());
-    dbOptions.maxOpenFiles(pc.getMaxOpenFiles());
-  }
-
   /**
    * Set propertyMap from StorageConfig bean list. No Config parameter needed.
    */
@@ -247,19 +233,6 @@ public Options newDefaultDbOptions(String name) {
   // Apply only user-specified overrides (non-null fields) to LevelDB Options.
   private static void applyDbOptionOverride(
       StorageConfig.DbOptionOverride o, Options dbOptions) {
-    if (o.getCreateIfMissing() != null) {
-      dbOptions.createIfMissing(o.getCreateIfMissing());
-    }
-    if (o.getParanoidChecks() != null) {
-      dbOptions.paranoidChecks(o.getParanoidChecks());
-    }
-    if (o.getVerifyChecksums() != null) {
-      dbOptions.verifyChecksums(o.getVerifyChecksums());
-    }
-    if (o.getCompressionType() != null) {
-      dbOptions.compressionType(
-          CompressionType.getCompressionTypeByPersistentId(o.getCompressionType()));
-    }
     if (o.getBlockSize() != null) {
       dbOptions.blockSize(o.getBlockSize());
     }

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

@@ -28,6 +28,8 @@ public class StorageConfig {
   private CheckpointConfig checkpoint = new CheckpointConfig();
   private SnapshotConfig snapshot = new SnapshotConfig();
   private TxCacheConfig txCache = new TxCacheConfig();
+  // ConfigBeanFactory requires all bean fields present per item, so we parse manually.
+  @Setter(lombok.AccessLevel.NONE)
   private List<PropertyConfig> properties = new ArrayList<>();
 
   // merkleRoot is a nested object (e.g. { reward-vi = "hash..." }) not a string.
@@ -54,6 +56,7 @@ public class StorageConfig {
   @Getter
   @Setter
   public static class DbConfig {
+
     private String engine = "LEVELDB";
     private boolean sync = false;
     private String directory = "database";
@@ -62,6 +65,7 @@ public static class DbConfig {
   @Getter
   @Setter
   public static class TransHistoryConfig {
+
     // "switch" is a reserved Java keyword; ConfigBeanFactory calls setSwitch() which works fine
     @Getter(lombok.AccessLevel.NONE)
     @Setter(lombok.AccessLevel.NONE)
@@ -79,6 +83,7 @@ public void setSwitch(String v) {
   @Getter
   @Setter
   public static class DbSettingsConfig {
+
     private int levelNumber = 7;
     private int compactThreads = 0; // 0 = auto: max(availableProcessors, 1)
     private int blocksize = 16;
@@ -100,25 +105,29 @@ void postProcess() {
   @Getter
   @Setter
   public static class BalanceConfig {
+
     private HistoryConfig history = new HistoryConfig();
 
     @Getter
     @Setter
     public static class HistoryConfig {
+
       private boolean lookup = false;
     }
   }
 
   @Getter
   @Setter
   public static class CheckpointConfig {
+
     private int version = 1;
     private boolean sync = true;
   }
 
   @Getter
   @Setter
   public static class SnapshotConfig {
+
     private int maxFlushCount = 1;
 
     // Reject out-of-range values. Mirrors develop Storage.getSnapshotMaxFlushCountFromConfig.
@@ -135,6 +144,7 @@ void postProcess() {
   @Getter
   @Setter
   public static class TxCacheConfig {
+
     private int estimatedTransactions = 1000;
     private boolean initOptimization = false;
 
@@ -148,19 +158,14 @@ void postProcess() {
     }
   }
 
+  // A named database entry: name/path plus the optional LevelDB option overrides
+  // inherited from DbOptionOverride (boxed types, null = "inherit per-tier defaults").
   @Getter
   @Setter
-  public static class PropertyConfig {
+  public static class PropertyConfig extends DbOptionOverride {
+
     private String name = "";
     private String path = "";
-    private boolean createIfMissing = true;
-    private boolean paranoidChecks = true;
-    private boolean verifyChecksums = true;
-    private int compressionType = 1;
-    private int blockSize = 4096;
-    private int writeBufferSize = 10485760;
-    private long cacheSize = 10485760;
-    private int maxOpenFiles = 100;
   }
 
   // Defaults come from reference.conf (loaded globally via Configuration.java)
@@ -170,6 +175,7 @@ public static StorageConfig fromConfig(Config config) {
 
     StorageConfig sc = ConfigBeanFactory.create(section, StorageConfig.class);
     sc.rawStorageConfig = section;
+    sc.properties = readProperties(section);
 
     // Read optional LevelDB option overrides (default, defaultM, defaultL).
     sc.defaultDbOption = readDbOption(section, "default");
@@ -187,45 +193,17 @@ public static StorageConfig fromConfig(Config config) {
   @Getter
   @Setter
   public static class DbOptionOverride {
-    private Boolean createIfMissing;
-    private Boolean paranoidChecks;
-    private Boolean verifyChecksums;
-    private Integer compressionType;
+
     private Integer blockSize;
     private Integer writeBufferSize;
     private Long cacheSize;
     private Integer maxOpenFiles;
   }
 
-  // Read optional LevelDB option override (default/defaultM/defaultL).
-  // Not bean-bound: users may only set a subset of keys (e.g. just maxOpenFiles),
-  // ConfigBeanFactory requires all fields present so partial overrides would fail.
-  private static DbOptionOverride readDbOption(Config section, String key) {
-    if (!section.hasPath(key)) {
-      return null;
-    }
-    ConfigObject conf = section.getObject(key);
-    DbOptionOverride o = new DbOptionOverride();
-    if (conf.containsKey("createIfMissing")) {
-      o.setCreateIfMissing(
-          Boolean.parseBoolean(conf.get("createIfMissing").unwrapped().toString()));
-    }
-    if (conf.containsKey("paranoidChecks")) {
-      o.setParanoidChecks(
-          Boolean.parseBoolean(conf.get("paranoidChecks").unwrapped().toString()));
-    }
-    if (conf.containsKey("verifyChecksums")) {
-      o.setVerifyChecksums(
-          Boolean.parseBoolean(conf.get("verifyChecksums").unwrapped().toString()));
-    }
-    if (conf.containsKey("compressionType")) {
-      String param = conf.get("compressionType").unwrapped().toString();
-      try {
-        o.setCompressionType(Integer.parseInt(param));
-      } catch (NumberFormatException e) {
-        throwIllegalArgumentException("compressionType", Integer.class, param);
-      }
-    }
+  // Shared LevelDB option parser used by both readDbOption and readProperties.
+  // Fills the given target (boxed fields, null means "not specified by user") so the
+  // same parser can populate a plain DbOptionOverride or a PropertyConfig (which extends it).
+  private static void readLevelDbOptions(ConfigObject conf, DbOptionOverride o) {
     if (conf.containsKey("blockSize")) {
       String param = conf.get("blockSize").unwrapped().toString();
       try {
@@ -258,9 +236,43 @@ private static DbOptionOverride readDbOption(Config section, String key) {
         throwIllegalArgumentException("maxOpenFiles", Integer.class, param);
       }
     }
+  }
+
+  // Read optional LevelDB option override for default/defaultM/defaultL keys.
+  private static DbOptionOverride readDbOption(Config section, String key) {
+    if (!section.hasPath(key)) {
+      return null;
+    }
+    DbOptionOverride o = new DbOptionOverride();
+    readLevelDbOptions(section.getObject(key), o);
     return o;
   }
 
+  // Parse storage.properties list manually: ConfigBeanFactory requires every bean field to be
+  // present in each list item, but name+path-only entries (all LevelDB opts commented out) are
+  // valid — missing fields fall back to PropertyConfig Java defaults.
+  private static List<PropertyConfig> readProperties(Config section) {
+    if (!section.hasPath("properties")) {
+      return new ArrayList<>();
+    }
+    List<? extends ConfigObject> items = section.getObjectList("properties");
+    List<PropertyConfig> result = new ArrayList<>(items.size());
+    for (ConfigObject obj : items) {
+      PropertyConfig p = new PropertyConfig();
+      if (obj.containsKey("name")) {
+        p.setName(obj.get("name").unwrapped().toString());
+      }
+      if (obj.containsKey("path")) {
+        p.setPath(obj.get("path").unwrapped().toString());
+      }
+      // Boxed nullable fields: unset options stay null so they inherit the per-tier
+      // defaults applied by newDefaultDbOptions instead of resetting them.
+      readLevelDbOptions(obj, p);
+      result.add(p);
+    }
+    return result;
+  }
+
   private static void throwIllegalArgumentException(String param, Class<?> type, String actual) {
     throw new IllegalArgumentException(
         String.format("[storage.properties] %s must be %s type, actual: %s.",

common/src/main/resources/reference.conf

@@ -44,49 +44,68 @@ net {
 }
 
 storage {
-  # Database engine: "LEVELDB" or "ROCKSDB" (ARM only supports ROCKSDB)
+  # Database engine: "LEVELDB" or "ROCKSDB" (ARM only supports ROCKSDB), case-insensitive
   db.engine = "LEVELDB"
+
+  # Controls the database write strategy.
+  # true  - Synchronous writes. Higher durability, lower performance.
+  # false - Asynchronous writes. Higher performance, but recent writes may be
+  #         lost if the machine crashes before data is flushed to disk.
+  # Asynchronous writes can significantly improve FullNode block sync performance.
   db.sync = false
+
   db.directory = "database"
 
   # Whether to write transaction result in transactionRetStore
   transHistory.switch = "on"
 
-  # Per-database LevelDB option overrides. Default: empty (all databases use global defaults).
-  # setting can improve leveldb performance .... start, deprecated for arm
-  # node: if this will increase process fds, you may check your ulimit if 'too many open files' error occurs
-  # see https://github.com/tronprotocol/tips/blob/master/tip-343.md for detail
-  # if you find block sync has lower performance, you can try this settings
+  # Per-database LevelDB option overrides.Default: empty. All databases use global LevelDB settings.
+  # These settings can be tuned to improve database performance during block synchronization.
+  # Note:
+  # - Increasing `maxOpenFiles` may significantly increase file descriptor usage.
+  # - If "Too many open files" errors occur, check the system `ulimit` configuration.
+  # - See TIP-343 for tuning recommendations:
+  #   https://github.com/tronprotocol/tips/blob/master/tip-343.md
+  # The following presets are provided as default. If block synchronization
+  # performance is unsatisfactory, consider adjusting the settings accordingly.
+  #
+  # Global default settings:
   # default = {
+  #   blockSize = 4096,           // 4 KB
+  #   writeBufferSize = 16777216, // 16 MB
+  #   cacheSize = 33554432,       // 32 MB
   #   maxOpenFiles = 100
   # }
+  # Default for bulk-read databases: code, contract
   # defaultM = {
-  #   maxOpenFiles = 500
+  #   blockSize = 4096,           // 4 KB
+  #   writeBufferSize = 67108864, // 64 MB
+  #   cacheSize = 33554432,       // 32 MB
+  #   maxOpenFiles = 100          // recommend 500 for production
   # }
+  # Default for frequently accessed databases: account, delegation, storage-row
   # defaultL = {
-  #   maxOpenFiles = 1000
+  #   blockSize = 4096,           // 4 KB
+  #   writeBufferSize = 67108864, // 64 MB
+  #   cacheSize = 33554432,       // 32 MB
+  #   maxOpenFiles = 100          // recommend 1000 for production
   # }
-  # setting can improve leveldb performance .... end, deprecated for arm
 
   # Per-database storage configuration overrides. Otherwise databases use global defaults and store
   # data in "output-directory" or the directory specified by the "-d" / "--output-directory" option.
   # Attention: name is a required field that must be set!
   # The name and path properties take effect for both LevelDB and RocksDB storage engines,
-  # while additional properties (createIfMissing, paranoidChecks, compressionType, etc.)
+  # while additional 4 properties (blockSize, writeBufferSize, cacheSize, maxOpenFiles)
   # only take effect when using LevelDB.
   # Example:
   # properties = [
   #   {
   #     name = "account",
   #     path = "storage_directory_test",
-  #     createIfMissing = true,     // deprecated for arm start
-  #     paranoidChecks = true,
-  #     verifyChecksums = true,
-  #     compressionType = 1,        // compressed with snappy
   #     blockSize = 4096,           // 4  KB =         4 * 1024 B
   #     writeBufferSize = 10485760, // 10 MB = 10 * 1024 * 1024 B
   #     cacheSize = 10485760,       // 10 MB = 10 * 1024 * 1024 B
-  #     maxOpenFiles = 100          // deprecated for arm end
+  #     maxOpenFiles = 100
   #   },
   # ]
   properties = []