Added logging for Uncompactor

- Fixed some parts of Compactor

Author: Iridium-IO

CompactGUI.Core/Compactor.cs

@@ -75,9 +75,10 @@ await Parallel.ForEachAsync(workingFiles, parallelOptions,
         }
         catch (OperationCanceledException){ return false; }
         catch (Exception){ return false; }
+        finally { sw.Stop();}
 
 
-        sw.Stop();
+        
         CompactorLog.CompressionCompleted(_logger, Math.Round(sw.Elapsed.TotalSeconds, 3));
         return true;
     }
@@ -142,16 +143,16 @@ public void Pause()
 
     public void Resume()
     {
-        CompactorLog.CompressionResumed(_logger);
         if (pauseSemaphore.CurrentCount == 0) pauseSemaphore.Release();  
+        CompactorLog.CompressionResumed(_logger);
     }
 
 
     public void Cancel()
     {
-        CompactorLog.CompressionCanceled(_logger);
         Resume();
         cancellationTokenSource.Cancel();
+        CompactorLog.CompressionCanceled(_logger);
     }
 
 

CompactGUI.Core/Uncompactor.cs

@@ -1,7 +1,11 @@
 
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Win32.SafeHandles;
 using System.Collections.Concurrent;
 using Windows.Win32;
+using CompactGUI.Logging.Core;
+using System.Diagnostics;
 
 namespace CompactGUI.Core;
 
@@ -12,6 +16,12 @@ public class Uncompactor : ICompressor, IDisposable
     private CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
     private ConcurrentDictionary<string, int> processedFileCount = new ConcurrentDictionary<string, int>();
 
+    private readonly ILogger<Uncompactor> _logger;
+
+    public Uncompactor(ILogger<Uncompactor>? logger = null)
+    {
+        _logger = logger ?? NullLogger<Uncompactor>.Instance;
+    }
 
     public async Task<bool> RunAsync(List<string> filesList, IProgress<CompressionProgress>? progressMonitor = null, int maxParallelism = 1)
     {
@@ -20,6 +30,8 @@ public async Task<bool> RunAsync(List<string> filesList, IProgress<CompressionPr
         ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = maxParallelism };
         processedFileCount.Clear();
 
+        UncompactorLog.StartingDecompression(_logger, totalFiles, maxParallelism);
+        Stopwatch sw = Stopwatch.StartNew();
         try
         {
             await Parallel.ForEachAsync(filesList, parallelOptions,
@@ -30,13 +42,16 @@ await Parallel.ForEachAsync(filesList, parallelOptions,
                 });
         }
         catch (OperationCanceledException) { return false; }
+        finally { sw.Stop(); }
 
+        UncompactorLog.DecompressionCompleted(_logger, Math.Round(sw.Elapsed.TotalSeconds, 3));
         return true;
 
     }
 
     private async Task PauseAndProcessFile(string file, int totalFiles, IProgress<CompressionProgress>? progressMonitor, CancellationToken ctx)
     {
+        UncompactorLog.ProcessingFile(_logger, file);
         try
         {
             await pauseSemaphore.WaitAsync(ctx).ConfigureAwait(false);
@@ -64,25 +79,31 @@ private async Task PauseAndProcessFile(string file, int totalFiles, IProgress<Co
                 return res;
             }  
         }
-        catch (Exception) { return null; }
+        catch (Exception ex) { 
+            UncompactorLog.FileDecompressionFailed(_logger, file, ex.Message);
+            return null; 
+        }
     }
 
     public void Pause()
     {
+        UncompactorLog.DecompressionPaused(_logger);
         pauseSemaphore.Wait();
     }
 
 
     public void Resume()
     {
         if (pauseSemaphore.CurrentCount == 0) pauseSemaphore.Release();
+        UncompactorLog.DecompressionResumed(_logger);
     }
 
 
     public void Cancel()
     {
         Resume();
         cancellationTokenSource.Cancel();
+        UncompactorLog.DecompressionCanceled(_logger);
     }
 
 

CompactGUI.Logging/Core/UncompactorLog.cs

@@ -0,0 +1,32 @@
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CompactGUI.Logging.Core;
+
+public static partial class UncompactorLog
+{
+    [LoggerMessage(Level = LogLevel.Information, Message = "Starting decompression of {FileCount} files with {MaxParallelism} threads")]
+    public static partial void StartingDecompression(ILogger logger, int fileCount, int maxParallelism);
+
+    [LoggerMessage(Level = LogLevel.Trace, Message = "Processing file: {FileName}")]
+    public static partial void ProcessingFile(ILogger logger, string fileName);
+
+    [LoggerMessage(Level = LogLevel.Warning, Message = "File decompression failed for: {FileName} with error: {ErrorMessage}")]
+    public static partial void FileDecompressionFailed(ILogger logger, string fileName, string errorMessage);
+
+    [LoggerMessage(Level = LogLevel.Information, Message = "Decompression paused.")]
+    public static partial void DecompressionPaused(ILogger logger);
+
+    [LoggerMessage(Level = LogLevel.Information, Message = "Decompression resumed.")]
+    public static partial void DecompressionResumed(ILogger logger);
+
+    [LoggerMessage(Level = LogLevel.Information, Message = "Decompression canceled.")]
+    public static partial void DecompressionCanceled(ILogger logger);
+
+    [LoggerMessage(Level = LogLevel.Information, Message = "Decompression completed successfully in {TimeTaken}s.")]
+    public static partial void DecompressionCompleted(ILogger logger, double timeTaken);
+}

CompactGUI/Models/NewModels/ICompressableFolder.vb

@@ -74,18 +74,20 @@ Public MustInherit Class CompressableFolder : Inherits ObservableObject
 
 
     Public Compressor As ICompressor
-    Private Shared ReadOnly CompressorLogger As ILogger = Application.GetService(Of ILogger(Of Compactor))()
+    Private Shared ReadOnly CompactorLogger As ILogger = Application.GetService(Of ILogger(Of Compactor))()
+    Private Shared ReadOnly UncompactorLogger As ILogger = Application.GetService(Of ILogger(Of Uncompactor))()
+
     Public Async Function CompressFolder() As Task(Of Boolean)
 
-        Compressor = New Compactor(FolderName, WOFConvertCompressionLevel(CompressionOptions.SelectedCompressionMode), GetSkipList, CompressorLogger)
+        Compressor = New Compactor(FolderName, WOFConvertCompressionLevel(CompressionOptions.SelectedCompressionMode), GetSkipList, CompactorLogger)
         Return Await RunCompressionAsync(Compressor, Nothing, True)
 
     End Function
 
 
     Public Async Function UncompressFolder() As Task(Of Boolean)
 
-        Compressor = New Uncompactor
+        Compressor = New Uncompactor(UncompactorLogger)
         Dim compressedFilesList = AnalysisResults.Where(Function(rs) rs.CompressedSize < rs.UncompressedSize).Select(Of String)(Function(f) f.FileName).ToList
         Return Await RunCompressionAsync(Compressor, compressedFilesList, isCompressing:=False)