This is an automated email from the ASF dual-hosted git repository.
CRZbulabula pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/master by this push:
new 4b447ff5c0b Reset DiskFull protection after successful configuration
reloads (#19151)
4b447ff5c0b is described below
commit 4b447ff5c0bd8a2a7938e1964fb8ff034b53e6e9
Author: d-wang-commit <[email protected]>
AuthorDate: Thu Nov 5 22:46:51 2026 +0800
Reset DiskFull protection after successful configuration reloads (#19151)
Restore Running only when a successful reload starts and ends in
ReadOnly(DiskFull). Let subsequent directory selection register current
failures, and remove reload-specific tracking of tier folder managers.
---
.../org/apache/iotdb/db/conf/IoTDBDescriptor.java | 4 +
.../iotdb/db/storageengine/StorageEngine.java | 6 +
.../tsfile/generator/TsFileNameGenerator.java | 2 +-
.../db/storageengine/rescon/disk/TierManager.java | 196 ++++++++-------------
.../iotdb/db/conf/DiskFullHotReloadTest.java | 148 ++++++++++++++++
.../apache/iotdb/commons/conf/CommonConfig.java | 23 ++-
.../apache/iotdb/commons/disk/FolderManager.java | 26 +--
.../commons/disk/strategy/DirectoryStrategy.java | 22 +--
8 files changed, 253 insertions(+), 174 deletions(-)
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java
index 04fe3381b75..08db154326b 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java
@@ -2517,6 +2517,7 @@ public class IoTDBDescriptor {
return;
}
+ boolean wasReadOnlyForDiskFull = commonConfig.isReadOnlyForDiskFull();
TrimProperties commonProperties = new TrimProperties();
try (InputStream inputStream = url.openStream()) {
LOGGER.info(DataNodeMiscMessages.START_RELOAD_CONFIG_FILE, url);
@@ -2534,6 +2535,9 @@ public class IoTDBDescriptor {
ConfigurationFileUtils.releaseDefault();
}
reloadMetricProperties(commonProperties);
+ if (wasReadOnlyForDiskFull) {
+ commonConfig.setRunningIfDiskFull();
+ }
}
public void reloadMetricProperties(TrimProperties properties) {
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/StorageEngine.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/StorageEngine.java
index 6c128c027a4..505ac60a26c 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/StorageEngine.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/StorageEngine.java
@@ -815,6 +815,8 @@ public class StorageEngine implements IService {
return tsStatus;
}
+ CommonConfig commonConfig = CommonDescriptor.getInstance().getConfig();
+ boolean wasReadOnlyForDiskFull = commonConfig.isReadOnlyForDiskFull();
try {
ConfigurationFileUtils.updateConfiguration(
new File(configFileUrl.getFile()),
@@ -832,6 +834,10 @@ public class StorageEngine implements IService {
}
return RpcUtils.getStatus(TSStatusCode.EXECUTE_STATEMENT_ERROR,
e.getMessage());
}
+ // A SET can apply in memory and still fail when persisting the
configuration file.
+ if (wasReadOnlyForDiskFull) {
+ commonConfig.setRunningIfDiskFull();
+ }
return tsStatus;
}
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/tsfile/generator/TsFileNameGenerator.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/tsfile/generator/TsFileNameGenerator.java
index b64f3436c7f..29c27ee7978 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/tsfile/generator/TsFileNameGenerator.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/tsfile/generator/TsFileNameGenerator.java
@@ -96,8 +96,8 @@ public class TsFileNameGenerator {
int tierLevel,
String customSuffix)
throws DiskSpaceInsufficientException, IOException {
+ FolderManager folderManager =
TierManager.getInstance().getFolderManager(tierLevel, sequence);
try {
- FolderManager folderManager =
TierManager.getInstance().getFolderManager(tierLevel, sequence);
return folderManager.getNextWithRetry(
baseDir -> {
String tsFileDir =
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/rescon/disk/TierManager.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/rescon/disk/TierManager.java
index b8f3134817c..59bc5877979 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/rescon/disk/TierManager.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/rescon/disk/TierManager.java
@@ -23,7 +23,6 @@ import org.apache.iotdb.commons.conf.IoTDBConstant;
import org.apache.iotdb.commons.disk.FolderManager;
import org.apache.iotdb.commons.disk.strategy.DirectoryStrategyType;
import org.apache.iotdb.commons.exception.DiskSpaceInsufficientException;
-import org.apache.iotdb.commons.utils.JVMCommonUtils;
import org.apache.iotdb.db.conf.IoTDBConfig;
import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.i18n.StorageEngineMessages;
@@ -59,12 +58,20 @@ import java.util.stream.Collectors;
public class TierManager {
private static final Logger logger =
LoggerFactory.getLogger(TierManager.class);
private static final IoTDBConfig config =
IoTDBDescriptor.getInstance().getConfig();
+ private DirectoryStrategyType directoryStrategyType =
DirectoryStrategyType.SEQUENCE_STRATEGY;
- private record TierDirectory(int tierLevel, String folderName) {}
+ /**
+ * seq folder manager of each storage tier, managing both data directories
and multi-dir strategy
+ */
+ private volatile List<FolderManager> seqTiers = new ArrayList<>();
- private volatile Map<TierDirectory, TierFolderManager> folderManagers =
Map.of();
- // A failed constructor can report DiskFull before the replacement managers
are published.
- private volatile boolean rebuildingFolders;
+ /**
+ * unSeq folder manager of each storage tier, managing both data directories
and multi-dir
+ * strategy
+ */
+ private volatile List<FolderManager> unSeqTiers = new ArrayList<>();
+
+ private volatile List<FolderManager> objectTiers = new ArrayList<>();
/** seq file folder's rawFsPath path -> tier level */
private volatile Map<String, Integer> seqDir2TierLevel = new HashMap<>();
@@ -74,27 +81,31 @@ public class TierManager {
private List<String> objectDirs;
+ private List<String> copyToTargetDirs;
+
+ // private FolderManager copyToFolderManager;
+
+ private MemoizedCheckedSupplier<FolderManager,
DiskSpaceInsufficientException>
+ copyToFolderManager;
+
/** total space of each tier, Long.MAX_VALUE when one tier contains remote
storage */
- private volatile long[] tierDiskTotalSpace = new long[0];
+ private long[] tierDiskTotalSpace;
private TierManager() {
initFolders();
}
public synchronized void initFolders() {
- rebuildingFolders = true;
- try {
- rebuildFolders();
- } finally {
- rebuildingFolders = false;
- }
+ initFolders(seqTiers, unSeqTiers, objectTiers, seqDir2TierLevel,
unSeqDir2TierLevel);
}
- private void rebuildFolders() {
- Map<TierDirectory, TierFolderManager> newManagers = new HashMap<>();
- Map<String, Integer> newSeqDir2TierLevel = new HashMap<>();
- Map<String, Integer> newUnSeqDir2TierLevel = new HashMap<>();
- DirectoryStrategyType directoryStrategyType =
+ private void initFolders(
+ List<FolderManager> seqTiers,
+ List<FolderManager> unSeqTiers,
+ List<FolderManager> objectTiers,
+ Map<String, Integer> seqDir2TierLevel,
+ Map<String, Integer> unSeqDir2TierLevel) {
+ directoryStrategyType =
DirectoryStrategyType.fromClassName(config.getMultiDirStrategyClassName());
config.updatePath();
@@ -129,14 +140,13 @@ public class TierManager {
.getPath())
.collect(Collectors.toList());
mkDataDirs(seqDirs);
- addFolderManager(
- newManagers,
- tierLevel,
- IoTDBConstant.SEQUENCE_FOLDER_NAME,
- seqDirs,
- directoryStrategyType);
+ try {
+ seqTiers.add(new FolderManager(seqDirs, directoryStrategyType));
+ } catch (DiskSpaceInsufficientException e) {
+ logger.error(StorageEngineMessages.ALL_DISKS_OF_TIER_FULL, tierLevel,
e);
+ }
for (String dir : seqDirs) {
- newSeqDir2TierLevel.put(dir, tierLevel);
+ seqDir2TierLevel.put(dir, tierLevel);
}
List<String> unSeqDirs =
@@ -149,18 +159,17 @@ public class TierManager {
.getPath())
.collect(Collectors.toList());
mkDataDirs(unSeqDirs);
- addFolderManager(
- newManagers,
- tierLevel,
- IoTDBConstant.UNSEQUENCE_FOLDER_NAME,
- unSeqDirs,
- directoryStrategyType);
+ try {
+ unSeqTiers.add(new FolderManager(unSeqDirs, directoryStrategyType));
+ } catch (DiskSpaceInsufficientException e) {
+ logger.error(StorageEngineMessages.ALL_DISKS_OF_TIER_FULL, tierLevel,
e);
+ }
for (String dir : unSeqDirs) {
- newUnSeqDir2TierLevel.put(dir, tierLevel);
+ unSeqDir2TierLevel.put(dir, tierLevel);
}
if (tierLevel == 0) {
- List<String> copyToTargetDirs =
+ copyToTargetDirs =
Arrays.stream(tierDirs[tierLevel])
.filter(Objects::nonNull)
.map(
@@ -169,12 +178,9 @@ public class TierManager {
.getFile(v,
IoTDBConstant.COPY_TO_TARGET_FOLDER_NAME)
.getPath())
.collect(Collectors.toList());
- addFolderManager(
- newManagers,
- tierLevel,
- IoTDBConstant.COPY_TO_TARGET_FOLDER_NAME,
- copyToTargetDirs,
- directoryStrategyType);
+ copyToFolderManager =
+ MemoizedCheckedSupplier.valueOf(
+ () -> new FolderManager(copyToTargetDirs,
directoryStrategyType));
}
objectDirs =
@@ -187,12 +193,11 @@ public class TierManager {
.getPath())
.collect(Collectors.toList());
- addFolderManager(
- newManagers,
- tierLevel,
- IoTDBConstant.OBJECT_FOLDER_NAME,
- objectDirs,
- directoryStrategyType);
+ try {
+ objectTiers.add(new FolderManager(objectDirs, directoryStrategyType));
+ } catch (DiskSpaceInsufficientException e) {
+ logger.error(StorageEngineMessages.ALL_DISKS_OF_TIER_FULL, tierLevel,
e);
+ }
// try to remove empty objectDirs
for (String dir : objectDirs) {
File dirFile = FSFactoryProducer.getFSFactory().getFile(dir);
@@ -206,74 +211,23 @@ public class TierManager {
}
tierDiskTotalSpace = getTierDiskSpace(DiskSpaceType.TOTAL);
- seqDir2TierLevel = newSeqDir2TierLevel;
- unSeqDir2TierLevel = newUnSeqDir2TierLevel;
- folderManagers = newManagers;
- }
-
- private void addFolderManager(
- Map<TierDirectory, TierFolderManager> newManagers,
- int tierLevel,
- String folderName,
- List<String> folders,
- DirectoryStrategyType type) {
- TierDirectory key = new TierDirectory(tierLevel, folderName);
- TierFolderManager entry = new TierFolderManager(key, folders, type);
- newManagers.put(key, entry);
- if (!IoTDBConstant.COPY_TO_TARGET_FOLDER_NAME.equals(folderName)) {
- try {
- entry.supplier.get();
- } catch (DiskSpaceInsufficientException e) {
- logger.error(StorageEngineMessages.ALL_DISKS_OF_TIER_FULL, tierLevel,
e);
- }
- }
- }
-
- private final class TierFolderManager {
- private final List<String> folders;
- private final MemoizedCheckedSupplier<FolderManager,
DiskSpaceInsufficientException> supplier;
- private volatile FolderManager manager;
-
- private TierFolderManager(TierDirectory key, List<String> folders,
DirectoryStrategyType type) {
- this.folders = folders;
- supplier =
- MemoizedCheckedSupplier.valueOf(
- () -> {
- manager = new FolderManager(folders, type, () ->
reportDiskFull(key, this));
- return manager;
- });
- }
-
- private boolean hasSpaceForRecovery() {
- FolderManager current = manager;
- return current == null
- ? folders.stream().anyMatch(JVMCommonUtils::hasSpaceWithoutRetry)
- : current.hasSpaceForRecovery();
- }
- }
-
- private void reportDiskFull(TierDirectory key, TierFolderManager source) {
- if (!rebuildingFolders && folderManagers.get(key) != source) {
- return;
- }
- CommonDescriptor.getInstance()
- .getConfig()
- .setReadOnlyForDiskFull(key, () -> hasSpaceForRecovery(key));
- }
-
- private boolean hasSpaceForRecovery(TierDirectory key) {
- Map<TierDirectory, TierFolderManager> active = folderManagers;
- if (rebuildingFolders) {
- return false;
- }
- TierFolderManager current = active.get(key);
- boolean recovered = current == null || current.hasSpaceForRecovery();
- return recovered && active == folderManagers && !rebuildingFolders;
}
public synchronized void resetFolders() {
long startTime = System.currentTimeMillis();
- initFolders();
+ List<FolderManager> newSeqTiers = new ArrayList<>();
+ List<FolderManager> newUnSeqTiers = new ArrayList<>();
+ List<FolderManager> newObjectTiers = new ArrayList<>();
+ Map<String, Integer> newSeqDir2TierLevel = new HashMap<>();
+ Map<String, Integer> newUnSeqDir2TierLevel = new HashMap<>();
+
+ initFolders(
+ newSeqTiers, newUnSeqTiers, newObjectTiers, newSeqDir2TierLevel,
newUnSeqDir2TierLevel);
+ seqTiers = newSeqTiers;
+ unSeqTiers = newUnSeqTiers;
+ objectTiers = newObjectTiers;
+ seqDir2TierLevel = newSeqDir2TierLevel;
+ unSeqDir2TierLevel = newUnSeqDir2TierLevel;
long endTime = System.currentTimeMillis();
logger.info(StorageEngineMessages.FOLDERS_RESET_SUCCESSFULLY, (endTime -
startTime));
}
@@ -297,31 +251,21 @@ public class TierManager {
public String getNextFolderForTsFile(int tierLevel, boolean sequence)
throws DiskSpaceInsufficientException {
- return getFolderManager(tierLevel, sequence).getNextFolder();
+ return sequence
+ ? seqTiers.get(tierLevel).getNextFolder()
+ : unSeqTiers.get(tierLevel).getNextFolder();
}
public String getNextFolderForCopyToTargetFile() throws
DiskSpaceInsufficientException {
- return getFolderManager(0,
IoTDBConstant.COPY_TO_TARGET_FOLDER_NAME).getNextFolder();
+ return copyToFolderManager.get().getNextFolder();
}
public String getNextFolderForObjectFile() throws
DiskSpaceInsufficientException {
- return getFolderManager(0,
IoTDBConstant.OBJECT_FOLDER_NAME).getNextFolder();
- }
-
- public FolderManager getFolderManager(int tierLevel, boolean sequence)
- throws DiskSpaceInsufficientException {
- String folderName =
- sequence ? IoTDBConstant.SEQUENCE_FOLDER_NAME :
IoTDBConstant.UNSEQUENCE_FOLDER_NAME;
- return getFolderManager(tierLevel, folderName);
+ return objectTiers.get(0).getNextFolder();
}
- private FolderManager getFolderManager(int tierLevel, String folderName)
- throws DiskSpaceInsufficientException {
- TierFolderManager entry = folderManagers.get(new TierDirectory(tierLevel,
folderName));
- if (entry == null) {
- throw new IndexOutOfBoundsException(tierLevel);
- }
- return entry.supplier.get();
+ public FolderManager getFolderManager(int tierLevel, boolean sequence) {
+ return sequence ? seqTiers.get(tierLevel) : unSeqTiers.get(tierLevel);
}
public List<String> getAllFilesFolders() {
@@ -412,7 +356,7 @@ public class TierManager {
}
public int getTiersNum() {
- return tierDiskTotalSpace.length;
+ return seqTiers.size();
}
public int getFileTierLevel(File file) {
diff --git
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/conf/DiskFullHotReloadTest.java
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/conf/DiskFullHotReloadTest.java
new file mode 100644
index 00000000000..38e1a44d551
--- /dev/null
+++
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/conf/DiskFullHotReloadTest.java
@@ -0,0 +1,148 @@
+/*
+ * 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.conf;
+
+import org.apache.iotdb.common.rpc.thrift.TSetConfigurationReq;
+import org.apache.iotdb.commons.cluster.NodeStatus;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
+import org.apache.iotdb.commons.conf.IoTDBConstant;
+import org.apache.iotdb.db.storageengine.StorageEngine;
+import org.apache.iotdb.rpc.TSStatusCode;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+
+public class DiskFullHotReloadTest {
+
+ @Rule public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+ private final IoTDBDescriptor descriptor = IoTDBDescriptor.getInstance();
+ private final CommonConfig config =
CommonDescriptor.getInstance().getConfig();
+ private final String originalConf =
System.getProperty(IoTDBConstant.IOTDB_CONF);
+ private final NodeStatus originalStatus = config.getNodeStatus();
+ private final String originalReason = config.getStatusReason();
+ private final boolean originalPartialInsert =
descriptor.getConfig().isEnablePartialInsert();
+ private Path configFile;
+
+ @Before
+ public void setUp() throws IOException {
+ configFile =
temporaryFolder.newFile(CommonConfig.SYSTEM_CONFIG_NAME).toPath();
+ System.setProperty(IoTDBConstant.IOTDB_CONF,
configFile.getParent().toString());
+ config.setNodeStatus(NodeStatus.Running);
+ }
+
+ @After
+ public void tearDown() {
+ if (originalConf == null) {
+ System.clearProperty(IoTDBConstant.IOTDB_CONF);
+ } else {
+ System.setProperty(IoTDBConstant.IOTDB_CONF, originalConf);
+ }
+ descriptor.getConfig().setEnablePartialInsert(originalPartialInsert);
+ config.setNodeStatus(NodeStatus.Running);
+ config.setNodeStatusWithReason(originalStatus, originalReason);
+ }
+
+ @Test
+ public void loadSameConfigurationClearsOldDiskFullChecks() throws Exception {
+ config.setReadOnlyForDiskFull("old directory", () -> false);
+ descriptor.loadHotModifiedProps();
+ assertRecoveredAndCleared();
+ }
+
+ @Test
+ public void setUnrelatedPropertyClearsOldDiskFullChecks() {
+ config.setReadOnlyForDiskFull("old directory", () -> false);
+ Map<String, String> update =
+ Map.of("enable_partial_insert",
Boolean.toString(!originalPartialInsert));
+ assertEquals(TSStatusCode.SUCCESS_STATUS.getStatusCode(),
setConfiguration(update));
+ assertEquals(!originalPartialInsert,
descriptor.getConfig().isEnablePartialInsert());
+ assertRecoveredAndCleared();
+ }
+
+ @Test
+ public void unsuccessfulAndEmptyReloadsKeepDiskFull() throws IOException {
+ config.setReadOnlyForDiskFull("old directory", () -> false);
+ assertEquals(
+ TSStatusCode.SUCCESS_STATUS.getStatusCode(),
setConfiguration(Collections.emptyMap()));
+ assertReadOnly(NodeStatus.DISK_FULL);
+
+ // The regular properties have loaded when the metrics phase rejects this
value.
+ Files.writeString(configFile, "dn_metric_level=INVALID\n");
+ assertThrows(IllegalArgumentException.class,
descriptor::loadHotModifiedProps);
+ assertReadOnly(NodeStatus.DISK_FULL);
+
+ // SET can apply properties in memory and still return an error if the
file is missing.
+ Files.delete(configFile);
+ assertEquals(
+ TSStatusCode.EXECUTE_STATEMENT_ERROR.getStatusCode(),
+ setConfiguration(Map.of("enable_partial_insert",
Boolean.toString(originalPartialInsert))));
+ assertReadOnly(NodeStatus.DISK_FULL);
+ }
+
+ @Test
+ public void successfulReloadsKeepOtherReadOnlyReasons() throws Exception {
+ config.setNodeStatusWithReason(NodeStatus.ReadOnly, NodeStatus.MANUAL);
+ descriptor.loadHotModifiedProps();
+ assertReadOnly(NodeStatus.MANUAL);
+
+ config.setNodeStatus(NodeStatus.Running);
+ String reason = NodeStatus.UNRECOVERABLE_ERROR + ", I/O error";
+ config.setNodeStatusWithReason(NodeStatus.ReadOnly, reason);
+ assertEquals(
+ TSStatusCode.SUCCESS_STATUS.getStatusCode(),
+ setConfiguration(Map.of("enable_partial_insert",
Boolean.toString(originalPartialInsert))));
+ assertReadOnly(reason);
+ }
+
+ private int setConfiguration(Map<String, String> items) {
+ return StorageEngine.getInstance()
+ .setConfiguration(new TSetConfigurationReq(items, 0))
+ .getCode();
+ }
+
+ private void assertRecoveredAndCleared() {
+ assertEquals(NodeStatus.Running, config.getNodeStatus());
+ assertNull(config.getStatusReason());
+ // A later aggregate-only failure must have no callback left from the
previous failure.
+ config.setNodeStatusWithReason(NodeStatus.ReadOnly, NodeStatus.DISK_FULL);
+ config.tryRecoverFromDiskFull();
+ assertEquals(NodeStatus.Running, config.getNodeStatus());
+ assertNull(config.getStatusReason());
+ }
+
+ private void assertReadOnly(String reason) {
+ assertEquals(NodeStatus.ReadOnly, config.getNodeStatus());
+ assertEquals(reason, config.getStatusReason());
+ }
+}
diff --git
a/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/conf/CommonConfig.java
b/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/conf/CommonConfig.java
index dc5b6a1e8db..f3ba8c27b10 100644
---
a/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/conf/CommonConfig.java
+++
b/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/conf/CommonConfig.java
@@ -853,24 +853,29 @@ public class CommonConfig {
setNodeStatusWithReason(NodeStatus.ReadOnly, NodeStatus.DISK_FULL);
}
+ public synchronized boolean isReadOnlyForDiskFull() {
+ return status == NodeStatus.ReadOnly &&
NodeStatus.DISK_FULL.equals(statusReason);
+ }
+
+ /** Recheck the reason under the status lock before clearing disk-full
recovery checks. */
+ public synchronized void setRunningIfDiskFull() {
+ if (isReadOnlyForDiskFull()) {
+ setNodeStatus(NodeStatus.Running);
+ }
+ }
+
/** Called after the aggregate disk-space check passes. */
public void tryRecoverFromDiskFull() {
final List<BooleanSupplier> recoveryChecks;
synchronized (this) {
- if (status != NodeStatus.ReadOnly ||
!NodeStatus.DISK_FULL.equals(statusReason)) {
+ if (!isReadOnlyForDiskFull()) {
return;
}
recoveryChecks = new ArrayList<>(diskFullRecoveryChecks.values());
}
// Do not hold the status monitor during filesystem I/O.
- if (!recoveryChecks.stream().allMatch(BooleanSupplier::getAsBoolean)) {
- return;
- }
- synchronized (this) {
- // A concurrent Manual/Stopping/error transition must not be cleared by
disk recovery.
- if (status == NodeStatus.ReadOnly &&
NodeStatus.DISK_FULL.equals(statusReason)) {
- setNodeStatus(NodeStatus.Running);
- }
+ if (recoveryChecks.stream().allMatch(BooleanSupplier::getAsBoolean)) {
+ setRunningIfDiskFull();
}
}
diff --git
a/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/disk/FolderManager.java
b/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/disk/FolderManager.java
index 4dee48cc47c..1cb969043e9 100644
---
a/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/disk/FolderManager.java
+++
b/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/disk/FolderManager.java
@@ -19,6 +19,7 @@
package org.apache.iotdb.commons.disk;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
import org.apache.iotdb.commons.disk.strategy.DirectoryStrategy;
import org.apache.iotdb.commons.disk.strategy.DirectoryStrategyType;
import org.apache.iotdb.commons.disk.strategy.MaxDiskUsableSpaceFirstStrategy;
@@ -74,21 +75,6 @@ public class FolderManager {
public FolderManager(
List<String> folders, DirectoryStrategyType type, boolean
changeSystemStatusToReadOnly)
throws DiskSpaceInsufficientException {
- this(folders, type, changeSystemStatusToReadOnly, null);
- }
-
- /** For an owner that replaces this manager on configuration reload. */
- public FolderManager(List<String> folders, DirectoryStrategyType type,
Runnable diskFullHandler)
- throws DiskSpaceInsufficientException {
- this(folders, type, true, diskFullHandler);
- }
-
- private FolderManager(
- List<String> folders,
- DirectoryStrategyType type,
- boolean changeSystemStatusToReadOnly,
- Runnable diskFullHandler)
- throws DiskSpaceInsufficientException {
this.folders = folders;
this.changeSystemStatusToReadOnly = changeSystemStatusToReadOnly;
folders.forEach(dir -> foldersStates.put(dir, FolderState.HEALTHY));
@@ -109,7 +95,6 @@ public class FolderManager {
throw new RuntimeException();
}
this.selectStrategy.setChangeSystemStatusToReadOnly(changeSystemStatusToReadOnly);
- this.selectStrategy.setDiskFullHandler(diskFullHandler);
this.selectStrategy.setFolders(folders);
this.selectStrategy.setFoldersStates(foldersStates);
}
@@ -143,10 +128,6 @@ public class FolderManager {
&& hasSpace.test(folder));
}
- public boolean hasSpaceForRecovery() {
- return
hasFolderWithAvailableDiskSpace(JVMCommonUtils::hasSpaceWithoutRetry);
- }
-
private void changeToReadOnlyIfDiskFull(DiskSpaceInsufficientException e) {
if (!changeSystemStatusToReadOnly) {
return;
@@ -156,7 +137,10 @@ public class FolderManager {
if
(LoggerPeriodicalLogReducer.shouldLog(UtilMessages.ALL_FOLDERS_FULL_CHANGE_TO_READ_ONLY))
{
logger.error(UtilMessages.ALL_FOLDERS_FULL_CHANGE_TO_READ_ONLY, e);
}
- selectStrategy.reportDiskFull(this, this::hasSpaceForRecovery);
+ CommonDescriptor.getInstance()
+ .getConfig()
+ .setReadOnlyForDiskFull(
+ this, () ->
hasFolderWithAvailableDiskSpace(JVMCommonUtils::hasSpaceWithoutRetry));
} else {
logger.warn(UtilMessages.CANNOT_SELECT_FOLDER_BUT_DISK_HAS_SPACE, e);
}
diff --git
a/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/disk/strategy/DirectoryStrategy.java
b/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/disk/strategy/DirectoryStrategy.java
index 4e1072d07d4..a592766ec78 100644
---
a/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/disk/strategy/DirectoryStrategy.java
+++
b/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/disk/strategy/DirectoryStrategy.java
@@ -32,7 +32,6 @@ import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.function.BooleanSupplier;
import static org.apache.iotdb.commons.disk.FolderManager.FolderState.HEALTHY;
@@ -49,20 +48,6 @@ public abstract class DirectoryStrategy {
private boolean changeSystemStatusToReadOnly = true;
- private Runnable diskFullHandler;
-
- public void setDiskFullHandler(Runnable diskFullHandler) {
- this.diskFullHandler = diskFullHandler;
- }
-
- public void reportDiskFull(Object source, BooleanSupplier recoveryCheck) {
- if (diskFullHandler != null) {
- diskFullHandler.run();
- } else {
-
CommonDescriptor.getInstance().getConfig().setReadOnlyForDiskFull(source,
recoveryCheck);
- }
- }
-
public void setChangeSystemStatusToReadOnly(boolean
changeSystemStatusToReadOnly) {
this.changeSystemStatusToReadOnly = changeSystemStatusToReadOnly;
}
@@ -85,8 +70,11 @@ public abstract class DirectoryStrategy {
if (changeSystemStatusToReadOnly) {
LOGGER.error(UtilMessages.DISK_SPACE_INSUFFICIENT_READ_ONLY);
final List<String> fullFolders = List.copyOf(folders);
- reportDiskFull(
- fullFolders, () ->
fullFolders.stream().anyMatch(JVMCommonUtils::hasSpaceWithoutRetry));
+ CommonDescriptor.getInstance()
+ .getConfig()
+ .setReadOnlyForDiskFull(
+ fullFolders,
+ () ->
fullFolders.stream().anyMatch(JVMCommonUtils::hasSpaceWithoutRetry));
} else {
if (LoggerPeriodicalLogReducer.shouldLog(
UtilMessages.MESSAGE_DISK_SPACE_INSUFFICIENT_DF6205B0)) {