refactor(config): move LevelDB option reading from Storage to StorageConfig

Move default/defaultM/defaultL LevelDB option reading into StorageConfig,
so Storage no longer touches Config directly.

- Add DbOptionOverride with nullable boxed types for partial overrides
- Fix cacheSize type from int to long to match LevelDB Options API
- Remove dead externalIp(Config) bridge method
- Remove setIfNeeded and Config field from Storage

Author: vividctrlalt

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

@@ -18,7 +18,6 @@
 import com.google.common.collect.Maps;
 import com.google.protobuf.ByteString;
 import com.typesafe.config.Config;
-import com.typesafe.config.ConfigObject;
 import java.io.File;
 import java.util.List;
 import java.util.Map;
@@ -47,7 +46,11 @@
 public class Storage {
 
   private static final String DEFAULT_INDEX_SWITCH = "on";
-  private Config storage;
+
+  // Optional per-tier LevelDB option overrides, read from StorageConfig bean
+  private StorageConfig.DbOptionOverride defaultDbOption;
+  private StorageConfig.DbOptionOverride defaultMDbOption;
+  private StorageConfig.DbOptionOverride defaultLDbOption;
 
   /**
    * Database storage directory: /path/to/{dbDirectory}
@@ -271,42 +274,6 @@ private static void applyPropertyOptions(StorageConfig.PropertyConfig pc, Option
     dbOptions.maxOpenFiles(pc.getMaxOpenFiles());
   }
 
-  // Keep old createProperty and setIfNeeded for setDefaultDbOptions which still
-  // uses ConfigObject for dynamic default/defaultM/defaultL overrides
-  private static void setIfNeeded(ConfigObject conf, Options dbOptions) {
-    if (conf.containsKey("createIfMissing")) {
-      dbOptions.createIfMissing(
-          Boolean.parseBoolean(conf.get("createIfMissing").unwrapped().toString()));
-    }
-    if (conf.containsKey("paranoidChecks")) {
-      dbOptions.paranoidChecks(
-          Boolean.parseBoolean(conf.get("paranoidChecks").unwrapped().toString()));
-    }
-    if (conf.containsKey("verifyChecksums")) {
-      dbOptions.verifyChecksums(
-          Boolean.parseBoolean(conf.get("verifyChecksums").unwrapped().toString()));
-    }
-    if (conf.containsKey("compressionType")) {
-      dbOptions.compressionType(CompressionType.getCompressionTypeByPersistentId(
-          Integer.parseInt(conf.get("compressionType").unwrapped().toString())));
-    }
-    if (conf.containsKey("blockSize")) {
-      dbOptions.blockSize(
-          Integer.parseInt(conf.get("blockSize").unwrapped().toString()));
-    }
-    if (conf.containsKey("writeBufferSize")) {
-      dbOptions.writeBufferSize(
-          Integer.parseInt(conf.get("writeBufferSize").unwrapped().toString()));
-    }
-    if (conf.containsKey("cacheSize")) {
-      dbOptions.cacheSize(
-          Long.parseLong(conf.get("cacheSize").unwrapped().toString()));
-    }
-    if (conf.containsKey("maxOpenFiles")) {
-      dbOptions.maxOpenFiles(
-          Integer.parseInt(conf.get("maxOpenFiles").unwrapped().toString()));
-    }
-  }
 
   /**
    * Set propertyMap of Storage object from Config via StorageConfig bean.
@@ -339,28 +306,59 @@ public void deleteAllStoragePaths() {
   }
 
   /**
-   * Accepts raw storage Config sub-tree because default/defaultM/defaultL are
-   * optional nested objects with dynamic LevelDB Option fields that
-   * ConfigBeanFactory cannot bind to fixed bean fields.
+   * Initialize default LevelDB options and store optional per-tier overrides
+   * from StorageConfig bean (no raw Config needed).
    */
-  public void setDefaultDbOptions(final Config storageSection) {
+  public void setDefaultDbOptions(StorageConfig sc) {
     this.defaultDbOptions = DbOptionalsUtils.createDefaultDbOptions();
-    storage = storageSection;
+    this.defaultDbOption = sc.getDefaultDbOption();
+    this.defaultMDbOption = sc.getDefaultMDbOption();
+    this.defaultLDbOption = sc.getDefaultLDbOption();
   }
 
   public Options newDefaultDbOptions(String name) {
     Options options = DbOptionalsUtils.newDefaultDbOptions(name, this.defaultDbOptions);
 
-    if (storage.hasPath("default")) {
-      setIfNeeded(storage.getObject("default"), options);
+    if (defaultDbOption != null) {
+      applyDbOptionOverride(defaultDbOption, options);
     }
-    if (storage.hasPath("defaultM") && DbOptionalsUtils.DB_M.contains(name)) {
-      setIfNeeded(storage.getObject("defaultM"), options);
+    if (defaultMDbOption != null && DbOptionalsUtils.DB_M.contains(name)) {
+      applyDbOptionOverride(defaultMDbOption, options);
     }
-    if (storage.hasPath("defaultL") && DbOptionalsUtils.DB_L.contains(name)) {
-      setIfNeeded(storage.getObject("defaultL"), options);
+    if (defaultLDbOption != null && DbOptionalsUtils.DB_L.contains(name)) {
+      applyDbOptionOverride(defaultLDbOption, options);
     }
 
     return options;
   }
+
+  // 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());
+    }
+    if (o.getWriteBufferSize() != null) {
+      dbOptions.writeBufferSize(o.getWriteBufferSize());
+    }
+    if (o.getCacheSize() != null) {
+      dbOptions.cacheSize(o.getCacheSize());
+    }
+    if (o.getMaxOpenFiles() != null) {
+      dbOptions.maxOpenFiles(o.getMaxOpenFiles());
+    }
+  }
 }

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

@@ -2,6 +2,7 @@
 
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigBeanFactory;
+import com.typesafe.config.ConfigObject;
 import java.util.ArrayList;
 import java.util.List;
 import lombok.Getter;
@@ -36,9 +37,8 @@ public class StorageConfig {
   @Setter(lombok.AccessLevel.NONE)
   private Object merkleRoot;
 
-  // LevelDB per-database option overrides (default, defaultM, defaultL)
-  // These are not bean-bound because they are optional nested objects with
-  // dynamic usage. Read manually in fromConfig().
+  // Raw storage config sub-tree, kept for setCacheStrategies/setDbRoots which
+  // have dynamic keys that ConfigBeanFactory cannot bind.
   @Getter(lombok.AccessLevel.NONE)
   @Setter(lombok.AccessLevel.NONE)
   private Config rawStorageConfig;
@@ -47,6 +47,22 @@ public Config getRawStorageConfig() {
     return rawStorageConfig;
   }
 
+  // LevelDB per-database option overrides (default, defaultM, defaultL).
+  // Excluded from auto-binding: optional partial overrides that ConfigBeanFactory cannot handle.
+  @Getter(lombok.AccessLevel.NONE)
+  @Setter(lombok.AccessLevel.NONE)
+  private DbOptionOverride defaultDbOption;
+  @Getter(lombok.AccessLevel.NONE)
+  @Setter(lombok.AccessLevel.NONE)
+  private DbOptionOverride defaultMDbOption;
+  @Getter(lombok.AccessLevel.NONE)
+  @Setter(lombok.AccessLevel.NONE)
+  private DbOptionOverride defaultLDbOption;
+
+  public DbOptionOverride getDefaultDbOption() { return defaultDbOption; }
+  public DbOptionOverride getDefaultMDbOption() { return defaultMDbOption; }
+  public DbOptionOverride getDefaultLDbOption() { return defaultLDbOption; }
+
   @Getter
   @Setter
   public static class DbConfig {
@@ -158,7 +174,7 @@ public static class PropertyConfig {
     private int compressionType = 1;
     private int blockSize = 4096;
     private int writeBufferSize = 10485760;
-    private int cacheSize = 10485760;
+    private long cacheSize = 10485760;
     private int maxOpenFiles = 100;
   }
 
@@ -168,8 +184,71 @@ public static StorageConfig fromConfig(Config config) {
     Config section = config.getConfig("storage");
 
     StorageConfig sc = ConfigBeanFactory.create(section, StorageConfig.class);
-    // Keep raw config for legacy LevelDB per-database option overrides (default, defaultM, defaultL)
     sc.rawStorageConfig = section;
+
+    // Read optional LevelDB option overrides (default, defaultM, defaultL).
+    sc.defaultDbOption = readDbOption(section, "default");
+    sc.defaultMDbOption = readDbOption(section, "defaultM");
+    sc.defaultLDbOption = readDbOption(section, "defaultL");
     return sc;
   }
+
+  // Partial LevelDB option override for default/defaultM/defaultL.
+  // Uses boxed types so null means "not set by user, keep existing value".
+  @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")) {
+      o.setCompressionType(
+          Integer.parseInt(conf.get("compressionType").unwrapped().toString()));
+    }
+    if (conf.containsKey("blockSize")) {
+      o.setBlockSize(
+          Integer.parseInt(conf.get("blockSize").unwrapped().toString()));
+    }
+    if (conf.containsKey("writeBufferSize")) {
+      o.setWriteBufferSize(
+          Integer.parseInt(conf.get("writeBufferSize").unwrapped().toString()));
+    }
+    if (conf.containsKey("cacheSize")) {
+      o.setCacheSize(
+          Long.parseLong(conf.get("cacheSize").unwrapped().toString()));
+    }
+    if (conf.containsKey("maxOpenFiles")) {
+      o.setMaxOpenFiles(
+          Integer.parseInt(conf.get("maxOpenFiles").unwrapped().toString()));
+    }
+    return o;
+  }
 }

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

@@ -274,7 +274,7 @@ private static void applyStorageConfig(StorageConfig sc) {
     // Dynamic nested objects use StorageConfig's raw storage sub-tree
     // setDefaultDbOptions must be called before setPropertyMapFromBean because
     // createPropertyFromBean calls newDefaultDbOptions which needs defaultDbOptions initialized
-    PARAMETER.storage.setDefaultDbOptions(sc.getRawStorageConfig());
+    PARAMETER.storage.setDefaultDbOptions(sc);
     PARAMETER.storage.setPropertyMapFromBean(sc.getProperties());
     PARAMETER.storage.setCacheStrategies(sc.getRawStorageConfig());
     PARAMETER.storage.setDbRoots(sc.getRawStorageConfig());
@@ -1157,11 +1157,6 @@ private static void logEmptyError(String arg) {
   // createTriggerConfig removed — logic moved to applyEventConfig()
   // getEventFilter removed — logic moved to applyEventConfig()
 
-  // Kept for backward compatibility — test code calls via reflection with Config param
-  private static void externalIp(final com.typesafe.config.Config config) {
-    externalIp(NodeConfig.fromConfig(config));
-  }
-
   private static void externalIp(NodeConfig nodeConfig) {
     String externalIp = nodeConfig.getDiscoveryExternalIp();
     if (StringUtils.isEmpty(externalIp)) {

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

@@ -143,14 +143,12 @@ public void testIpFromLibP2p()
     String configuredExternalIp = parameter.getNodeExternalIp();
     Assert.assertEquals("46.168.1.1", configuredExternalIp);
 
-    Config config = Configuration.getByFileName(TestConstants.TEST_CONF);
-    Config config3 = config.withoutPath("node.discovery.external.ip");
-
     CommonParameter.getInstance().setNodeExternalIp(null);
 
-    Method method2 = Args.class.getDeclaredMethod("externalIp", Config.class);
+    NodeConfig nc = new NodeConfig();
+    Method method2 = Args.class.getDeclaredMethod("externalIp", NodeConfig.class);
     method2.setAccessible(true);
-    method2.invoke(Args.class, config3);
+    method2.invoke(Args.class, nc);
 
     Assert.assertNotEquals(configuredExternalIp, parameter.getNodeExternalIp());
   }