Fix issue 15806 ("aspire stop" is not cleaning up application containers) (#16006)

* Fix issue 15806

* Change default process start time check tolerance to 1 second

(to match the start time granularity used by the backchannel)

* Address code review feedback from Mitch

* Add ExecuteCommandUntilOutputAsync test helper

* Ensure containers are cleaned up by "aspire stop" command

* Improved check for container cleanup

Author: karolz-ms

src/Aspire.Cli/Aspire.Cli.csproj

@@ -129,6 +129,7 @@
     <Compile Include="$(SharedDir)ConsoleLogs\SharedAIHelpers.cs" Link="ConsoleLogs\SharedAIHelpers.cs" />
     <Compile Include="$(SharedDir)ConsoleLogs\TimestampParser.cs" Link="ConsoleLogs\TimestampParser.cs" />
     <Compile Include="$(SharedDir)ConsoleLogs\UrlParser.cs" Link="ConsoleLogs\UrlParser.cs" />
+    <Compile Include="$(SharedDir)ProcessSignaler.cs" Link="Utils\ProcessSignaler.cs" />
     <Compile Include="$(SharedDir)NpmVersionHelper.cs" Link="Utils\NpmVersionHelper.cs" />
   </ItemGroup>
 

src/Aspire.Cli/Commands/StopCommand.cs

@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
-using System.Diagnostics;
 using System.Globalization;
 using Aspire.Cli.Backchannel;
 using Aspire.Cli.Configuration;
@@ -193,16 +192,12 @@ private async Task<int> StopAppHostAsync(IAppHostAuxiliaryBackchannel connection
 
         _interactionService.DisplayMessage(KnownEmojis.StopSign, "Sending stop signal...");
 
-        // Get the CLI process ID - this is the process we need to kill
-        // Killing the CLI process will tear down everything including the AppHost
-        var cliProcessId = appHostInfo?.CliProcessId;
-
-        if (cliProcessId is int cliPid)
+        if (appHostInfo?.CliProcessId is int cliPid)
         {
             _logger.LogDebug("Sending stop signal to CLI process (PID {Pid})", cliPid);
             try
             {
-                SendStopSignal(cliPid);
+                SendStopSignal(cliPid, appHostInfo?.CliStartedAt);
             }
             catch (Exception ex)
             {
@@ -213,7 +208,7 @@ private async Task<int> StopAppHostAsync(IAppHostAuxiliaryBackchannel connection
         }
         else
         {
-            // Fallback: Try the RPC method if we don't have CLI process ID
+            // Fallback: Try the RPC method if we don't have CLI process ID.
             _logger.LogDebug("No CLI process ID available, trying RPC stop");
             var rpcSucceeded = false;
             try
@@ -228,10 +223,10 @@ private async Task<int> StopAppHostAsync(IAppHostAuxiliaryBackchannel connection
             // If RPC didn't work, try sending SIGINT to AppHost process directly
             if (!rpcSucceeded && appHostInfo?.ProcessId is int appHostPid)
             {
-                _logger.LogDebug("RPC stop not available, sending SIGINT to AppHost PID {Pid}", appHostPid);
+                _logger.LogDebug("RPC stop not available, sending SIGTERM to AppHost PID {Pid}", appHostPid);
                 try
                 {
-                    SendStopSignal(appHostPid);
+                    SendStopSignal(appHostPid, appHostInfo?.StartedAt);
                 }
                 catch (Exception ex)
                 {
@@ -247,21 +242,37 @@ private async Task<int> StopAppHostAsync(IAppHostAuxiliaryBackchannel connection
             }
         }
 
+        var manager = new RunningInstanceManager(_logger, _interactionService, _timeProvider);
         var stopped = await _interactionService.ShowStatusAsync(
             StopCommandStrings.StoppingAppHost,
             async () =>
             {
                 try
                 {
-                    // Wait for processes to terminate
-                    var manager = new RunningInstanceManager(_logger, _interactionService, _timeProvider);
+                    if (appHostInfo is null)
+                    {
+                        return true;
+                    }
+
+                    if (await manager.MonitorProcessesForTerminationAsync(appHostInfo, cancellationToken).ConfigureAwait(false))
+                    {
+                        return true;
+                    }
 
-                    if (appHostInfo is not null)
+                    var procsToKill = new HashSet<(int, DateTimeOffset?)> { (appHostInfo.ProcessId, appHostInfo.StartedAt) };
+
+                    if (appHostInfo.CliProcessId is int cliPid)
+                    {
+                        procsToKill.Add((cliPid, appHostInfo.CliStartedAt));
+                    }
+
+                    foreach (var (pid, startTime) in procsToKill)
                     {
-                        return await manager.MonitorProcessesForTerminationAsync(appHostInfo, cancellationToken).ConfigureAwait(false);
+                        _logger.LogWarning("AppHost did not stop gracefully within timeout. Forcing process {Pid} to terminate.", pid);
+                        ForceKillProcess(pid, startTime);
                     }
 
-                    return true;
+                    return await manager.MonitorProcessesForTerminationAsync(appHostInfo, cancellationToken).ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {
@@ -286,28 +297,21 @@ private async Task<int> StopAppHostAsync(IAppHostAuxiliaryBackchannel connection
     }
 
     /// <summary>
-    /// Sends a stop signal to a process to terminate it and its process tree.
-    /// Uses Process.Kill(entireProcessTree: true) to ensure all child processes are terminated.
+    /// Sends a best-effort graceful shutdown signal to the target process.
+    /// Uses Ctrl-Break on Windows and SIGTERM on non-Windows.
     /// </summary>
-    private static void SendStopSignal(int pid)
+    private void SendStopSignal(int pid, DateTimeOffset? startTime)
     {
-        try
-        {
-            using var process = Process.GetProcessById(pid);
-            process.Kill(entireProcessTree: true);
-        }
-        catch (ArgumentException)
-        {
-            // Process doesn't exist - already terminated
-        }
-        catch (InvalidOperationException)
-        {
-            // Process has already exited
-        }
-        catch (Exception)
-        {
-            // Some other error (e.g., permission denied) - ignore
-        }
+        ProcessSignaler.RequestGracefulShutdown(pid, startTime, _logger);
+    }
+
+    /// <summary>
+    /// Forcefully kills the target process after the graceful shutdown timeout elapses.
+    /// This does not terminate the entire process tree.
+    /// </summary>
+    private void ForceKillProcess(int pid, DateTimeOffset? startTime)
+    {
+        ProcessSignaler.ForceKill(pid, startTime, _logger);
     }
 
 }

src/Aspire.Cli/Processes/DetachedProcessLauncher.Windows.cs

@@ -77,16 +77,17 @@ private static Process StartWindows(string fileName, IReadOnlyList<string> argum
 
                     var si = new STARTUPINFOEX();
                     si.cb = Marshal.SizeOf<STARTUPINFOEX>();
-                    si.dwFlags = StartfUseStdHandles;
+                    si.dwFlags = StartfUseStdHandles | StartfUseShowWindow;
                     si.hStdInput = nint.Zero;
                     si.hStdOutput = nulRawHandle;
                     si.hStdError = nulRawHandle;
                     si.lpAttributeList = attrList;
+                    si.wShowWindow = ShowWindowHide;
 
                     // Build the command line string: "fileName" arg1 arg2 ...
                     var commandLine = BuildCommandLine(fileName, arguments);
 
-                    var flags = CreateUnicodeEnvironment | ExtendedStartupInfoPresent | CreateNoWindow;
+                    var flags = CreateUnicodeEnvironment | ExtendedStartupInfoPresent | CreateNewProcessGroup;
 
                     // Build a filtered environment block if variables need to be removed.
                     // CreateProcessW with lpEnvironment=nint.Zero inherits the parent's
@@ -293,9 +294,11 @@ private static nint BuildFilteredEnvironmentBlock(Func<string, bool> shouldRemov
     private const uint OpenExisting = 3;
     private const uint HandleFlagInherit = 0x00000001;
     private const uint StartfUseStdHandles = 0x00000100;
+    private const uint StartfUseShowWindow = 0x00000001;
     private const uint CreateUnicodeEnvironment = 0x00000400;
     private const uint ExtendedStartupInfoPresent = 0x00080000;
-    private const uint CreateNoWindow = 0x08000000;
+    private const uint CreateNewProcessGroup = 0x00000200;
+    private const ushort ShowWindowHide = 0x0000;
     private static readonly nint s_procThreadAttributeHandleList = (nint)0x00020002;
 
     // --- Structs ---

src/Aspire.Cli/Program.cs

@@ -5,6 +5,7 @@
 using System.CommandLine.Parsing;
 using System.Diagnostics;
 using System.Globalization;
+using System.Runtime.InteropServices;
 using System.Text;
 using System.Text.Json;
 using Aspire.Cli.Agents;
@@ -680,6 +681,13 @@ public static async Task<int> Main(string[] args)
             cts.Cancel();
             eventArgs.Cancel = true;
         };
+        using var sigTermRegistration = OperatingSystem.IsWindows()
+            ? null
+            : PosixSignalRegistration.Create(PosixSignal.SIGTERM, context =>
+            {
+                cts.Cancel();
+                context.Cancel = true;
+            });
 
         Console.OutputEncoding = Encoding.UTF8;
 
@@ -695,6 +703,7 @@ public static async Task<int> Main(string[] args)
         // Logging the log file path is useful so that when console logging is enabled (for example with --log-level debug),
         // the path is written to the console logger (stderr) for easier discovery.
         logger.LogInformation("Log file: {LogFilePath}", loggingOptions.LogFilePath);
+        logger.LogInformation("CLI process ID: {ProcessId}", Environment.ProcessId);
 
         IHost? app = null;
         try

src/Aspire.Hosting/Aspire.Hosting.csproj

@@ -56,6 +56,7 @@
     <Compile Include="$(SharedDir)UserSecrets\UserSecretsPathHelper.cs" Link="UserSecrets\UserSecretsPathHelper.cs" />
     <Compile Include="$(SharedDir)X509Certificate2Extensions.cs" Link="Utils\X509Certificate2Extensions.cs" />
     <Compile Include="$(SharedDir)PasswordGenerator.cs" Link="Utils\PasswordGenerator.cs" />
+    <Compile Include="$(SharedDir)ProcessSignaler.cs" Link="Utils\ProcessSignaler.cs" />
   </ItemGroup>
 
   <ItemGroup>

src/Aspire.Hosting/Backchannel/AuxiliaryBackchannelRpcTarget.cs

@@ -366,13 +366,20 @@ public Task<AppHostInformation> GetAppHostInformationAsync(CancellationToken can
         {
             cliProcessId = parsedCliPid;
         }
+        DateTimeOffset? cliStartedAt = null;
+        var cliStartedAtString = configuration[KnownConfigNames.CliProcessStarted];
+        if (!string.IsNullOrEmpty(cliStartedAtString) && long.TryParse(cliStartedAtString, out var parsedCliStartedAt))
+        {
+            cliStartedAt = DateTimeOffset.FromUnixTimeSeconds(parsedCliStartedAt);
+        }
 
         return Task.FromResult(new AppHostInformation
         {
             AppHostPath = appHostPath,
             ProcessId = Environment.ProcessId,
             CliProcessId = cliProcessId,
-            StartedAt = new DateTimeOffset(Process.GetCurrentProcess().StartTime)
+            StartedAt = new DateTimeOffset(Process.GetCurrentProcess().StartTime),
+            CliStartedAt = cliStartedAt
         });
     }
 

src/Aspire.Hosting/Backchannel/BackchannelDataTypes.cs

@@ -1020,6 +1020,12 @@ internal sealed class AppHostInformation
     /// Gets or sets when the AppHost process started.
     /// </summary>
     public DateTimeOffset? StartedAt { get; init; }
+
+    /// <summary>
+    /// Gets or sets when the CLI process that launched the AppHost started.
+    /// This value is only set when the AppHost is launched via the Aspire CLI.
+    /// </summary>
+    public DateTimeOffset? CliStartedAt { get; init; }
 }
 
 /// <summary>

src/Aspire.Hosting/Cli/CliOrphanDetector.cs

@@ -1,7 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Diagnostics;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
@@ -12,37 +11,14 @@ internal sealed class CliOrphanDetector(IConfiguration configuration, IHostAppli
 {
     internal Func<int, bool> IsProcessRunning { get; set; } = (int pid) =>
     {
-        try
-        {
-            return !Process.GetProcessById(pid).HasExited;
-        }
-        catch (ArgumentException)
-        {
-            // If Process.GetProcessById throws it means the process in not running.
-            return false;
-        }
+        using var process = ProcessSignaler.TryGetRunningProcess(pid, null, logger);
+        return process is not null;
     };
 
     internal Func<int, long, bool> IsProcessRunningWithStartTime { get; set; } = (int pid, long expectedStartTimeUnix) =>
     {
-        try
-        {
-            var process = Process.GetProcessById(pid);
-            if (process.HasExited)
-            {
-                return false;
-            }
-
-            // Check if the process start time matches the expected start time exactly.
-            var actualStartTimeUnix = ((DateTimeOffset)process.StartTime).ToUnixTimeSeconds();
-            return actualStartTimeUnix == expectedStartTimeUnix;
-        }
-        catch
-        {
-            // If we can't get the process and/or can't get the start time, 
-            // then we interpret both exceptions as the process not being there.
-            return false;
-        }
+        using var process = ProcessSignaler.TryGetRunningProcess(pid, DateTimeOffset.FromUnixTimeSeconds(expectedStartTimeUnix), logger);
+        return process is not null;
     };
 
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)