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)) {

Reply via email to