From 09bef00f982081751cbd74322948d27683eebcbb Mon Sep 17 00:00:00 2001 From: Peng Junzhi <201250214@smail.nju.edu.cn> Date: Wed, 18 Nov 2026 23:17:35 +0800 Subject: [PATCH] [Pipe] Avoid creating DAL managers during region cleanup and suppress expected close warnings --- .../deletion/DeletionResourceManager.java | 21 +++- .../persist/PageCacheDeletionBuffer.java | 6 +- .../storageengine/dataregion/DataRegion.java | 7 +- .../DeletionResourceManagerCleanupTest.java | 114 ++++++++++++++++++ .../persist/PageCacheDeletionBufferTest.java | 75 ++++++++++++ 5 files changed, 215 insertions(+), 8 deletions(-) create mode 100644 iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/consensus/deletion/DeletionResourceManagerCleanupTest.java diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/consensus/deletion/DeletionResourceManager.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/consensus/deletion/DeletionResourceManager.java index 98f447a4b12a3..416fe2776597a 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/consensus/deletion/DeletionResourceManager.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/consensus/deletion/DeletionResourceManager.java @@ -176,7 +176,26 @@ public List getAllDeletionResources() { } } - public void removeDAL() { + /** Close an existing manager and remove its DAL without creating a manager for cleanup. */ + public static void closeAndRemoveDAL(int groupId) { + if (DeletionResourceManagerHolder.CONSENSUS_GROUP_ID_2_INSTANCE_MAP == null) { + return; + } + final DeletionResourceManager manager = + DeletionResourceManagerHolder.CONSENSUS_GROUP_ID_2_INSTANCE_MAP.get(groupId); + if (manager != null) { + manager.close(); + removeDAL(groupId, manager.storageDir); + } else { + removeDAL( + groupId, + new File( + IoTDBDescriptor.getInstance().getConfig().getIotConsensusV2DeletionFileDir(), + Integer.toString(groupId))); + } + } + + private static void removeDAL(int dataRegionId, File storageDir) { if (storageDir.exists()) { FileUtils.deleteFileOrDirectory(storageDir); LOGGER.info( diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/consensus/deletion/persist/PageCacheDeletionBuffer.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/consensus/deletion/persist/PageCacheDeletionBuffer.java index 6fe2246627f1f..945b70e7c380c 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/consensus/deletion/persist/PageCacheDeletionBuffer.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/consensus/deletion/persist/PageCacheDeletionBuffer.java @@ -390,7 +390,11 @@ private void persistDeletion() throws IOException { maxProgressIndexInCurrentFile.updateToMinimumEqualOrIsAfterProgressIndex( firstDeletionResource.getProgressIndex()); } catch (InterruptedException e) { - LOGGER.warn(DataNodePipeMessages.INTERRUPTED_WHEN_WAITING_FOR_TAKING_DELETIONRESOURCE_FROM); + // shutdownNow interrupts the idle queue wait during normal close. + if (!isClosed) { + LOGGER.warn( + DataNodePipeMessages.INTERRUPTED_WHEN_WAITING_FOR_TAKING_DELETIONRESOURCE_FROM); + } Thread.currentThread().interrupt(); return; } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/DataRegion.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/DataRegion.java index 94f44022ceffe..d19a9e0813e63 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/DataRegion.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/DataRegion.java @@ -2456,12 +2456,7 @@ public void shutdownUpgradeModFileThreadPool() { } public void deleteDALFolderAndClose() { - Optional.ofNullable(DeletionResourceManager.getInstance(dataRegionId.getId())) - .ifPresent( - manager -> { - manager.close(); - manager.removeDAL(); - }); + DeletionResourceManager.closeAndRemoveDAL(dataRegionId.getId()); } /** close all tsfile resource */ diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/consensus/deletion/DeletionResourceManagerCleanupTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/consensus/deletion/DeletionResourceManagerCleanupTest.java new file mode 100644 index 0000000000000..7eff2b86e004d --- /dev/null +++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/consensus/deletion/DeletionResourceManagerCleanupTest.java @@ -0,0 +1,114 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.iotdb.db.pipe.consensus.deletion; + +import org.apache.iotdb.db.conf.IoTDBDescriptor; +import org.apache.iotdb.db.pipe.consensus.deletion.persist.PageCacheDeletionBuffer; + +import ch.qos.logback.classic.Logger; +import ch.qos.logback.classic.spi.ILoggingEvent; +import ch.qos.logback.core.Appender; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; +import org.slf4j.LoggerFactory; + +import java.io.File; +import java.nio.file.Files; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; + +public class DeletionResourceManagerCleanupTest { + private static final int REGION_ID = 91821; + @Rule public final TemporaryFolder temporaryFolder = new TemporaryFolder(); + private String previousDirectory; + private int previousBufferSize; + private Logger bufferLogger; + private Appender appender; + + @Before + @SuppressWarnings("unchecked") + public void setUp() throws Exception { + previousDirectory = + IoTDBDescriptor.getInstance().getConfig().getIotConsensusV2DeletionFileDir(); + previousBufferSize = PageCacheDeletionBuffer.DAL_BUFFER_SIZE; + IoTDBDescriptor.getInstance() + .getConfig() + .setIotConsensusV2DeletionFileDir(temporaryFolder.getRoot().getAbsolutePath()); + PageCacheDeletionBuffer.setDalBufferSize(1024); + DeletionResourceManager.buildForTest(); + bufferLogger = (Logger) LoggerFactory.getLogger(PageCacheDeletionBuffer.class); + appender = mock(Appender.class); + bufferLogger.addAppender(appender); + } + + @After + public void tearDown() { + try { + DeletionResourceManager.closeAndRemoveDAL(REGION_ID); + } finally { + bufferLogger.detachAppender(appender); + IoTDBDescriptor.getInstance().getConfig().setIotConsensusV2DeletionFileDir(previousDirectory); + PageCacheDeletionBuffer.setDalBufferSize(previousBufferSize); + } + } + + @Test + public void testCleanupWithoutManagerDoesNotStartBuffer() { + DeletionResourceManager.closeAndRemoveDAL(REGION_ID); + + Assert.assertFalse(regionDirectory().exists()); + verify(appender, never()).doAppend(any(ILoggingEvent.class)); + } + + @Test + public void testCleanupRemovesOrphanedDALWithoutStartingBuffer() throws Exception { + final File directory = regionDirectory(); + Assert.assertTrue(directory.mkdir()); + Files.write(new File(directory, "_0-0.deletion").toPath(), new byte[] {1, 2, 3}); + + DeletionResourceManager.closeAndRemoveDAL(REGION_ID); + + Assert.assertFalse(directory.exists()); + verify(appender, never()).doAppend(any(ILoggingEvent.class)); + } + + @Test + public void testCleanupClosesExistingManagerAndAllowsRecreation() { + final DeletionResourceManager manager = DeletionResourceManager.getInstance(REGION_ID); + Assert.assertTrue(regionDirectory().exists()); + + DeletionResourceManager.closeAndRemoveDAL(REGION_ID); + + Assert.assertFalse(regionDirectory().exists()); + Assert.assertNotSame(manager, DeletionResourceManager.getInstance(REGION_ID)); + Assert.assertTrue(regionDirectory().exists()); + } + + private File regionDirectory() { + return new File(temporaryFolder.getRoot(), Integer.toString(REGION_ID)); + } +} diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/consensus/deletion/persist/PageCacheDeletionBufferTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/consensus/deletion/persist/PageCacheDeletionBufferTest.java index 59d0d2862bd7c..9891f86052062 100644 --- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/consensus/deletion/persist/PageCacheDeletionBufferTest.java +++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/consensus/deletion/persist/PageCacheDeletionBufferTest.java @@ -24,11 +24,16 @@ import org.apache.iotdb.commons.path.MeasurementPath; import org.apache.iotdb.commons.queryengine.plan.planner.plan.node.PlanNodeId; import org.apache.iotdb.db.conf.IoTDBDescriptor; +import org.apache.iotdb.db.i18n.DataNodePipeMessages; import org.apache.iotdb.db.pipe.consensus.deletion.DeletionResource; import org.apache.iotdb.db.pipe.consensus.deletion.DeletionResourceManager; import org.apache.iotdb.db.pipe.consensus.deletion.recover.DeletionReader; import org.apache.iotdb.db.queryengine.plan.planner.plan.node.write.DeleteDataNode; +import ch.qos.logback.classic.Level; +import ch.qos.logback.classic.Logger; +import ch.qos.logback.classic.spi.ILoggingEvent; +import ch.qos.logback.core.Appender; import org.awaitility.Awaitility; import org.junit.After; import org.junit.Assert; @@ -37,6 +42,7 @@ import org.junit.Test; import org.junit.rules.TemporaryFolder; import org.mockito.InOrder; +import org.slf4j.LoggerFactory; import java.io.File; import java.io.IOException; @@ -45,11 +51,16 @@ import java.nio.channels.FileChannel; import java.util.Collections; import java.util.List; +import java.util.concurrent.BlockingQueue; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicReference; +import static org.mockito.AdditionalAnswers.delegatesTo; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.Mockito.atLeastOnce; import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doThrow; @@ -75,6 +86,70 @@ public void tearDown() { PageCacheDeletionBuffer.setDalBufferSize(previousDalBufferSize); } + @Test + public void testIdleCloseDoesNotWarnAboutQueueInterruption() throws Exception { + assertQueueInterruptionLogging(true); + } + + @Test + public void testUnexpectedQueueInterruptionStillWarns() throws Exception { + assertQueueInterruptionLogging(false); + } + + @SuppressWarnings("unchecked") + private void assertQueueInterruptionLogging(boolean closeNormally) throws Exception { + final PageCacheDeletionBuffer deletionBuffer = + new PageCacheDeletionBuffer(1, temporaryFolder.newFolder("interrupt").getAbsolutePath()); + final CountDownLatch taking = new CountDownLatch(1); + final AtomicReference worker = new AtomicReference<>(); + final Field queueField = PageCacheDeletionBuffer.class.getDeclaredField("deletionResources"); + queueField.setAccessible(true); + final BlockingQueue originalQueue = + (BlockingQueue) queueField.get(deletionBuffer); + final BlockingQueue queue = + mock(BlockingQueue.class, delegatesTo(originalQueue)); + doAnswer( + invocation -> { + worker.set(Thread.currentThread()); + taking.countDown(); + return originalQueue.take(); + }) + .when(queue) + .take(); + queueField.set(deletionBuffer, queue); + final Logger logger = (Logger) LoggerFactory.getLogger(PageCacheDeletionBuffer.class); + final Appender appender = mock(Appender.class); + logger.addAppender(appender); + deletionBuffer.start(); + try { + Assert.assertTrue(taking.await(10, TimeUnit.SECONDS)); + if (!closeNormally) { + worker.get().interrupt(); + Awaitility.await() + .atMost(10, TimeUnit.SECONDS) + .untilAsserted( + () -> + verify(appender, atLeastOnce()) + .doAppend(argThat(this::isQueueInterruptionWarning))); + } + } finally { + try { + deletionBuffer.close(); + if (closeNormally) { + verify(appender, never()).doAppend(argThat(this::isQueueInterruptionWarning)); + } + } finally { + logger.detachAppender(appender); + } + } + } + + private boolean isQueueInterruptionWarning(ILoggingEvent event) { + return event.getLevel() == Level.WARN + && DataNodePipeMessages.INTERRUPTED_WHEN_WAITING_FOR_TAKING_DELETIONRESOURCE_FROM.equals( + event.getMessage()); + } + @Test public void testDequeuedDeletionIsNotReportedAsFlushed() throws Exception { final CountDownLatch serializationStarted = new CountDownLatch(1);