add test & synchronized

Signed-off-by: OneSizeFitsQuorum <[email protected]>

Author: OneSizeFitsQuorum

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/wal/allocation/AbstractNodeAllocationStrategy.java

@@ -34,40 +34,36 @@
 import java.io.File;
 import java.io.IOException;
 import java.util.Arrays;
-import java.util.concurrent.atomic.AtomicReference;
 
 public abstract class AbstractNodeAllocationStrategy implements NodeAllocationStrategy {
   private static final Logger logger =
       LoggerFactory.getLogger(AbstractNodeAllocationStrategy.class);
   private static final CommonConfig commonConfig = CommonDescriptor.getInstance().getConfig();
 
   // manage wal folders
-  protected AtomicReference<FolderManager> folderManager = new AtomicReference<>();
+  protected FolderManager folderManager;
 
   protected AbstractNodeAllocationStrategy() {
     try {
-      folderManager.set(
+      folderManager =
           new FolderManager(
-              Arrays.asList(commonConfig.getWalDirs()), DirectoryStrategyType.SEQUENCE_STRATEGY));
+              Arrays.asList(commonConfig.getWalDirs()), DirectoryStrategyType.SEQUENCE_STRATEGY);
     } catch (DiskSpaceInsufficientException e) {
       logger.error(
           "Fail to create wal node allocation strategy because all disks of wal folders are full.",
           e);
     }
   }
 
-  protected IWALNode createWALNode(String identifier) {
+  protected synchronized IWALNode createWALNode(String identifier) {
     try {
-      // already in lock, so no need to synchronized
-      if (folderManager.get() == null) {
-        folderManager.set(
+      if (folderManager == null) {
+        folderManager =
             new FolderManager(
-                Arrays.asList(commonConfig.getWalDirs()), DirectoryStrategyType.SEQUENCE_STRATEGY));
+                Arrays.asList(commonConfig.getWalDirs()), DirectoryStrategyType.SEQUENCE_STRATEGY);
       }
-      return folderManager
-          .get()
-          .getNextWithRetry(
-              folder -> new WALNode(identifier, folder + File.separator + identifier));
+      return folderManager.getNextWithRetry(
+          folder -> new WALNode(identifier, folder + File.separator + identifier));
     } catch (DiskSpaceInsufficientException e) {
       logger.error("Fail to create wal node because all disks of wal folders are full.", e);
       return WALFakeNode.getFailureInstance(e);
@@ -79,15 +75,6 @@ protected IWALNode createWALNode(String identifier) {
     }
   }
 
-  protected IWALNode createWALNode(String identifier, String folder) {
-    try {
-      return new WALNode(identifier, folder);
-    } catch (IOException e) {
-      logger.error("Meet exception when creating wal node", e);
-      return WALFakeNode.getFailureInstance(e);
-    }
-  }
-
   protected IWALNode createWALNode(
       String identifier, String folder, long startFileVersion, long startSearchIndex) {
     try {

iotdb-core/datanode/src/test/java/org/apache/iotdb/db/storageengine/dataregion/wal/allocation/FirstCreateStrategyTest.java

@@ -38,6 +38,7 @@
 import org.junit.Test;
 
 import java.io.File;
+import java.io.IOException;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotEquals;
@@ -141,6 +142,79 @@ public void testRegisterWALNode() throws IllegalPathException {
     }
   }
 
+  @Test
+  public void testReInitializeAfterDiskSpaceCleaned() throws IllegalPathException, IOException {
+    // Create temporary directories for testing
+    File tempDir = new File(System.getProperty("java.io.tmpdir"), "iotdb_wal_reinit_test");
+    tempDir.mkdirs();
+
+    String[] walDirs =
+        new String[] {
+          new File(tempDir, "wal_reinit_test1").getAbsolutePath(),
+          new File(tempDir, "wal_reinit_test2").getAbsolutePath(),
+          new File(tempDir, "wal_reinit_test3").getAbsolutePath()
+        };
+
+    String[] originalWalDirs = commonConfig.getWalDirs();
+    commonConfig.setWalDirs(walDirs);
+
+    try {
+      // Create strategy with valid directories first
+      FirstCreateStrategy strategy = new FirstCreateStrategy();
+
+      // Simulate folderManager becoming null (e.g., due to disk space issues)
+      // We'll use reflection to set folderManager to null to test re-initialization
+      try {
+        java.lang.reflect.Field folderManagerField =
+            AbstractNodeAllocationStrategy.class.getDeclaredField("folderManager");
+        folderManagerField.setAccessible(true);
+        folderManagerField.set(strategy, null);
+      } catch (NoSuchFieldException | IllegalAccessException e) {
+        throw new RuntimeException("Failed to set folderManager to null for testing", e);
+      }
+
+      // Now apply for WAL node, should successfully re-initialize folderManager
+      IWALNode walNode = strategy.applyForWALNode("test_reinit_identifier");
+      assertNotNull("WAL node should be created after re-initialization", walNode);
+
+      // Verify that WAL node was created successfully by logging data
+      walNode.log(1, getInsertRowNode());
+
+      // Verify that WAL files were created in at least one directory
+      boolean walFileCreated = false;
+      for (String walDir : walDirs) {
+        File walDirFile = new File(walDir);
+        if (walDirFile.exists()) {
+          File[] nodeDirs = walDirFile.listFiles(File::isDirectory);
+          if (nodeDirs != null && nodeDirs.length > 0) {
+            for (File nodeDir : nodeDirs) {
+              if (nodeDir.exists() && WALFileUtils.listAllWALFiles(nodeDir).length > 0) {
+                walFileCreated = true;
+                break;
+              }
+            }
+          }
+        }
+        if (walFileCreated) {
+          break;
+        }
+      }
+      assertTrue("WAL files should be created after re-initialization", walFileCreated);
+
+      // Clean up
+      walNode.close();
+    } finally {
+      // Clean up the test directories
+      for (String walDir : walDirs) {
+        EnvironmentUtils.cleanDir(walDir);
+      }
+      // Clean up temp directory
+      EnvironmentUtils.cleanDir(tempDir.getAbsolutePath());
+      // Restore original WAL directories
+      commonConfig.setWalDirs(originalWalDirs);
+    }
+  }
+
   private InsertRowNode getInsertRowNode() throws IllegalPathException {
     long time = 110L;
     TSDataType[] dataTypes =