From 9a29c00dfc908a24596987aece23617f6a2c5f3d Mon Sep 17 00:00:00 2001
From: Anthony Stirling <77850077+Frooodle@users.noreply.github.com.>
Date: Wed, 25 Jun 2025 12:49:42 +0100
Subject: [PATCH] final changes

---
 .../common/config/TempFileConfiguration.java  |  6 +--
 .../service/TempFileCleanupService.java       | 38 +++++++++----------
 .../common/util/TempFileRegistry.java         | 15 ++++----
 3 files changed, 28 insertions(+), 31 deletions(-)

diff --git a/common/src/main/java/stirling/software/common/config/TempFileConfiguration.java b/common/src/main/java/stirling/software/common/config/TempFileConfiguration.java
index 87abdbe60..6fce7e0bf 100644
--- a/common/src/main/java/stirling/software/common/config/TempFileConfiguration.java
+++ b/common/src/main/java/stirling/software/common/config/TempFileConfiguration.java
@@ -49,9 +49,9 @@ public class TempFileConfiguration {
                 log.info("Created temporary directory: {}", tempDir);
             }
 
-            log.info("Temporary file configuration initialized");
-            log.info("Using temp directory: {}", customTempDirectory);
-            log.info("Temp file prefix: {}", tempFiles.getPrefix());
+            log.debug("Temporary file configuration initialized");
+            log.debug("Using temp directory: {}", customTempDirectory);
+            log.debug("Temp file prefix: {}", tempFiles.getPrefix());
         } catch (Exception e) {
             log.error("Failed to initialize temporary file configuration", e);
         }
diff --git a/common/src/main/java/stirling/software/common/service/TempFileCleanupService.java b/common/src/main/java/stirling/software/common/service/TempFileCleanupService.java
index 7a4e7d626..d53c4ea84 100644
--- a/common/src/main/java/stirling/software/common/service/TempFileCleanupService.java
+++ b/common/src/main/java/stirling/software/common/service/TempFileCleanupService.java
@@ -302,53 +302,37 @@ public class TempFileCleanupService {
             Consumer<Path> onDeleteCallback)
             throws IOException {
 
-        // Check recursion depth limit
         if (depth > MAX_RECURSION_DEPTH) {
-            log.warn("Maximum directory recursion depth reached for: {}", directory);
+            log.debug("Maximum directory recursion depth reached for: {}", directory);
             return;
         }
 
-        // Use try-with-resources to ensure the stream is closed
+        java.util.List<Path> subdirectories = new java.util.ArrayList<>();
+        
         try (Stream<Path> pathStream = Files.list(directory)) {
-            // Process files in a streaming fashion instead of materializing the whole list
             pathStream.forEach(
                     path -> {
                         try {
                             String fileName = path.getFileName().toString();
 
-                            // Skip if file should be excluded
                             if (SHOULD_SKIP.test(fileName)) {
                                 return;
                             }
 
-                            // Handle directories recursively
                             if (Files.isDirectory(path)) {
-                                try {
-                                    cleanupDirectoryStreaming(
-                                            path,
-                                            containerMode,
-                                            depth + 1,
-                                            maxAgeMillis,
-                                            isScheduled,
-                                            onDeleteCallback);
-                                } catch (IOException e) {
-                                    log.warn("Error processing subdirectory: {}", path, e);
-                                }
+                                subdirectories.add(path);
                                 return;
                             }
 
-                            // Skip registered files - these are handled by TempFileManager
                             if (registry.contains(path.toFile())) {
                                 return;
                             }
 
-                            // Check if this file should be deleted
                             if (shouldDeleteFile(path, fileName, containerMode, maxAgeMillis)) {
                                 try {
                                     Files.deleteIfExists(path);
                                     onDeleteCallback.accept(path);
                                 } catch (IOException e) {
-                                    // Handle locked files more gracefully
                                     if (e.getMessage() != null
                                             && e.getMessage()
                                                     .contains("being used by another process")) {
@@ -363,6 +347,20 @@ public class TempFileCleanupService {
                         }
                     });
         }
+        
+        for (Path subdirectory : subdirectories) {
+            try {
+                cleanupDirectoryStreaming(
+                        subdirectory,
+                        containerMode,
+                        depth + 1,
+                        maxAgeMillis,
+                        isScheduled,
+                        onDeleteCallback);
+            } catch (IOException e) {
+                log.warn("Error processing subdirectory: {}", subdirectory, e);
+            }
+        }
     }
 
     /** Determine if a file should be deleted based on its name, age, and other criteria. */
diff --git a/common/src/main/java/stirling/software/common/util/TempFileRegistry.java b/common/src/main/java/stirling/software/common/util/TempFileRegistry.java
index 96aaf8ffa..1e55c6b15 100644
--- a/common/src/main/java/stirling/software/common/util/TempFileRegistry.java
+++ b/common/src/main/java/stirling/software/common/util/TempFileRegistry.java
@@ -4,9 +4,11 @@ import java.io.File;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.time.Instant;
+import java.util.Collections;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ConcurrentSkipListSet;
 import java.util.stream.Collectors;
 
@@ -22,14 +24,11 @@ import lombok.extern.slf4j.Slf4j;
 @Component
 public class TempFileRegistry {
 
-    // Track temp files with creation timestamps
-    private final Map<Path, Instant> registeredFiles = new ConcurrentHashMap<>();
-
-    // Separately track third-party temp files that need special handling
-    private final Set<Path> thirdPartyTempFiles = new ConcurrentSkipListSet<>();
-
-    // Track temp directories
-    private final Set<Path> tempDirectories = new ConcurrentSkipListSet<>();
+	 private final ConcurrentMap<Path, Instant> registeredFiles = new ConcurrentHashMap<>();
+	     private final Set<Path> thirdPartyTempFiles =
+	             Collections.newSetFromMap(new ConcurrentHashMap<>());
+	     private final Set<Path> tempDirectories =
+	            Collections.newSetFromMap(new ConcurrentHashMap<>());
 
     /**
      * Register a temporary file with the registry.