fix(config): remove inactive RocksDB options

Preserve the shipped RocksDB options that were effective before this change. Remove the inactive blocksize plumbing and table setters without activating the unverified table configuration.

Keep the existing shared cache object for separate configuration design and validation.

Closes #49

Author: bladehan1

common/src/main/java/org/tron/common/setting/RocksDbSettings.java

@@ -6,7 +6,6 @@
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import org.rocksdb.BlockBasedTableConfig;
-import org.rocksdb.BloomFilter;
 import org.rocksdb.ComparatorOptions;
 import org.rocksdb.InfoLogLevel;
 import org.rocksdb.LRUCache;
@@ -30,8 +29,6 @@ public class RocksDbSettings {
   @Getter
   private int compactThreads;
   @Getter
-  private long blockSize;
-  @Getter
   private long maxBytesForLevelBase;
   @Getter
   private double maxBytesForLevelMultiplier;
@@ -67,7 +64,7 @@ private RocksDbSettings() {
 
   public static RocksDbSettings getDefaultSettings() {
     RocksDbSettings defaultSettings = new RocksDbSettings();
-    return defaultSettings.withLevelNumber(7).withBlockSize(64).withCompactThreads(32)
+    return defaultSettings.withLevelNumber(7).withCompactThreads(32)
         .withTargetFileSizeBase(256).withMaxBytesForLevelMultiplier(10)
         .withTargetFileSizeMultiplier(1)
         .withMaxBytesForLevelBase(256).withMaxOpenFiles(5000).withEnableStatistics(false);
@@ -78,16 +75,14 @@ public static RocksDbSettings getSettings() {
   }
 
   public static RocksDbSettings initCustomSettings(int levelNumber, int compactThreads,
-      int blockSize, long maxBytesForLevelBase,
-      double maxBytesForLevelMultiplier, int level0FileNumCompactionTrigger,
-      long targetFileSizeBase,
+      long maxBytesForLevelBase, double maxBytesForLevelMultiplier,
+      int level0FileNumCompactionTrigger, long targetFileSizeBase,
       int targetFileSizeMultiplier, int maxOpenFiles) {
     rocksDbSettings = new RocksDbSettings()
         .withMaxOpenFiles(maxOpenFiles)
         .withEnableStatistics(false)
         .withLevelNumber(levelNumber)
         .withCompactThreads(compactThreads)
-        .withBlockSize(blockSize)
         .withMaxBytesForLevelBase(maxBytesForLevelBase)
         .withMaxBytesForLevelMultiplier(maxBytesForLevelMultiplier)
         .withLevel0FileNumCompactionTrigger(level0FileNumCompactionTrigger)
@@ -98,12 +93,11 @@ public static RocksDbSettings initCustomSettings(int levelNumber, int compactThr
 
   public static void loggingSettings() {
     logger.info(
-        "level number: {}, CompactThreads: {}, Blocksize:{}, maxBytesForLevelBase: {},"
+        "level number: {}, CompactThreads: {}, maxBytesForLevelBase: {},"
             + " withMaxBytesForLevelMultiplier: {}, level0FileNumCompactionTrigger: {}, "
             + "withTargetFileSizeBase: {}, withTargetFileSizeMultiplier: {}, maxOpenFiles: {}",
         rocksDbSettings.getLevelNumber(),
-        rocksDbSettings.getCompactThreads(), rocksDbSettings.getBlockSize(),
-        rocksDbSettings.getMaxBytesForLevelBase(),
+        rocksDbSettings.getCompactThreads(), rocksDbSettings.getMaxBytesForLevelBase(),
         rocksDbSettings.getMaxBytesForLevelMultiplier(),
         rocksDbSettings.getLevel0FileNumCompactionTrigger(),
         rocksDbSettings.getTargetFileSizeBase(), rocksDbSettings.getTargetFileSizeMultiplier(),
@@ -120,11 +114,6 @@ public RocksDbSettings withCompactThreads(int compactThreads) {
     return this;
   }
 
-  public RocksDbSettings withBlockSize(long blockSize) {
-    this.blockSize = blockSize * 1024;
-    return this;
-  }
-
   public RocksDbSettings withMaxBytesForLevelBase(long maxBytesForLevelBase) {
     this.maxBytesForLevelBase = maxBytesForLevelBase * 1024 * 1024;
     return this;
@@ -159,6 +148,7 @@ public RocksDbSettings withTargetFileSizeMultiplier(int targetFileSizeMultiplier
     this.targetFileSizeMultiplier = targetFileSizeMultiplier;
     return this;
   }
+
   public static LRUCache getCache() {
     return cache;
   }
@@ -211,13 +201,7 @@ protected void log(InfoLogLevel infoLogLevel, String logMsg) {
     options.setTargetFileSizeBase(settings.getTargetFileSizeBase());
 
     // table options
-    final BlockBasedTableConfig tableCfg;
-    options.setTableFormatConfig(tableCfg = new BlockBasedTableConfig());
-    tableCfg.setBlockSize(settings.getBlockSize());
-    tableCfg.setBlockCache(RocksDbSettings.getCache());
-    tableCfg.setCacheIndexAndFilterBlocks(true);
-    tableCfg.setPinL0FilterAndIndexBlocksInCache(true);
-    tableCfg.setFilter(new BloomFilter(10, false));
+    options.setTableFormatConfig(new BlockBasedTableConfig());
     if (Constant.MARKET_PAIR_PRICE_TO_ORDER.equals(dbName)) {
       ComparatorOptions comparatorOptions = new ComparatorOptions();
       options.setComparator(new MarketOrderPriceComparatorForRocksDB(comparatorOptions));

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

@@ -86,7 +86,6 @@ public static class DbSettingsConfig {
 
     private int levelNumber = 7;
     private int compactThreads = 0; // 0 = auto: max(availableProcessors, 1)
-    private int blocksize = 16;
     private long maxBytesForLevelBase = 256;
     private double maxBytesForLevelMultiplier = 10;
     private int level0FileNumCompactionTrigger = 2;

common/src/main/resources/reference.conf

@@ -108,7 +108,6 @@ storage {
   dbSettings = {
     levelNumber = 7             // Number of RocksDB levels.
     compactThreads = 0          // 0 = auto: max(availableProcessors, 1)
-    blocksize = 16              // n * KB
     maxBytesForLevelBase = 256  // n * MB
     maxBytesForLevelMultiplier = 10 // Level size multiplier.
     level0FileNumCompactionTrigger = 2 // L0 files that trigger compaction.

common/src/test/java/org/tron/common/setting/RocksDbSettingsTest.java

@@ -0,0 +1,59 @@
+/*
+ * java-tron is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * java-tron is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.tron.common.setting;
+
+import static org.junit.Assert.assertTrue;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Comparator;
+import java.util.stream.Stream;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.rocksdb.Options;
+import org.rocksdb.RocksDB;
+
+public class RocksDbSettingsTest {
+
+  @Rule
+  public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+  @Test
+  public void shouldKeepNativeBlockTableDefaults() throws Exception {
+    Path database = temporaryFolder.newFolder("rocksdb").toPath();
+
+    try (Options options = RocksDbSettings.getOptionsByDbName("test")) {
+      try (RocksDB ignored = RocksDB.open(options, database.toString())) {
+        // Opening the DB materializes the table factory and persists its native settings.
+      }
+    }
+
+    Path optionsFile;
+    try (Stream<Path> files = Files.list(database)) {
+      optionsFile = files
+          .filter(path -> path.getFileName().toString().startsWith("OPTIONS-"))
+          .max(Comparator.comparing(path -> path.getFileName().toString()))
+          .orElseThrow(() -> new AssertionError("RocksDB OPTIONS file not found"));
+    }
+    String nativeOptions = new String(Files.readAllBytes(optionsFile), StandardCharsets.UTF_8);
+
+    assertTrue(nativeOptions.contains("block_size=4096"));
+    assertTrue(nativeOptions.contains("pin_l0_filter_and_index_blocks_in_cache=false"));
+    assertTrue(nativeOptions.contains("filter_policy=nullptr"));
+  }
+}

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

@@ -68,7 +68,6 @@ public void testDbSettingsDefaults() {
     // compactThreads default is 0 in reference.conf, auto-expanded by postProcess()
     assertEquals(StrictMathWrapper.max(Runtime.getRuntime().availableProcessors(), 1),
         ds.getCompactThreads());
-    assertEquals(16, ds.getBlocksize());
     assertEquals(256, ds.getMaxBytesForLevelBase());
     assertEquals(10, ds.getMaxBytesForLevelMultiplier(), 0.01);
     assertEquals(2, ds.getLevel0FileNumCompactionTrigger());

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

@@ -228,10 +228,9 @@ private static void applyStorageConfig(StorageConfig sc) {
     StorageConfig.DbSettingsConfig dbs = sc.getDbSettings();
     PARAMETER.rocksDBCustomSettings = RocksDbSettings
         .initCustomSettings(dbs.getLevelNumber(), dbs.getCompactThreads(),
-            dbs.getBlocksize(), dbs.getMaxBytesForLevelBase(),
-            dbs.getMaxBytesForLevelMultiplier(), dbs.getLevel0FileNumCompactionTrigger(),
-            dbs.getTargetFileSizeBase(), dbs.getTargetFileSizeMultiplier(),
-            dbs.getMaxOpenFiles());
+            dbs.getMaxBytesForLevelBase(), dbs.getMaxBytesForLevelMultiplier(),
+            dbs.getLevel0FileNumCompactionTrigger(), dbs.getTargetFileSizeBase(),
+            dbs.getTargetFileSizeMultiplier(), dbs.getMaxOpenFiles());
     RocksDbSettings.loggingSettings();
 
     // Dynamic nested objects use StorageConfig's raw storage sub-tree
@@ -1315,4 +1314,3 @@ private static Map<String, String[]> getOptionGroup() {
     return optionGroupMap;
   }
 }
-

framework/src/main/resources/config.conf

@@ -26,7 +26,6 @@ storage {
   dbSettings = {
     levelNumber = 7
     # compactThreads = 32
-    blocksize = 64  // n * KB
     maxBytesForLevelBase = 256  // n * MB
     maxBytesForLevelMultiplier = 10
     level0FileNumCompactionTrigger = 4

framework/src/test/java/org/tron/core/config/ConfigurationTest.java

@@ -35,6 +35,7 @@
 import org.tron.common.crypto.ECKey;
 import org.tron.common.utils.ByteArray;
 import org.tron.core.Wallet;
+import org.tron.core.config.args.StorageConfig;
 
 @Slf4j
 public class ConfigurationTest {
@@ -91,4 +92,19 @@ public void getConfigurationWhenOnlyConfFileName() {
     assertTrue(config.hasPath("seed.node"));
     assertTrue(config.hasPath("genesis.block"));
   }
+
+  @Test
+  public void defaultConfigShouldPreserveEffectiveRocksDbSettings() {
+    Config config = Configuration.getByFileName("config.conf");
+    StorageConfig.DbSettingsConfig settings = StorageConfig.fromConfig(config).getDbSettings();
+
+    assertFalse(config.hasPath("storage.dbSettings.blocksize"));
+    assertEquals(7, settings.getLevelNumber());
+    assertEquals(256, settings.getMaxBytesForLevelBase());
+    assertEquals(10, settings.getMaxBytesForLevelMultiplier(), 0.01);
+    assertEquals(4, settings.getLevel0FileNumCompactionTrigger());
+    assertEquals(256, settings.getTargetFileSizeBase());
+    assertEquals(1, settings.getTargetFileSizeMultiplier());
+    assertEquals(5000, settings.getMaxOpenFiles());
+  }
 }