Compress for cdb output files

Author: CapulusCodeNinja

nexus_engine/nexus_engine/Internal/CdbSession.cs

@@ -1,5 +1,4 @@
 using System.Diagnostics;
-using System.IO.Compression;
 using System.Text;
 
 using Nexus.Config;
@@ -559,26 +558,21 @@ private async Task CompressCdbLogIfAvailableAsync()
 
             var cdbLogFilePath = GetCdbSessionBasedLogPath(SessionId);
 
-            if (!File.Exists(cdbLogFilePath))
+            if (!m_FileSystem.FileExists(cdbLogFilePath))
             {
                 return;
             }
 
             var compressedPath = $"{cdbLogFilePath}.gz";
 
-            if (File.Exists(compressedPath))
+            if (m_FileSystem.FileExists(compressedPath))
             {
                 return;
             }
 
-            using (var sourceStream = new FileStream(cdbLogFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
-            using (var destinationStream = new FileStream(compressedPath, FileMode.Create, FileAccess.Write, FileShare.None))
-            using (var gzipStream = new GZipStream(destinationStream, CompressionLevel.Optimal))
-            {
-                await sourceStream.CopyToAsync(gzipStream).ConfigureAwait(false);
-            }
+            await m_FileSystem.CompressToGZipAsync(cdbLogFilePath, compressedPath).ConfigureAwait(false);
 
-            File.Delete(cdbLogFilePath);
+            m_FileSystem.DeleteFile(cdbLogFilePath);
 
             m_Logger.Info("Compressed CDB log for session {SessionId} to {CompressedPath}", SessionId, compressedPath);
         }

nexus_external_apis/FileSystem/FileSystem.cs

@@ -1,3 +1,5 @@
+using System.IO.Compression;
+
 namespace Nexus.External.Apis.FileSystem;
 
 /// <summary>
@@ -207,4 +209,19 @@ public void ProbeRead(string path)
         Span<byte> buffer = stackalloc byte[1];
         _ = stream.Read(buffer);
     }
+
+    /// <summary>
+    /// Compresses the specified source file into GZip format at the specified destination path.
+    /// </summary>
+    /// <param name="sourceFilePath">The path of the file to compress.</param>
+    /// <param name="destinationFilePath">The path where the compressed file should be created.</param>
+    /// <param name="cancellationToken">The cancellation token for the operation.</param>
+    /// <returns>A task representing the asynchronous compression operation.</returns>
+    public async Task CompressToGZipAsync(string sourceFilePath, string destinationFilePath, CancellationToken cancellationToken = default)
+    {
+        using var sourceStream = File.OpenRead(sourceFilePath);
+        using var destinationStream = new FileStream(destinationFilePath, FileMode.Create, FileAccess.Write, FileShare.None);
+        using var gzipStream = new GZipStream(destinationStream, CompressionLevel.Optimal);
+        await sourceStream.CopyToAsync(gzipStream, cancellationToken).ConfigureAwait(false);
+    }
 }

nexus_external_apis/FileSystem/IFileSystem.cs

@@ -145,4 +145,13 @@ public interface IFileSystem
     /// </summary>
     /// <param name="path">The file path to probe.</param>
     void ProbeRead(string path);
+
+    /// <summary>
+    /// Compresses the specified source file into GZip format at the specified destination path.
+    /// </summary>
+    /// <param name="sourceFilePath">The path of the file to compress.</param>
+    /// <param name="destinationFilePath">The path where the compressed file should be created.</param>
+    /// <param name="cancellationToken">The cancellation token for the operation.</param>
+    /// <returns>A task representing the asynchronous compression operation.</returns>
+    Task CompressToGZipAsync(string sourceFilePath, string destinationFilePath, CancellationToken cancellationToken = default);
 }

unittests/nexus_engine/nexus_engine_unittests/Internal/CdbSessionTests.cs

@@ -1388,22 +1388,19 @@ public async Task InitializeAsync_WhenInitializationFails_DisposesSession()
     }
 
     /// <summary>
-    /// Verifies that disposing the session compresses the CDB log file and deletes the original log.
+    /// Verifies that disposing the session requests GZip compression of the CDB log file and deletes the original log via the file system abstraction.
     /// </summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
     [Fact]
     public async Task DisposeAsync_CompressesCdbLog_AndDeletesOriginalLog()
     {
         // Arrange
         var originalConfig = LogManager.Configuration;
-        var tempRoot = Path.Combine(Path.GetTempPath(), "MCPNexusCdbCompressionTests", Guid.NewGuid().ToString("N"));
-        var logsDirectory = Path.Combine(tempRoot, "Logs");
-        _ = Directory.CreateDirectory(logsDirectory);
 
         try
         {
             var config = new LoggingConfiguration();
-            var mainLogPath = Path.Combine(logsDirectory, "main.log");
+            const string mainLogPath = "C:\\logs\\main.log";
             var fileTarget = new FileTarget("mainFile")
             {
                 FileName = mainLogPath,
@@ -1412,42 +1409,39 @@ public async Task DisposeAsync_CompressesCdbLog_AndDeletesOriginalLog()
             config.AddRuleForAllLevels(fileTarget);
             LogManager.Configuration = config;
 
-            var accessor = new CdbSessionTestAccessor(m_Settings.Object, m_MockFileSystem.Object, m_MockProcessManager.Object);
+            var fileSystem = new Mock<IFileSystem>();
+            var processManager = m_MockProcessManager;
+
+            var accessor = new CdbSessionTestAccessor(m_Settings.Object, fileSystem.Object, processManager.Object);
 
             var sessionId = "session-compress";
             var sessionIdProperty = typeof(CdbSession).GetProperty("SessionId", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public);
             sessionIdProperty!.SetValue(accessor, sessionId);
 
             var getLogPathMethod = typeof(CdbSession).GetMethod("GetCdbSessionBasedLogPath", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
             var logPath = (string)getLogPathMethod!.Invoke(accessor, new object[] { sessionId })!;
+            var compressedPath = $"{logPath}.gz";
 
-            var logDirectory = Path.GetDirectoryName(logPath);
-            if (!string.IsNullOrEmpty(logDirectory))
-            {
-                _ = Directory.CreateDirectory(logDirectory);
-            }
+            _ = fileSystem.Setup(fs => fs.FileExists(logPath))
+                .Returns(true);
+            _ = fileSystem.Setup(fs => fs.FileExists(compressedPath))
+                .Returns(false);
+
+            _ = fileSystem.Setup(fs => fs.CompressToGZipAsync(logPath, compressedPath, It.IsAny<CancellationToken>()))
+                .Returns(Task.CompletedTask);
 
-            const string logContent = "cdb log content";
-            File.WriteAllText(logPath, logContent);
+            _ = fileSystem.Setup(fs => fs.DeleteFile(logPath));
 
             // Act
             await accessor.DisposeAsync();
 
             // Assert
-            var compressedPath = $"{logPath}.gz";
-            _ = File.Exists(logPath).Should().BeFalse();
-            _ = File.Exists(compressedPath).Should().BeTrue();
-            var compressedFileInfo = new FileInfo(compressedPath);
-            _ = compressedFileInfo.Length.Should().BeGreaterThan(0);
+            fileSystem.Verify(fs => fs.CompressToGZipAsync(logPath, compressedPath, It.IsAny<CancellationToken>()), Times.Once);
+            fileSystem.Verify(fs => fs.DeleteFile(logPath), Times.Once);
         }
         finally
         {
             LogManager.Configuration = originalConfig;
-
-            if (Directory.Exists(tempRoot))
-            {
-                Directory.Delete(tempRoot, true);
-            }
         }
     }
 }