You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by rp...@apache.org on 2025/07/10 15:16:02 UTC

(ignite-3) branch main updated: IGNITE-25854 Implement method to get non-destroyed RocksDB tables IDs (#6229)

This is an automated email from the ASF dual-hosted git repository.

rpuch pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/ignite-3.git


The following commit(s) were added to refs/heads/main by this push:
     new 08222f16884 IGNITE-25854 Implement method to get non-destroyed RocksDB tables IDs (#6229)
08222f16884 is described below

commit 08222f168846c86a65e159cab9e632583ac24add
Author: Roman Puchkovskiy <ro...@gmail.com>
AuthorDate: Thu Jul 10 19:15:56 2025 +0400

    IGNITE-25854 Implement method to get non-destroyed RocksDB tables IDs (#6229)
---
 .../internal/storage/engine/MvTableStorage.java    | 12 ++++--
 .../internal/storage/engine/StorageEngine.java     |  3 +-
 .../engine/ThreadAssertingStorageEngine.java       |  2 +
 .../AbstractPersistentStorageEngineTest.java       | 26 +++++++++----
 .../storage/engine/AbstractStorageEngineTest.java  |  2 +-
 .../PersistentPageMemoryStorageEngineTest.java     |  5 +++
 .../storage/rocksdb/ColumnFamilyUtils.java         |  2 +-
 .../storage/rocksdb/RocksDbMvPartitionStorage.java |  1 +
 .../storage/rocksdb/RocksDbStorageEngine.java      | 22 +++++++++++
 .../rocksdb/index/AbstractRocksDbIndexStorage.java | 43 +++++++++++++++------
 .../rocksdb/instance/SharedRocksDbInstance.java    | 45 ++++++++++++++++++++++
 .../rocksdb/engine/RocksDbStorageEngineTest.java   | 18 +++------
 12 files changed, 144 insertions(+), 37 deletions(-)

diff --git a/modules/storage-api/src/main/java/org/apache/ignite/internal/storage/engine/MvTableStorage.java b/modules/storage-api/src/main/java/org/apache/ignite/internal/storage/engine/MvTableStorage.java
index 354cb6e2a34..ab70e6ced73 100644
--- a/modules/storage-api/src/main/java/org/apache/ignite/internal/storage/engine/MvTableStorage.java
+++ b/modules/storage-api/src/main/java/org/apache/ignite/internal/storage/engine/MvTableStorage.java
@@ -64,7 +64,9 @@ public interface MvTableStorage extends ManuallyCloseable {
     @Nullable MvPartitionStorage getMvPartition(int partitionId);
 
     /**
-     * Destroys a partition and all associated indices.
+     * Destroys a partition and all associated indices. The destruction (even after the future has completed) is not guaranteed
+     * to be durable (that is, if a node stops/crashes before persisting this change to disk, the storage might still be there after
+     * node restart).
      *
      * <p>REQUIRED: For background tasks for partition, such as rebalancing, to be completed by the time the method is called.
      *
@@ -95,7 +97,9 @@ public interface MvTableStorage extends ManuallyCloseable {
     void createHashIndex(int partitionId, StorageHashIndexDescriptor indexDescriptor);
 
     /**
-     * Destroys the index with the given ID and all data in it.
+     * Destroys the index with the given ID and all data in it. The destruction (even after the future has completed) is not guaranteed
+     * to be durable (that is, if a node stops/crashes before persisting this change to disk, the storage might still be there after
+     * node restart).
      *
      * <p>This method is a no-op if the index with the given ID does not exist or if the table storage is closed or under destruction.
      *
@@ -109,7 +113,9 @@ public interface MvTableStorage extends ManuallyCloseable {
     boolean isVolatile();
 
     /**
-     * Stops and destroys the storage and cleans all allocated resources.
+     * Stops and destroys the storage and cleans all allocated resources. The destruction (even after the future has completed)
+     * is not guaranteed to be durable (that is, if a node stops/crashes before persisting this change to disk, the storage might
+     * still be there after node restart).
      *
      * @return Future that will complete when the table destruction is complete.
      */
diff --git a/modules/storage-api/src/main/java/org/apache/ignite/internal/storage/engine/StorageEngine.java b/modules/storage-api/src/main/java/org/apache/ignite/internal/storage/engine/StorageEngine.java
index 7e9aaa8ccd0..90b693885bf 100644
--- a/modules/storage-api/src/main/java/org/apache/ignite/internal/storage/engine/StorageEngine.java
+++ b/modules/storage-api/src/main/java/org/apache/ignite/internal/storage/engine/StorageEngine.java
@@ -64,7 +64,8 @@ public interface StorageEngine {
     MvTableStorage createMvTable(StorageTableDescriptor tableDescriptor, StorageIndexDescriptorSupplier indexDescriptorSupplier);
 
     /**
-     * Destroys the table if it exists.
+     * Destroys the table if it exists. The destruction is not guaranteed to be durable (that is, if a node stops/crashes before
+     * persisting this change to disk, the table storage might still be there after node restart).
      *
      * @param tableId Table ID.
      * @throws StorageException If an error has occurs while dropping the table.
diff --git a/modules/storage-api/src/main/java/org/apache/ignite/internal/storage/engine/ThreadAssertingStorageEngine.java b/modules/storage-api/src/main/java/org/apache/ignite/internal/storage/engine/ThreadAssertingStorageEngine.java
index 647346b3bcf..e0e75b98e98 100644
--- a/modules/storage-api/src/main/java/org/apache/ignite/internal/storage/engine/ThreadAssertingStorageEngine.java
+++ b/modules/storage-api/src/main/java/org/apache/ignite/internal/storage/engine/ThreadAssertingStorageEngine.java
@@ -45,6 +45,8 @@ public class ThreadAssertingStorageEngine implements StorageEngine {
 
     @Override
     public void start() throws StorageException {
+        assertThreadAllowsToWrite();
+
         storageEngine.start();
     }
 
diff --git a/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/engine/AbstractPersistentStorageEngineTest.java b/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/engine/AbstractPersistentStorageEngineTest.java
index fa50d2eb388..6611c861181 100644
--- a/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/engine/AbstractPersistentStorageEngineTest.java
+++ b/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/engine/AbstractPersistentStorageEngineTest.java
@@ -70,6 +70,9 @@ import org.mockito.Mock;
  * because it doesn't limit the usage of the engine with a single table.
  */
 public abstract class AbstractPersistentStorageEngineTest extends AbstractStorageEngineTest {
+    /** Makes sure that table destruction is persisted durably. */
+    protected abstract void persistTableDestructionIfNeeded();
+
     @Test
     void isNonVolatile() {
         assertFalse(storageEngine.isVolatile());
@@ -360,8 +363,8 @@ public abstract class AbstractPersistentStorageEngineTest extends AbstractStorag
     @ParameterizedTest
     @ValueSource(booleans = {true, false})
     protected void remembersCreatedTableIdsOnDisk(boolean restart) {
-        createTableStorageWithPartitionStorage(1);
-        createTableStorageWithPartitionStorage(3);
+        createTableStorageLeavingTraceOnDisk(1);
+        createTableStorageLeavingTraceOnDisk(3);
 
         if (restart) {
             restartEngine();
@@ -372,20 +375,21 @@ public abstract class AbstractPersistentStorageEngineTest extends AbstractStorag
 
     @ParameterizedTest
     @ValueSource(booleans = {true, false})
-    protected void tableIdsOnDiskGoAfterDestruction(boolean restart) {
-        MvTableStorage tableStorage1 = createTableStorageWithPartitionStorage(1);
-        createTableStorageWithPartitionStorage(3);
+    protected void tableIdsOnDiskGetRemovedOnPersistedDestruction(boolean restart) {
+        MvTableStorage tableStorage1 = createTableStorageLeavingTraceOnDisk(1);
+        createTableStorageLeavingTraceOnDisk(3);
 
         assertThat(tableStorage1.destroy(), willCompleteSuccessfully());
 
         if (restart) {
+            persistTableDestructionIfNeeded();
             restartEngine();
         }
 
         assertThat(storageEngine.tableIdsOnDisk(), contains(3));
     }
 
-    private MvTableStorage createTableStorageWithPartitionStorage(int tableId) {
+    private MvTableStorage createTableStorageLeavingTraceOnDisk(int tableId) {
         StorageTableDescriptor tableDescriptor = new StorageTableDescriptor(tableId, 1, DEFAULT_STORAGE_PROFILE);
         StorageIndexDescriptorSupplier indexSupplier = mock(StorageIndexDescriptorSupplier.class);
 
@@ -394,7 +398,15 @@ public abstract class AbstractPersistentStorageEngineTest extends AbstractStorag
         CompletableFuture<MvPartitionStorage> partitionStorageFuture = tableStorage.createMvPartition(0);
         assertThat(partitionStorageFuture, willCompleteSuccessfully());
 
-        assertThat(partitionStorageFuture.join().flush(), willCompleteSuccessfully());
+        MvPartitionStorage partitionStorage = partitionStorageFuture.join();
+
+        partitionStorage.runConsistently(locker -> {
+            partitionStorage.committedGroupConfiguration(new byte[]{1, 2, 3});
+            partitionStorage.lastApplied(1, 1);
+            return null;
+        });
+
+        assertThat(partitionStorage.flush(), willCompleteSuccessfully());
 
         return tableStorage;
     }
diff --git a/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/engine/AbstractStorageEngineTest.java b/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/engine/AbstractStorageEngineTest.java
index 8d33f11f28b..d034daf27e0 100644
--- a/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/engine/AbstractStorageEngineTest.java
+++ b/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/engine/AbstractStorageEngineTest.java
@@ -34,7 +34,7 @@ import org.mockito.junit.jupiter.MockitoExtension;
 @ExtendWith(MockitoExtension.class)
 public abstract class AbstractStorageEngineTest extends BaseMvStoragesTest {
     /** Engine instance. */
-    StorageEngine storageEngine;
+    protected StorageEngine storageEngine;
 
     protected LogSyncer logSyncer = mock(LogSyncer.class);
 
diff --git a/modules/storage-page-memory/src/test/java/org/apache/ignite/internal/storage/pagememory/engine/PersistentPageMemoryStorageEngineTest.java b/modules/storage-page-memory/src/test/java/org/apache/ignite/internal/storage/pagememory/engine/PersistentPageMemoryStorageEngineTest.java
index 3c2802a8d9e..94016ec43bd 100644
--- a/modules/storage-page-memory/src/test/java/org/apache/ignite/internal/storage/pagememory/engine/PersistentPageMemoryStorageEngineTest.java
+++ b/modules/storage-page-memory/src/test/java/org/apache/ignite/internal/storage/pagememory/engine/PersistentPageMemoryStorageEngineTest.java
@@ -100,4 +100,9 @@ public class PersistentPageMemoryStorageEngineTest extends AbstractPersistentSto
             assertThat(((PersistentPageMemoryProfileView) view).sizeBytes(), is(12345L));
         }
     }
+
+    @Override
+    protected void persistTableDestructionIfNeeded() {
+        // No-op as table destruction is durable for this engine.
+    }
 }
diff --git a/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/ColumnFamilyUtils.java b/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/ColumnFamilyUtils.java
index 7f2ab963948..b9e4dad5880 100644
--- a/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/ColumnFamilyUtils.java
+++ b/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/ColumnFamilyUtils.java
@@ -39,7 +39,7 @@ public class ColumnFamilyUtils {
         RocksDB.loadLibrary();
     }
 
-    /** Name of the meta column family matches default columns family, meaning that it always exist when new table is created. */
+    /** Name of the meta column family matches default columns family, meaning that it always exists when new table is created. */
     private static final String META_CF_NAME = "default";
 
     /** Name of the Column Family that stores partition data with references to row data. */
diff --git a/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/RocksDbMvPartitionStorage.java b/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/RocksDbMvPartitionStorage.java
index 652a5f627ca..54cfc23fd4e 100644
--- a/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/RocksDbMvPartitionStorage.java
+++ b/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/RocksDbMvPartitionStorage.java
@@ -1180,6 +1180,7 @@ public class RocksDbMvPartitionStorage implements MvPartitionStorage {
         writeBatch.delete(meta, lastAppliedIndexAndTermKey);
         writeBatch.delete(meta, lastGroupConfigKey);
         writeBatch.delete(meta, leaseKey);
+        writeBatch.delete(meta, estimatedSizeKey);
 
         writeBatch.deleteRange(helper.partCf, helper.partitionStartPrefix(), helper.partitionEndPrefix());
         writeBatch.deleteRange(helper.dataCf, helper.partitionStartPrefix(), helper.partitionEndPrefix());
diff --git a/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/RocksDbStorageEngine.java b/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/RocksDbStorageEngine.java
index 523c79bfa8a..d6cd7aab2ed 100644
--- a/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/RocksDbStorageEngine.java
+++ b/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/RocksDbStorageEngine.java
@@ -17,6 +17,8 @@
 
 package org.apache.ignite.internal.storage.rocksdb;
 
+import static java.util.concurrent.CompletableFuture.allOf;
+import static java.util.stream.Collectors.toUnmodifiableSet;
 import static org.apache.ignite.internal.storage.configurations.StorageProfileConfigurationSchema.UNSPECIFIED_SIZE;
 import static org.apache.ignite.internal.util.IgniteUtils.closeAll;
 import static org.apache.ignite.internal.util.IgniteUtils.closeAllManually;
@@ -24,6 +26,7 @@ import static org.apache.ignite.internal.util.IgniteUtils.shutdownAndAwaitTermin
 
 import java.nio.file.Path;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
@@ -270,4 +273,23 @@ public class RocksDbStorageEngine implements StorageEngine {
             rocksDbStorage.rocksDbInstance.destroyTable(tableId);
         }
     }
+
+    @Override
+    public Set<Integer> tableIdsOnDisk() {
+        return storageByProfileName.values().stream()
+                .flatMap(storage -> storage.rocksDbInstance.tableIdsOnDisk().stream())
+                .collect(toUnmodifiableSet());
+    }
+
+    /**
+     * Flushes all changes made to the underlying RocksDB instances to disk.
+     *
+     * @return Future that gets completed when flush is complete.
+     */
+    public CompletableFuture<Void> flush() {
+        CompletableFuture<?>[] futures = storageByProfileName.values().stream()
+                .map(storage -> storage.rocksDbInstance.flush())
+                .toArray(CompletableFuture[]::new);
+        return allOf(futures);
+    }
 }
diff --git a/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/index/AbstractRocksDbIndexStorage.java b/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/index/AbstractRocksDbIndexStorage.java
index c53195b632e..9933cfda535 100644
--- a/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/index/AbstractRocksDbIndexStorage.java
+++ b/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/index/AbstractRocksDbIndexStorage.java
@@ -159,7 +159,7 @@ public abstract class AbstractRocksDbIndexStorage implements IndexStorage {
         busyLock.block();
 
         try {
-            destroyData(writeBatch);
+            clearData(writeBatch);
         } catch (RocksDBException e) {
             throw new StorageRebalanceException("Error when trying to start rebalancing storage: " + createStorageInfo(), e);
         } finally {
@@ -178,7 +178,7 @@ public abstract class AbstractRocksDbIndexStorage implements IndexStorage {
         }
 
         try {
-            destroyData(writeBatch);
+            clearData(writeBatch);
         } catch (RocksDBException e) {
             throw new StorageRebalanceException("Error when trying to abort rebalancing storage: " + createStorageInfo(), e);
         }
@@ -208,7 +208,7 @@ public abstract class AbstractRocksDbIndexStorage implements IndexStorage {
         // Changed storage states and expect all storage operations to stop soon.
         busyLock.block();
 
-        destroyData(writeBatch);
+        clearData(writeBatch);
     }
 
     /**
@@ -257,24 +257,43 @@ public abstract class AbstractRocksDbIndexStorage implements IndexStorage {
     }
 
     /**
-     * Deletes the data associated with the index, using passed write batch for the operation.
+     * Deletes the data associated with the index to prepare the storage for subsequent use, using passed write batch for the operation.
      *
      * @throws RocksDBException If failed to delete data.
      */
-    public final void destroyData(WriteBatch writeBatch) throws RocksDBException {
+    public final void clearData(WriteBatch writeBatch) throws RocksDBException {
         clearIndex(writeBatch);
 
         if (descriptor.mustBeBuilt()) {
-            RowId initialRowId = initialRowIdToBuild(partitionId);
+            resetNextRowIdToBuild(writeBatch);
+        } else {
+            removeNextRowIdToBuild(writeBatch);
+        }
+    }
+
+    /**
+     * Deletes the data associated with the index (the storage will not be used anymore), using passed write batch for the operation.
+     *
+     * @throws RocksDBException If failed to delete data.
+     */
+    public final void destroyData(WriteBatch writeBatch) throws RocksDBException {
+        clearIndex(writeBatch);
 
-            indexMetaStorage.putNextRowIdToBuild(writeBatch, tableId, indexId, partitionId, initialRowId);
+        removeNextRowIdToBuild(writeBatch);
+    }
 
-            nextRowIdToBuild = initialRowId;
-        } else {
-            indexMetaStorage.removeNextRowIdToBuild(writeBatch, tableId, indexId, partitionId);
+    private void resetNextRowIdToBuild(WriteBatch writeBatch) {
+        RowId initialRowId = initialRowIdToBuild(partitionId);
 
-            nextRowIdToBuild = null;
-        }
+        indexMetaStorage.putNextRowIdToBuild(writeBatch, tableId, indexId, partitionId, initialRowId);
+
+        nextRowIdToBuild = initialRowId;
+    }
+
+    private void removeNextRowIdToBuild(WriteBatch writeBatch) {
+        indexMetaStorage.removeNextRowIdToBuild(writeBatch, tableId, indexId, partitionId);
+
+        nextRowIdToBuild = null;
     }
 
     /** Method that needs to be overridden by the inheritors to remove all implementation specific data for this index. */
diff --git a/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/instance/SharedRocksDbInstance.java b/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/instance/SharedRocksDbInstance.java
index c33803f5679..384d7a6915a 100644
--- a/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/instance/SharedRocksDbInstance.java
+++ b/modules/storage-rocksdb/src/main/java/org/apache/ignite/internal/storage/rocksdb/instance/SharedRocksDbInstance.java
@@ -29,6 +29,7 @@ import static org.apache.ignite.internal.storage.rocksdb.RocksDbStorageUtils.KEY
 import static org.apache.ignite.internal.storage.rocksdb.instance.SharedRocksDbInstanceCreator.sortedIndexCfOptions;
 import static org.apache.ignite.internal.util.ByteUtils.intToBytes;
 import static org.apache.ignite.internal.util.IgniteUtils.closeAll;
+import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
 
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
@@ -36,14 +37,17 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.atomic.AtomicBoolean;
 import org.apache.ignite.internal.lang.ByteArray;
+import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.rocksdb.ColumnFamily;
 import org.apache.ignite.internal.rocksdb.flush.RocksDbFlusher;
 import org.apache.ignite.internal.storage.StorageClosedException;
@@ -53,6 +57,7 @@ import org.apache.ignite.internal.storage.rocksdb.IndexIdCursor;
 import org.apache.ignite.internal.storage.rocksdb.IndexIdCursor.TableAndIndexId;
 import org.apache.ignite.internal.storage.rocksdb.RocksDbMetaStorage;
 import org.apache.ignite.internal.storage.rocksdb.RocksDbStorageEngine;
+import org.apache.ignite.internal.util.ByteUtils;
 import org.apache.ignite.internal.util.IgniteSpinBusyLock;
 import org.jetbrains.annotations.Nullable;
 import org.rocksdb.ColumnFamilyDescriptor;
@@ -443,4 +448,44 @@ public final class SharedRocksDbInstance {
             );
         }
     }
+
+    /**
+     * Returns IDs of all tables for which there are storages in the underlying RocksDB.
+     */
+    public Set<Integer> tableIdsOnDisk() {
+        Set<Integer> tableIds = new HashSet<>();
+
+        try (
+                var upperBound = new Slice(incrementPrefix(PARTITION_META_PREFIX));
+                var readOptions = new ReadOptions().setIterateUpperBound(upperBound);
+                RocksIterator it = meta.columnFamily().newIterator(readOptions)
+        ) {
+            it.seek(PARTITION_META_PREFIX);
+
+            while (it.isValid()) {
+                byte[] key = it.key();
+                int tableId = ByteUtils.bytesToInt(key, PARTITION_META_PREFIX.length);
+                tableIds.add(tableId);
+
+                it.next();
+            }
+
+            // Doing this to make an exception thrown if the iteration was stopped due to an error and not due to exhausting
+            // the iteration space.
+            it.status();
+        } catch (RocksDBException e) {
+            throw new IgniteInternalException(INTERNAL_ERR, "Cannot get table IDs", e);
+        }
+
+        return Set.copyOf(tableIds);
+    }
+
+    /**
+     * Flushes the underlying RocksDB to disk.
+     *
+     * @return Future that gets completed when the flush completes.
+     */
+    public CompletableFuture<Void> flush() {
+        return flusher.awaitFlush(true);
+    }
 }
diff --git a/modules/storage-rocksdb/src/test/java/org/apache/ignite/internal/storage/rocksdb/engine/RocksDbStorageEngineTest.java b/modules/storage-rocksdb/src/test/java/org/apache/ignite/internal/storage/rocksdb/engine/RocksDbStorageEngineTest.java
index 6bb22a75799..1d9ddeef024 100644
--- a/modules/storage-rocksdb/src/test/java/org/apache/ignite/internal/storage/rocksdb/engine/RocksDbStorageEngineTest.java
+++ b/modules/storage-rocksdb/src/test/java/org/apache/ignite/internal/storage/rocksdb/engine/RocksDbStorageEngineTest.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.storage.rocksdb.engine;
 
+import static org.apache.ignite.internal.testframework.matchers.CompletableFutureMatcher.willCompleteSuccessfully;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
 import static org.mockito.Mockito.mock;
@@ -70,6 +71,11 @@ public class RocksDbStorageEngineTest extends AbstractPersistentStorageEngineTes
         );
     }
 
+    @Override
+    protected void persistTableDestructionIfNeeded() {
+        assertThat(((RocksDbStorageEngine) storageEngine).flush(), willCompleteSuccessfully());
+    }
+
     @Test
     void dataRegionSizeGetsInitialized() {
         for (StorageProfileView view : storageConfiguration.profiles().value()) {
@@ -90,16 +96,4 @@ public class RocksDbStorageEngineTest extends AbstractPersistentStorageEngineTes
             assertThat(((RocksDbProfileView) view).sizeBytes(), is(12345L));
         }
     }
-
-    // TODO: https://issues.apache.org/jira/browse/IGNITE-25854 - remove the override.
-    @Override
-    protected void remembersCreatedTableIdsOnDisk(boolean restart) {
-        // No-op.
-    }
-
-    // TODO: https://issues.apache.org/jira/browse/IGNITE-25854 - remove the override.
-    @Override
-    protected void tableIdsOnDiskGoAfterDestruction(boolean restart) {
-        // No-op.
-    }
 }