feat: Introduce task-specific logging for PLC protocols and integrate log viewing into the task manager UI.

Author: efargas

docs/website/docs/architecture/task-execution-workflow.md

@@ -0,0 +1,77 @@
+---
+id: task-execution-workflow
+title: Task Execution Workflow
+sidebar_position: 8
+---
+
+# Application Task Execution Workflow
+
+This document details the complete end-to-end task execution workflow for the PLC Memory Dump process, focusing on task cancellation propagation and connection lifecycle management.
+
+## Components Involved
+- **Job Wizard (UI)**: Initiates and manages the UX of the workflow.
+- **BootloaderService**: Handles connection proxying and starts the orchestration.
+- **SocatProcessManager**: Manages the underlying `socat` proxy processes mapping TCP/IP to serial over SSH/Telnet.
+- **MemoryDumpOrchestrator**: Orchestrates the multi-segment memory dump process, tracking memory blocks and dispatching them to the UI thread.
+- **DumperService**: Handles the low-level data packet framing and parsing from the PLC.
+
+## Workflow Execution Sequence
+
+1. **Initialization (`StartDumpSession`)**
+   The JobWizard triggers `BootloaderService.StartDumpSessionAsync()`. This call invokes the `SocatProcessManager` to spawn the necessary `socat` proxies to bridge the connection to the PLC.
+2. **Session Pipeline Creation (`StartSessionAsync`)**
+   The `BootloaderService` passes the `CancellationToken` to `MemoryDumpOrchestrator.StartSessionAsync()`. It creates a linked `CancellationTokenSource` and spawns the `DumperService` loop (`_dumpTask`) and the Consumer loop (`_consumptionTask`).
+3. **Data Acquisition Loop (`InvokeDumpCommandAsync`)**
+   For each memory segment:
+   - Leftover data is flushed and parser is reset to prevent state corruption.
+   - The orchestrator frames and sends the dump hook payload.
+   - It awaits the segment completion via `WaitForSegmentAsync`.
+   - The `DS` parses bytes, dispatching `MemoryBlock` elements to the orchestrator via a `Channel<MemoryBlock>`.
+4. **Graceful Teardown and Cancellation (`StopAsync`)**
+   When the task completes or is canceled:
+   - `BootloaderService` triggers `MemoryDumpOrchestrator.StopAsync()`.
+   - The orchestrator commands `DumperService.StopAsync()` which writes the cancellation byte `0x03` to the stream to pause PLC transmission.
+   - Pending reads are aborted.
+   - `SocatProcessManager.StopAll()` executes complete process tree termination to avoid orphan `socat` processes.
+
+## Sequence Diagram
+
+```mermaid
+sequenceDiagram
+    participant UI as Job Wizard (UI)
+    participant BO as BootloaderService
+    participant SP as SocatProcessManager
+    participant MO as MemoryDumpOrchestrator
+    participant DS as DumperService
+    participant PLC as PLC Device
+
+    UI->>BO: StartDumpSession(token)
+    activate BO
+    BO->>SP: StartSocatProxy()
+    activate SP
+    SP-->>BO: Proxy Ready
+    BO->>MO: StartSessionAsync(token)
+    activate MO
+    MO->>DS: StartDumpingAsync(host, port, token)
+    activate DS
+    DS->>PLC: Connect Socket
+    
+    loop Per Memory Segment
+        MO->>MO: FlushRemainingDataAsync()
+        MO->>DS: ResetForNewSegment()
+        MO->>PLC: InvokeDumpCommandAsync(args)
+        PLC-->>DS: Data Stream (Segments)
+        DS-->>MO: ChannelReader<MemoryBlock>
+        MO-->>UI: DispatchBatchToUIAsync()
+    end
+    
+    UI->>BO: Cancel or Finish
+    BO->>MO: StopAsync()
+    MO->>DS: StopAsync() (Send 0x03 byte)
+    DS->>PLC: 0x03 Cancel Byte
+    deactivate DS
+    deactivate MO
+    BO->>SP: StopAll() (Kill Process Tree)
+    deactivate SP
+    deactivate BO
+```

src/S7Tools.Core/Interfaces/Services/IPlcClient.cs

@@ -80,6 +80,12 @@ Task InvokeDumperStreamAsync(
     /// <param name="port">The port number.</param>
     void Configure(string host, int port);
 
+    /// <summary>
+    /// Sets an optional session-specific logger (e.g., for task-specific protocol logging).
+    /// </summary>
+    /// <param name="logger">The logger to use for this session.</param>
+    void SetLogger(Microsoft.Extensions.Logging.ILogger? logger);
+
     /// <summary>
     /// Establishes the connection to the PLC (via Socat).
     /// </summary>

src/S7Tools.Core/Interfaces/Services/IPlcProtocol.cs

@@ -54,6 +54,12 @@ public interface IPlcProtocol
     /// <param name="port">The port number.</param>
     void Configure(string host, int port);
 
+    /// <summary>
+    /// Sets an optional session-specific logger (e.g., for task-specific protocol logging).
+    /// </summary>
+    /// <param name="logger">The logger to use for this session.</param>
+    void SetLogger(Microsoft.Extensions.Logging.ILogger? logger);
+
     /// <summary>
     /// Establishes the connection to the PLC.
     /// </summary>

src/S7Tools/Services/Adapters/PlcClientAdapter.cs

@@ -62,6 +62,14 @@ public void Configure(string host, int port)
             _protocol.Configure(host, port);
         }
 
+        /// <summary>
+        /// Sets an optional session-specific logger (e.g., for task-specific protocol logging).
+        /// </summary>
+        public void SetLogger(ILogger? logger)
+        {
+            _protocol.SetLogger(logger);
+        }
+
         /// <summary>
         /// Executes the DisposeAsync operation.
         /// </summary>

src/S7Tools/Services/Adapters/PlcProtocolAdapter.cs

@@ -20,6 +20,7 @@ public sealed class PlcProtocolAdapter : IPlcProtocol
     {
         private readonly ILogger<PlcProtocolAdapter> _logger;
         private readonly IPlcTransport _transport;
+        private ILogger _effectiveLogger;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="PlcProtocolAdapter"/> class.
@@ -28,6 +29,18 @@ public PlcProtocolAdapter(IPlcTransport transport, ILogger<PlcProtocolAdapter> l
         {
             _transport = transport ?? throw new ArgumentNullException(nameof(transport));
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _effectiveLogger = _logger;
+        }
+
+        /// <summary>
+        /// Sets an optional session-specific logger (e.g., for task-specific protocol logging).
+        /// </summary>
+        public void SetLogger(ILogger? logger)
+        {
+            if (logger != null)
+            {
+                _effectiveLogger = logger;
+            }
         }
 
         /// <summary>
@@ -125,9 +138,9 @@ public async Task SendPacketAsync(byte[] payload, int? maxChunk = 2, Cancellatio
             await Task.Delay(10, cancellationToken).ConfigureAwait(false);
 
             var packet = EncodePacket(payload);
-            if (_logger.IsEnabled(LogLevel.Trace))
+            if (_effectiveLogger.IsEnabled(LogLevel.Trace))
             {
-                _logger.LogTrace("-> SEND: {Hex}", BitConverter.ToString(packet).Replace("-", ""));
+                _effectiveLogger.LogTrace("-> SEND: {Hex}", BitConverter.ToString(packet).Replace("-", ""));
             }
 
             int step = maxChunk ?? 2;
@@ -182,9 +195,9 @@ public async Task<byte[]> ReceivePacketAsync(CancellationToken cancellationToken
                 bytesRead += currentBytesRead;
             }
 
-            if (_logger.IsEnabled(LogLevel.Trace))
+            if (_effectiveLogger.IsEnabled(LogLevel.Trace))
             {
-                _logger.LogTrace("<- RECV: {Hex}", BitConverter.ToString(fullPacket).Replace("-", ""));
+                _effectiveLogger.LogTrace("<- RECV: {Hex}", BitConverter.ToString(fullPacket).Replace("-", ""));
             }
             return DecodePacket(fullPacket);
         }

src/S7Tools/Services/Bootloader/BootloaderService.cs

@@ -871,6 +871,7 @@ private async Task<BootloaderResult> PerformDumpProcessStreamingAsync(
         JobProfileSet profiles,
         IProgress<(string stage, double percent, long? bytesRead, long? totalBytes)> progress,
         ILogger logger,
+        ILogger? processLogger,
         double startPercent,
         double weight,
         Guid? taskId,
@@ -918,7 +919,7 @@ private async Task<BootloaderResult> PerformDumpProcessStreamingAsync(
 
             // Start the dumper session ONCE for all iterations
             logger.LogInformation("Starting persistent dumper session for all iterations.");
-            await client.StartDumperSessionAsync(cancellationToken, logger).ConfigureAwait(false);
+            await client.StartDumperSessionAsync(cancellationToken, processLogger).ConfigureAwait(false);
 
             for (int iter = 0; iter < iterationCount; iter++)
             {
@@ -941,6 +942,7 @@ private async Task<BootloaderResult> PerformDumpProcessStreamingAsync(
                     client,
                     progress,
                     logger,
+                    processLogger,
                     startPercent,
                     weight,
                     iterationCount,
@@ -990,12 +992,14 @@ private record StreamingContext(
         IPlcClient Client,
         IProgress<(string stage, double percent, long? bytesRead, long? totalBytes)> Progress,
         ILogger Logger,
+        ILogger? ProcessLogger,
         double StartPercent,
         double Weight,
         int IterationCount,
         int CurrentIteration,
         long TotalExpectedBytes,
-        CancellationToken CancellationToken);
+        CancellationToken CancellationToken
+    );
 
     private static uint ParseSegmentAddress(MemorySegment segment)
     {
@@ -1108,7 +1112,7 @@ await ctx.Client.InvokeDumperStreamAsync(
                     async data => await fileStream.WriteAsync(data, ctx.CancellationToken),
                     segProgress,
                     ctx.CancellationToken,
-                    logger: ctx.Logger).ConfigureAwait(false);
+                    logger: ctx.ProcessLogger).ConfigureAwait(false);
 
                 // Use the local variable that was updated by the progress callback
                 // or fall back to segLength if the callback didn't fire for some reason
@@ -1181,7 +1185,7 @@ await ctx.Client.InvokeDumperStreamAsync(
                 async data => await fileStream.WriteAsync(data, ctx.CancellationToken),
                 regionProgress,
                 ctx.CancellationToken,
-                logger: ctx.Logger).ConfigureAwait(false);
+                logger: ctx.ProcessLogger).ConfigureAwait(false);
 
             await fileStream.FlushAsync(ctx.CancellationToken).ConfigureAwait(false);
 
@@ -1360,6 +1364,9 @@ await WaitWithProgressAsync(
             progress.Report(("plc_connect", 12.0, null, null));
             await using IPlcClient client = clientFactory(profiles);
 
+            // Inject processlogger for protocol-level tracing during handshake and bootloader setup
+            client.SetLogger(processLogger);
+
             effectiveTaskLogger.LogDebug("Connecting PLC client to localhost:{Port}", profiles.Socat.Port);
             await client.ConnectAsync(cancellationToken).ConfigureAwait(false);
 
@@ -1455,7 +1462,7 @@ await WaitWithProgressAsync(
 
             var dumpResult = await PerformDumpProcessStreamingAsync(
                 client, profiles,
-                progress, effectiveTaskLogger,
+                progress, effectiveTaskLogger, processLogger,
                 startPercent: 20.0, weight: 75.0,
                 taskId,
                 cancellationToken).ConfigureAwait(false);

src/S7Tools/Services/Plc/Adapters/PlcProtocolAdapter.cs

@@ -20,6 +20,7 @@ public sealed class PlcProtocolAdapter : IPlcProtocol
     {
         private readonly ILogger<PlcProtocolAdapter> _logger;
         private readonly IPlcTransport _transport;
+        private ILogger _effectiveLogger;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="PlcProtocolAdapter"/> class.
@@ -28,6 +29,18 @@ public PlcProtocolAdapter(IPlcTransport transport, ILogger<PlcProtocolAdapter> l
         {
             _transport = transport ?? throw new ArgumentNullException(nameof(transport));
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _effectiveLogger = _logger;
+        }
+
+        /// <summary>
+        /// Sets an optional session-specific logger (e.g., for task-specific protocol logging).
+        /// </summary>
+        public void SetLogger(ILogger? logger)
+        {
+            if (logger != null)
+            {
+                _effectiveLogger = logger;
+            }
         }
 
         /// <summary>
@@ -125,9 +138,9 @@ public async Task SendPacketAsync(byte[] payload, int? maxChunk = 2, Cancellatio
             await Task.Delay(10, cancellationToken).ConfigureAwait(false);
 
             var packet = EncodePacket(payload);
-            if (_logger.IsEnabled(LogLevel.Trace))
+            if (_effectiveLogger.IsEnabled(LogLevel.Trace))
             {
-                _logger.LogTrace("-> SEND: {Hex}", BitConverter.ToString(packet).Replace("-", ""));
+                _effectiveLogger.LogTrace("-> SEND: {Hex}", BitConverter.ToString(packet).Replace("-", ""));
             }
 
             int step = maxChunk ?? 2;
@@ -182,9 +195,9 @@ public async Task<byte[]> ReceivePacketAsync(CancellationToken cancellationToken
                 bytesRead += currentBytesRead;
             }
 
-            if (_logger.IsEnabled(LogLevel.Trace))
+            if (_effectiveLogger.IsEnabled(LogLevel.Trace))
             {
-                _logger.LogTrace("<- RECV: {Hex}", BitConverter.ToString(fullPacket).Replace("-", ""));
+                _effectiveLogger.LogTrace("<- RECV: {Hex}", BitConverter.ToString(fullPacket).Replace("-", ""));
             }
             return DecodePacket(fullPacket);
         }

src/S7Tools/Services/Tasking/TaskScheduler.cs

@@ -951,11 +951,7 @@ private async Task ExecuteTaskAsync(Guid taskId)
 
         try
         {
-            task.UpdateState(TaskState.Running, "Starting task execution");
-            TaskStateChanged?.Invoke(task);
-            _ = Task.Run(() => SaveTasksAsync(), CancellationToken.None); // Persist running state
-
-            // Create task-specific logger
+            // Create task-specific logger FIRST so UI auto-open has access to it when state changes to Running
             taskLogger = await _taskLoggerFactory.CreateTaskLoggerAsync(
                 taskId,
                 task.JobName,
@@ -964,6 +960,10 @@ private async Task ExecuteTaskAsync(Guid taskId)
 
             task.Logger = taskLogger;
 
+            task.UpdateState(TaskState.Running, "Starting task execution");
+            TaskStateChanged?.Invoke(task);
+            _ = Task.Run(() => SaveTasksAsync(), CancellationToken.None); // Persist running state
+
             // Log task start
             taskLogger.MainLogger?.LogInformation(
                 "Task execution started: {JobName} (ID: {TaskId}) at {StartTime}",

src/S7Tools/ViewModels/Layout/MainWindowViewModel.cs

@@ -173,6 +173,16 @@ public MainWindowViewModel(
 
         // Wire navigation to open content in dock tabs
         Navigation.OpenDocumentAction = vm => OpenDocumentTab(vm);
+        Navigation.OpenToolAction = vm => OpenToolTab(vm);
+
+        // Pre-wire TaskManagerViewModel so it can open task logs automatically
+        // even if the user hasn't visited the Tasks sidebar view yet
+        var taskManagerVm = _serviceProvider.GetService<ViewModels.Tasks.TaskManagerViewModel>();
+        if (taskManagerVm != null)
+        {
+            taskManagerVm.OpenDocumentAction = vm => OpenDocumentTab(vm);
+            taskManagerVm.OpenToolAction = vm => OpenToolTab(vm);
+        }
 
         _logger.LogDebug("MainWindowViewModel initialized with specialized ViewModels and docking system");
     }

src/S7Tools/ViewModels/Layout/NavigationViewModel.cs

@@ -101,6 +101,11 @@ public NavigationViewModel(
     /// </summary>
     public Action<IDockableViewModel>? OpenDocumentAction { get; set; }
 
+    /// <summary>
+    /// Action to open a tool window in the bottom dock panel.
+    /// </summary>
+    public Action<IDockableViewModel>? OpenToolAction { get; set; }
+
     /// <summary>
     /// Creates the welcome/initial ViewModel for the dock's default document.
     /// </summary>
@@ -418,10 +423,20 @@ private void NavigateToActivityBarItemContent(string itemId)
                 case "taskmanager":
                     SidebarTitle = UIStrings.Navigation_TaskManager;
                     TaskManagerShellViewModel? taskManagerShell = CreateViewModel<TaskManagerShellViewModel>();
-                    CurrentContent = taskManagerShell; // Sidebar categories
-                    ShowLogStats = false;
-                    // Open task manager as a dock tab
-                    OpenDockableContent(taskManagerShell);
+                    if (taskManagerShell != null)
+                    {
+                        taskManagerShell.OpenDocumentAction = OpenDocumentAction;
+                        taskManagerShell.OpenToolAction = OpenToolAction;
+                        CurrentContent = taskManagerShell; // Sidebar categories
+                        ShowLogStats = false;
+                        // Open task manager as a dock tab
+                        OpenDockableContent(taskManagerShell);
+                    }
+                    else
+                    {
+                        CurrentContent = null;
+                        ShowLogStats = false;
+                    }
                     _logger.LogDebug("Navigated to Task Manager");
                     break;