fix(db): resolve resource leakage in database close()

chainbase/src/main/java/org/tron/core/db/TronDatabase.java

@@ -78,12 +78,15 @@ public void close() {
     logger.info("******** Begin to close {}. ********", getName());
     try {
       writeOptions.close();
+    } catch (Exception e) {
+      logger.warn("Failed to close writeOptions in {}.", getName(), e);
+    }
+    try {
       dbSource.closeDB();
     } catch (Exception e) {
-      logger.warn("Failed to close {}.", getName(), e);
-    } finally {
-      logger.info("******** End to close {}. ********", getName());
+      logger.warn("Failed to close dbSource in {}.", getName(), e);
     }
+    logger.info("******** End to close {}. ********", getName());
   }
 
   public abstract void put(byte[] key, T item);

chainbase/src/main/java/org/tron/core/store/CheckPointV2Store.java

@@ -63,19 +63,18 @@ public void updateByBatch(Map<byte[], byte[]> rows) {
   }
 
   /**
-   * close the database.
+   * Closes the database and releases all resources.
+   * This method ensures that subclass-specific resources are cleaned up
+   * before delegating to the parent class for complete resource cleanup.
    */
   @Override
   public void close() {
-    logger.debug("******** Begin to close {}. ********", getName());
     try {
       writeOptions.close();
-      dbSource.closeDB();
     } catch (Exception e) {
-      logger.warn("Failed to close {}.", getName(), e);
-    } finally {
-      logger.debug("******** End to close {}. ********", getName());
+      logger.warn("Failed to close writeOptions in {}.", getName(), e);
     }
+    super.close();
   }
 
 }

framework/src/test/java/org/tron/core/db/CheckPointV2StoreTest.java

@@ -0,0 +1,104 @@
+package org.tron.core.db;
+
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+
+import java.io.IOException;
+import java.lang.reflect.Field;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.rocksdb.RocksDB;
+import org.tron.common.TestConstants;
+import org.tron.common.storage.WriteOptionsWrapper;
+import org.tron.core.config.args.Args;
+import org.tron.core.db.common.DbSourceInter;
+import org.tron.core.store.CheckPointV2Store;
+
+public class CheckPointV2StoreTest {
+
+  @ClassRule
+  public static final TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+  static {
+    RocksDB.loadLibrary();
+  }
+
+  @BeforeClass
+  public static void initArgs() throws IOException {
+    Args.setParam(
+        new String[]{"-d", temporaryFolder.newFolder().toString()},
+        TestConstants.TEST_CONF
+    );
+  }
+
+  @AfterClass
+  public static void destroy() {
+    Args.clearParam();
+  }
+
+  @Test
+  public void testCloseReleasesAllResources() throws Exception {
+    CheckPointV2Store store = new CheckPointV2Store("test-close");
+
+    // Replace dbSource with a mock so we can verify closeDB()
+    Field dbSourceField = TronDatabase.class.getDeclaredField("dbSource");
+    dbSourceField.setAccessible(true);
+    DbSourceInter<byte[]> originalDbSource = (DbSourceInter<byte[]>) dbSourceField.get(store);
+    DbSourceInter<byte[]> mockDbSource = mock(DbSourceInter.class);
+    dbSourceField.set(store, mockDbSource);
+
+    try {
+      store.close();
+
+      verify(mockDbSource).closeDB();
+    } finally {
+      originalDbSource.closeDB();
+    }
+  }
+
+  @Test
+  public void testCloseDbSourceWhenWriteOptionsThrows() throws Exception {
+    CheckPointV2Store store = new CheckPointV2Store("test-close-exception");
+
+    // Replace child writeOptions with a spy that throws on close
+    Field childWriteOptionsField = CheckPointV2Store.class.getDeclaredField("writeOptions");
+    childWriteOptionsField.setAccessible(true);
+    WriteOptionsWrapper childWriteOptions =
+        (WriteOptionsWrapper) childWriteOptionsField.get(store);
+    WriteOptionsWrapper spyChildWriteOptions = spy(childWriteOptions);
+    doThrow(new RuntimeException("simulated writeOptions failure"))
+        .when(spyChildWriteOptions).close();
+    childWriteOptionsField.set(store, spyChildWriteOptions);
+
+    // Replace parent writeOptions with a spy that throws on close
+    Field parentWriteOptionsField = TronDatabase.class.getDeclaredField("writeOptions");
+    parentWriteOptionsField.setAccessible(true);
+    WriteOptionsWrapper parentWriteOptions =
+        (WriteOptionsWrapper) parentWriteOptionsField.get(store);
+    WriteOptionsWrapper spyParentWriteOptions = spy(parentWriteOptions);
+    doThrow(new RuntimeException("simulated parent writeOptions failure"))
+        .when(spyParentWriteOptions).close();
+    parentWriteOptionsField.set(store, spyParentWriteOptions);
+
+    // Replace dbSource with a mock
+    Field dbSourceField = TronDatabase.class.getDeclaredField("dbSource");
+    dbSourceField.setAccessible(true);
+    DbSourceInter<byte[]> originalDbSource = (DbSourceInter<byte[]>) dbSourceField.get(store);
+    DbSourceInter<byte[]> mockDbSource = mock(DbSourceInter.class);
+    dbSourceField.set(store, mockDbSource);
+
+    try {
+      store.close();
+
+      // dbSource.closeDB() must be called even though both writeOptions threw
+      verify(mockDbSource).closeDB();
+    } finally {
+      originalDbSource.closeDB();
+    }
+  }
+}