Refactor snapshot object path handling with Path APIs.

This change replaces string-based path parsing with Java Path operations for object snapshot logging, link creation, and log validation to improve cross-platform correctness and maintainability.

Made-with: Cursor

Author: luoluoyuyu

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/snapshot/SnapshotFileSet.java

@@ -22,6 +22,7 @@
 import org.apache.iotdb.db.storageengine.dataregion.modification.ModificationFile;
 import org.apache.iotdb.db.storageengine.dataregion.modification.v1.ModificationFileV1;
 import org.apache.iotdb.db.storageengine.dataregion.tsfile.TsFileResource;
+import org.apache.iotdb.db.utils.ObjectTypeUtils;
 
 import org.apache.tsfile.common.constant.TsFileConstant;
 
@@ -37,6 +38,9 @@ public class SnapshotFileSet {
         TsFileResource.RESOURCE_SUFFIX.replace(".", ""),
         ModificationFileV1.FILE_SUFFIX.replace(".", ""),
         ModificationFile.FILE_SUFFIX.replace(".", ""),
+        ObjectTypeUtils.OBJECT_FILE_SUFFIX.replace(".", ""),
+        ObjectTypeUtils.OBJECT_TEMP_FILE_SUFFIX.replace(".", ""),
+        ObjectTypeUtils.OBJECT_BACK_FILE_SUFFIX.replace(".", ""),
       };
 
   private static final Set<String> DATA_FILE_SUFFIX_SET =

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/snapshot/SnapshotLoader.java

@@ -26,7 +26,9 @@
 import org.apache.iotdb.db.storageengine.dataregion.DataRegion;
 import org.apache.iotdb.db.storageengine.dataregion.flush.CompressionRatio;
 import org.apache.iotdb.db.storageengine.rescon.disk.FolderManager;
+import org.apache.iotdb.db.storageengine.rescon.disk.TierManager;
 import org.apache.iotdb.db.storageengine.rescon.disk.strategy.DirectoryStrategyType;
+import org.apache.iotdb.db.utils.ObjectTypeUtils;
 
 import org.apache.tsfile.external.commons.io.FileUtils;
 import org.slf4j.Logger;
@@ -38,6 +40,7 @@
 import java.nio.file.FileVisitor;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.SimpleFileVisitor;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -231,6 +234,17 @@ private void deleteAllFilesInDataDirs() throws IOException {
           timePartitions.addAll(Arrays.asList(files));
         }
       }
+
+      File objectRegionDir =
+          new File(
+              dataDirPath
+                  + File.separator
+                  + IoTDBConstant.OBJECT_FOLDER_NAME
+                  + File.separator
+                  + dataRegionId);
+      if (objectRegionDir.exists()) {
+        timePartitions.add(objectRegionDir);
+      }
     }
 
     try {
@@ -312,6 +326,91 @@ private void createLinksFromSnapshotDirToDataDirWithoutLog(File sourceDir)
         createLinksFromSnapshotToSourceDir(targetSuffix, files, folderManager);
       }
     }
+
+    File snapshotObjectDir = new File(sourceDir, IoTDBConstant.OBJECT_FOLDER_NAME);
+    if (snapshotObjectDir.exists()) {
+      FolderManager objectFolderManager =
+          new FolderManager(
+              TierManager.getInstance().getAllObjectFileFolders(),
+              DirectoryStrategyType.SEQUENCE_STRATEGY);
+      linkObjectTreeFromSnapshotToObjectDirs(snapshotObjectDir, objectFolderManager);
+    }
+  }
+
+  private void linkObjectTreeFromSnapshotToObjectDirs(
+      File sourceObjectRoot, FolderManager folderManager)
+      throws DiskSpaceInsufficientException, IOException {
+    Map<String, String> fileTarget = new HashMap<>();
+    List<File> files = new ArrayList<>();
+    Files.walkFileTree(
+        sourceObjectRoot.toPath(),
+        new SimpleFileVisitor<Path>() {
+          @Override
+          public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
+            if (isObjectSnapshotCandidate(file.getFileName().toString())) {
+              files.add(file.toFile());
+            }
+            return FileVisitResult.CONTINUE;
+          }
+        });
+    Path sourceRootPath = sourceObjectRoot.toPath();
+    for (File file : files) {
+      Path relativePath = sourceRootPath.relativize(file.toPath());
+      String fileKey =
+          relativePath.getNameCount() > 1
+              ? relativePath.getName(0).toString()
+              : relativePath.toString();
+      String dataDir = fileTarget.get(fileKey);
+      final Path targetRelPath = relativePath;
+      final String targetKey = fileKey;
+      final String preferredDir = dataDir;
+      final File sourceFile = file;
+
+      try {
+        folderManager.getNextWithRetry(
+            currentObjectDir -> {
+              String effectiveDir = (preferredDir != null) ? preferredDir : currentObjectDir;
+              File targetFile = new File(effectiveDir).toPath().resolve(targetRelPath).toFile();
+
+              try {
+                if (!targetFile.getParentFile().exists() && !targetFile.getParentFile().mkdirs()) {
+                  throw new IOException(
+                      String.format(
+                          "Cannot create directory %s",
+                          targetFile.getParentFile().getAbsolutePath()));
+                }
+
+                try {
+                  Files.createLink(targetFile.toPath(), sourceFile.toPath());
+                  LOGGER.debug("Created hard link from {} to {}", sourceFile, targetFile);
+                  fileTarget.put(targetKey, effectiveDir);
+                  return targetFile;
+                } catch (IOException e) {
+                  LOGGER.info(
+                      "Cannot create link from {} to {}, fallback to copy", sourceFile, targetFile);
+                }
+
+                Files.copy(sourceFile.toPath(), targetFile.toPath());
+                fileTarget.put(targetKey, effectiveDir);
+                return targetFile;
+              } catch (Exception e) {
+                LOGGER.warn(
+                    "Failed to process file {} in dir {}: {}",
+                    sourceFile.getName(),
+                    effectiveDir,
+                    e.getMessage(),
+                    e);
+                throw e;
+              }
+            });
+      } catch (Exception e) {
+        throw new IOException(
+            String.format(
+                "Failed to process object file after retries. Source: %s",
+                file.getAbsolutePath()),
+            e);
+      }
+    }
   }
 
   private void createLinksFromSnapshotToSourceDir(
@@ -470,6 +569,103 @@ private int takeHardLinksFromSnapshotToDataDir(
       }
     }
 
+    File objectSnapshotRoot =
+        new File(snapshotFolder.getAbsolutePath() + File.separator + IoTDBConstant.OBJECT_FOLDER_NAME);
+    if (objectSnapshotRoot.exists()) {
+      cnt += linkObjectSnapshotTreeToDataDir(objectSnapshotRoot, fileInfoSet);
+    }
+
+    return cnt;
+  }
+
+  private int linkObjectSnapshotTreeToDataDir(File objectSnapshotRoot, Set<String> fileInfoSet)
+      throws IOException {
+    final FolderManager folderManager;
+    try {
+      folderManager =
+          new FolderManager(
+              TierManager.getInstance().getAllObjectFileFolders(),
+              DirectoryStrategyType.SEQUENCE_STRATEGY);
+    } catch (DiskSpaceInsufficientException e) {
+      throw new IOException("Failed to initialize object folder manager", e);
+    }
+    Map<String, String> fileTarget = new HashMap<>();
+    List<File> files = new ArrayList<>();
+    Files.walkFileTree(
+        objectSnapshotRoot.toPath(),
+        new SimpleFileVisitor<Path>() {
+          @Override
+          public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
+            if (isObjectSnapshotCandidate(file.getFileName().toString())) {
+              files.add(file.toFile());
+            }
+            return FileVisitResult.CONTINUE;
+          }
+        });
+    Path rootPath = objectSnapshotRoot.toPath();
+    int cnt = 0;
+    for (File file : files) {
+      Path relativePath = rootPath.relativize(file.toPath());
+      String fileKey =
+          relativePath.getNameCount() > 1
+              ? relativePath.getName(0).toString()
+              : relativePath.toString();
+      String infoStr = getFileInfoString(file);
+      if (!fileInfoSet.contains(infoStr)) {
+        throw new IOException(
+            String.format("File %s is not in the log file list", file.getAbsolutePath()));
+      }
+      final Path targetRelPath = relativePath;
+      final String targetKey = fileKey;
+      final File sourceFile = file;
+
+      try {
+        folderManager.getNextWithRetry(
+            currentObjectDir -> {
+              String effectiveDir = fileTarget.getOrDefault(targetKey, currentObjectDir);
+              File targetFile = new File(effectiveDir).toPath().resolve(targetRelPath).toFile();
+
+              try {
+                if (!targetFile.getParentFile().exists() && !targetFile.getParentFile().mkdirs()) {
+                  throw new IOException(
+                      String.format(
+                          "Cannot create directory %s",
+                          targetFile.getParentFile().getAbsolutePath()));
+                }
+
+                try {
+                  Files.createLink(targetFile.toPath(), sourceFile.toPath());
+                  LOGGER.debug("Created hard link from {} to {}", sourceFile, targetFile);
+                  fileTarget.putIfAbsent(targetKey, effectiveDir);
+                  return targetFile;
+                } catch (IOException e) {
+                  LOGGER.info(
+                      "Cannot create link from {} to {}, fallback to copy", sourceFile, targetFile);
+                }
+
+                Files.copy(sourceFile.toPath(), targetFile.toPath());
+                fileTarget.putIfAbsent(targetKey, effectiveDir);
+                return targetFile;
+              } catch (Exception e) {
+                LOGGER.warn(
+                    "Failed to process file {} in dir {}: {}",
+                    sourceFile.getName(),
+                    effectiveDir,
+                    e.getMessage(),
+                    e);
+                throw e;
+              }
+            });
+      } catch (Exception e) {
+        throw new IOException(
+            String.format(
+                "Failed to process object snapshot file after retries. Source: %s",
+                file.getAbsolutePath()),
+            e);
+      }
+      cnt++;
+    }
+
     return cnt;
   }
 
@@ -492,6 +688,33 @@ private void createLinksFromSourceToTarget(File targetDir, File[] files, Set<Str
   }
 
   private String getFileInfoString(File file) {
+    Path filePath = file.toPath();
+    int objectDirIndex = -1;
+    int nameCount = filePath.getNameCount();
+    for (int i = 0; i < nameCount; i++) {
+      if (IoTDBConstant.OBJECT_FOLDER_NAME.equals(filePath.getName(i).toString())) {
+        objectDirIndex = i;
+        break;
+      }
+    }
+    if (objectDirIndex >= 0 && objectDirIndex < nameCount - 1) {
+      Path relativeToObject = filePath.subpath(objectDirIndex + 1, nameCount);
+      String fileName = relativeToObject.getFileName().toString();
+      Path parentPath = relativeToObject.getParent();
+      String middlePath = "";
+      if (parentPath != null) {
+        List<String> pathElements = new ArrayList<>();
+        for (Path element : parentPath) {
+          pathElements.add(element.toString());
+        }
+        middlePath = String.join("/", pathElements);
+      }
+      return fileName
+          + SnapshotLogger.SPLIT_CHAR
+          + middlePath
+          + SnapshotLogger.SPLIT_CHAR
+          + "object";
+    }
     String[] splittedStr = file.getAbsolutePath().split(File.separator.equals("\\") ? "\\\\" : "/");
     int length = splittedStr.length;
     return splittedStr[length - SnapshotLogger.FILE_NAME_OFFSET]
@@ -501,6 +724,12 @@ private String getFileInfoString(File file) {
         + splittedStr[length - SnapshotLogger.SEQUENCE_OFFSET];
   }
 
+  private boolean isObjectSnapshotCandidate(String fileName) {
+    return fileName.endsWith(ObjectTypeUtils.OBJECT_FILE_SUFFIX)
+        || fileName.endsWith(ObjectTypeUtils.OBJECT_TEMP_FILE_SUFFIX)
+        || fileName.endsWith(ObjectTypeUtils.OBJECT_BACK_FILE_SUFFIX);
+  }
+
   public List<File> getSnapshotFileInfo() throws IOException {
     File snapshotLogFile = getSnapshotLogFile();
 

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/snapshot/SnapshotLogger.java

@@ -24,6 +24,9 @@
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
 
 public class SnapshotLogger implements AutoCloseable {
   public static final String SNAPSHOT_LOG_NAME = "snapshot.log";
@@ -63,6 +66,26 @@ public void close() throws Exception {
    * @param sourceFile
    * @throws IOException
    */
+  public void logObjectRelativePath(Path relativePathFromObjectRoot) throws IOException {
+    String fileName = relativePathFromObjectRoot.getFileName().toString();
+    Path parentPath = relativePathFromObjectRoot.getParent();
+    String middlePath = "";
+    if (parentPath != null) {
+      List<String> pathElements = new ArrayList<>();
+      for (Path element : parentPath) {
+        pathElements.add(element.toString());
+      }
+      middlePath = String.join("/", pathElements);
+    }
+    os.write(fileName.getBytes(StandardCharsets.UTF_8));
+    os.write(SPLIT_CHAR.getBytes(StandardCharsets.UTF_8));
+    os.write(middlePath.getBytes(StandardCharsets.UTF_8));
+    os.write(SPLIT_CHAR.getBytes(StandardCharsets.UTF_8));
+    os.write("object".getBytes(StandardCharsets.UTF_8));
+    os.write("\n".getBytes(StandardCharsets.UTF_8));
+    os.flush();
+  }
+
   public void logFile(File sourceFile) throws IOException {
     String[] splitInfo =
         sourceFile.getAbsolutePath().split(File.separator.equals("\\") ? "\\\\" : "/");