feat: enhance progress and status handling with cancellation support and configuration actions

Author: WolfBublitz

src/Extensions/ILoggerExtensions.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using Spectre.Console;
 using Spectre.Console.Rendering;
@@ -10,8 +11,6 @@ namespace WB.Logging.LogSinks.Console.Spectre;
 /// </summary>
 public static class ILoggerExtensions
 {
-    private static readonly ProgressConfiguration defaultProgressConfiguration = new();
-    
     // ┌─────────────────────────────────────────────────────────────────────────────┐
     // │ Public Methods                                                              │
     // └─────────────────────────────────────────────────────────────────────────────┘
@@ -82,19 +81,21 @@ public static ILogger HorizontalRule(this ILogger @this, string? title = null)
     /// <param name="this">The <see cref="ILogger"/> instance to start the progress on.</param>
     /// <param name="progressConfiguration">The configuration for the progress. This includes settings such as
     /// <param name="action">The function that performs the progress.</param>
+    /// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
     /// <returns>A task that represents the asynchronous operation.</returns>
     /// <seealso cref="ProgressConfiguration"/>
-    public static async Task StartProgressAsync(this ILogger @this, ProgressConfiguration progressConfiguration, Func<ProgressContext, Task> action)
+    public static async Task StartProgressAsync(this ILogger @this, Action<Progress> progress, Func<ProgressContext, CancellationToken, Task> action, CancellationToken cancellationToken = default)
     {
         ArgumentNullException.ThrowIfNull(@this);
 
         ProgressPayload progressPayload = new()
         {
-            Configuration = progressConfiguration,
-            Action = action,
+            ProgressConfigurationAction = progress,
+            ProgressAction = action,
+            CancellationToken = cancellationToken,
         };
 
-        await @this.FlushAsync().ConfigureAwait(false);
+        await @this.FlushAsync(cancellationToken).ConfigureAwait(false);
 
         @this.Log(null, progressPayload);
 
@@ -108,17 +109,18 @@ public static async Task StartProgressAsync(this ILogger @this, ProgressConfigur
     /// <param name="this">The <see cref="ILogger"/> instance to start the progress on.</param>
     /// <param name="action">The function that performs the progress.</param>
     /// <returns>A task that represents the asynchronous operation.</returns>
-    public static async Task StartProgressAsync(this ILogger @this, Func<ProgressContext, Task> action)
-        => await StartProgressAsync(@this, defaultProgressConfiguration, action).ConfigureAwait(false);
+    public static async Task StartProgressAsync(this ILogger @this, Func<ProgressContext, CancellationToken, Task> action, CancellationToken cancellationToken = default)
+        => await StartProgressAsync(@this, _ => { }, action, cancellationToken).ConfigureAwait(false);
 
-    public static async Task StartStatusAsync(this ILogger @this, StatusConfiguration statusConfiguration, Func<StatusContext, Task> action)
+    public static async Task StartStatusAsync(this ILogger @this, string message, Action<Status> status, Func<StatusContext, Task> action)
     {
         ArgumentNullException.ThrowIfNull(@this);
 
         StatusPayload statusPayload = new()
         {
-            Configuration = statusConfiguration,
-            Action = action,
+            StatusConfigurationAction = status,
+            StatusAction = action,
+            StatusMessage = message,
         };
 
         await @this.FlushAsync().ConfigureAwait(false);
@@ -129,11 +131,5 @@ public static async Task StartStatusAsync(this ILogger @this, StatusConfiguratio
     }
 
     public static Task StartStatusAsync(this ILogger @this, string statusMessage, Func<StatusContext, Task> action)
-    {
-        ArgumentNullException.ThrowIfNull(@this);
-
-        StatusConfiguration statusConfiguration = new(statusMessage);
-
-        return StartStatusAsync(@this, statusConfiguration, action);
-    }
+        => StartStatusAsync(@this, statusMessage, _ => { }, action);
 }

src/LogMessageWriters/ProgressConsoleMessageWriter.cs

@@ -29,16 +29,16 @@ internal sealed class ProgressConsoleMessageWriter : IAsyncLogMessageWriter<Prog
     /// <inheritdoc/>
     public async ValueTask WriteAsync(DateTimeOffset timestamp, LogLevel? logLevel, IEnumerable<string> senders, ProgressPayload payload)
     {
-        ProgressConfiguration progressConfiguration = payload.Configuration;
-
 #pragma warning disable CA1031 // Do not catch general exception types
         try
         {
-            await Writer.Progress()
-                .AutoClear(progressConfiguration.AutoClear)
-                .AutoRefresh(progressConfiguration.AutoRefresh)
-                .HideCompleted(progressConfiguration.HideCompleted)
-                .StartAsync(payload.Action).ConfigureAwait(false);
+            using IDisposable _ = payload.CancellationToken.Register(payload.SetCanceled);
+
+            Progress progress = Writer.Progress();
+
+            payload.ProgressConfigurationAction(progress);
+
+            await progress.StartAsync(context => payload.ProgressAction(context, payload.CancellationToken)).ConfigureAwait(false);
 
             payload.SetCompleted();
         }

src/LogMessageWriters/StatusConsoleMessageWriter.cs

@@ -29,15 +29,14 @@ internal sealed class StatusConsoleMessageWriter : IAsyncLogMessageWriter<Status
     /// <inheritdoc/>
     public async ValueTask WriteAsync(DateTimeOffset timestamp, LogLevel? logLevel, IEnumerable<string> senders, StatusPayload payload)
     {
-        StatusConfiguration statusConfiguration = payload.Configuration;
-
 #pragma warning disable CA1031 // Do not catch general exception types
         try
         {
-            await Writer.Status()
-                .AutoRefresh(statusConfiguration.AutoRefresh)
-                .Spinner(statusConfiguration.Spinner)
-                .StartAsync(statusConfiguration.StatusMessage, payload.Action).ConfigureAwait(false);
+            Status status = Writer.Status();
+
+            payload.StatusConfigurationAction(status);
+
+            await status.StartAsync(payload.StatusMessage, payload.StatusAction).ConfigureAwait(false);
 
             payload.SetCompleted();
         }

src/Payloads/ProgressPayload.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using Spectre.Console;
 
@@ -19,14 +20,11 @@ internal sealed class ProgressPayload
     // │ Public Properties                                                           │
     // └─────────────────────────────────────────────────────────────────────────────┘
 
-    /// <summary>
-    /// Gets or sets the configuration for the progress. This includes settings such as
-    /// whether the progress should be automatically cleared, refreshed, or hide completed tasks.
-    /// </summary>
-    /// <seealso cref="ProgressConfiguration"/>
-    public required ProgressConfiguration Configuration { get; init; }
+    public required Func<ProgressContext, CancellationToken, Task> ProgressAction { get; init; }
+
+    public Action<Progress> ProgressConfigurationAction { get; init; } = _ => { };
 
-    public required Func<ProgressContext, Task> Action { get; init; }
+    public CancellationToken CancellationToken { get; init; } = CancellationToken.None;
 
     /// <summary>
     /// Gets a <see cref="Task"/> that represents the completion of the progress. The 
@@ -55,4 +53,11 @@ public void SetCompleted()
     /// <param name="exception">The exception that caused the progress to fail.</param>
     public void SetException(Exception exception)
         => taskCompletionSource.TrySetException(exception);
+
+    /// <summary>
+    /// Sets the progress as canceled, which will complete the <see cref="Completed"/> 
+    /// task as canceled.
+    /// </summary>
+    public void SetCanceled()
+        => taskCompletionSource.TrySetCanceled();
 }

src/Payloads/StatusPayload.cs

@@ -19,12 +19,14 @@ internal sealed class StatusPayload
     // │ Public Properties                                                           │
     // └─────────────────────────────────────────────────────────────────────────────┘
 
-    public required StatusConfiguration Configuration { get; init; }
+    public required string StatusMessage { get; init; }
 
     /// <summary>
     /// Gets or sets the action that performs the status update.
     /// </summary>
-    public required Func<StatusContext, Task> Action { get; init; }
+    public required Func<StatusContext, Task> StatusAction { get; init; }
+
+    public Action<Status> StatusConfigurationAction { get; init; } = _ => { };
 
     /// <summary>
     /// Gets a <see cref="Task"/> that represents the completion of the status. The 

src/ProgressConfiguration.cs

@@ -1,4 +1,7 @@
+using System;
+using System.Threading;
 using System.Threading.Tasks;
+using AwesomeAssertions;
 using Spectre.Console.Testing;
 using VerifyTUnit;
 using WB.Logging;
@@ -23,19 +26,73 @@ public async Task ShouldStartAProgressTaskAndLogItToTheConsole()
         });
 
         // Act
-        await logger.StartProgressAsync("Processing...", async progress =>
+        await logger.StartProgressAsync(async (progress, cancellationToken) =>
         {
             var task = progress.AddTask("Processing files", maxValue: 100);
 
             while (!progress.IsFinished)
             {
                 task.Increment(1);
 
-                await Task.Delay(100).ConfigureAwait(false);
+                await Task.Delay(10).ConfigureAwait(false);
             }
         }).ConfigureAwait(false);
         await logger.FlushAsync().ConfigureAwait(false);
 
-        await Verifier.Verify(testConsole.Output).ConfigureAwait(false);
+        testConsole.Output.Should().NotBeEmpty(because: "a progress should have been logged to the console");
+    }
+
+    [Test]
+    public async Task ShouldThrowTheExceptionFromProgressAction()
+    {
+        // Arrange
+        TestConsole testConsole = new()
+        {
+            EmitAnsiSequences = true,
+        };
+        ILogger logger = new Logger("Test");
+        logger.AttachSpectreConsole(logSink =>
+        {
+            logSink.Writer = testConsole;
+        });
+
+        // Act
+        Func<Task> action = () => logger.StartProgressAsync(async (progress, cancellationToken) =>
+        {
+            throw new Exception("Something went wrong during progress.");
+        });
+
+        // Assert
+        await action.Should().ThrowAsync<Exception>(because: "the exception from the progress action should be propagated");
+    }
+
+    [Test]
+    public async Task ShouldBeCancellable()
+    {
+        // Arrange
+        TestConsole testConsole = new()
+        {
+            EmitAnsiSequences = true,
+        };
+        ILogger logger = new Logger("Test");
+        logger.AttachSpectreConsole(logSink =>
+        {
+            logSink.Writer = testConsole;
+        });
+
+        using CancellationTokenSource cancellationTokenSource = new();
+
+        // Act
+        Func<Task> action = () => logger.StartProgressAsync(async (progress, cancellationToken) =>
+        {
+            while (true)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+            }
+        }, cancellationTokenSource.Token);
+        cancellationTokenSource.Cancel();
+
+        // Assert
+        await action.Should().ThrowAsync<OperationCanceledException>(because: "the progress should be canceled when the cancellation token is canceled");
     }
 }