Send Ctrl+C to launched process before killing it on Windows

Author: tmat

src/BuiltInTools/dotnet-watch/HotReload/CompilationHandler.cs

@@ -130,7 +130,7 @@ public async ValueTask StartSessionAsync(CancellationToken cancellationToken)
             };
 
             var launchResult = new ProcessLaunchResult();
-            var runningProcess = _processRunner.RunAsync(processSpec, processReporter, isUserApplication: true, launchResult, processTerminationSource.Token);
+            var runningProcess = _processRunner.RunAsync(processSpec, processReporter, launchResult, processTerminationSource.Token);
             if (launchResult.ProcessId == null)
             {
                 // error already reported

src/BuiltInTools/dotnet-watch/HotReload/HotReloadDotNetWatcher.cs

@@ -796,6 +796,7 @@ await FileWatcher.WaitForFileChangeAsync(
             {
                 Executable = _context.EnvironmentOptions.MuxerPath,
                 WorkingDirectory = Path.GetDirectoryName(projectPath)!,
+                IsUserApplication = false,
                 OnOutput = line =>
                 {
                     lock (buildOutput)
@@ -804,12 +805,12 @@ await FileWatcher.WaitForFileChangeAsync(
                     }
                 },
                 // pass user-specified build arguments last to override defaults:
-                Arguments = ["build", projectPath, "-consoleLoggerParameters:NoSummary;Verbosity=minimal", .. binLogArguments, .. buildArguments]
+                Arguments = ["build", projectPath, "-consoleLoggerParameters:NoSummary;Verbosity=minimal", .. binLogArguments, .. buildArguments],
             };
 
             _context.Reporter.Output($"Building {projectPath} ...");
 
-            var exitCode = await _context.ProcessRunner.RunAsync(processSpec, _context.Reporter, isUserApplication: false, launchResult: null, cancellationToken);
+            var exitCode = await _context.ProcessRunner.RunAsync(processSpec, _context.Reporter, launchResult: null, cancellationToken);
             return (exitCode == 0, buildOutput.ToImmutableArray(), projectPath);
         }
 

src/BuiltInTools/dotnet-watch/Process/ProcessRunner.cs

@@ -22,8 +22,7 @@ private sealed class ProcessState
         /// <summary>
         /// Launches a process.
         /// </summary>
-        /// <param name="isUserApplication">True if the process is a user application, false if it is a helper process (e.g. msbuild).</param>
-        public async Task<int> RunAsync(ProcessSpec processSpec, IReporter reporter, bool isUserApplication, ProcessLaunchResult? launchResult, CancellationToken processTerminationToken)
+        public async Task<int> RunAsync(ProcessSpec processSpec, IReporter reporter, ProcessLaunchResult? launchResult, CancellationToken processTerminationToken)
         {
             var state = new ProcessState();
             var stopwatch = new Stopwatch();
@@ -90,12 +89,12 @@ public async Task<int> RunAsync(ProcessSpec processSpec, IReporter reporter, boo
                     // Either Ctrl+C was pressed or the process is being restarted.
 
                     // Non-cancellable to not leave orphaned processes around blocking resources:
-                    await TerminateProcessAsync(process, state, reporter, CancellationToken.None);
+                    await TerminateProcessAsync(process, processSpec, state, reporter, CancellationToken.None);
                 }
             }
             catch (Exception e)
             {
-                if (isUserApplication)
+                if (processSpec.IsUserApplication)
                 {
                     reporter.Error($"Application failed: {e.Message}");
                 }
@@ -117,7 +116,7 @@ public async Task<int> RunAsync(ProcessSpec processSpec, IReporter reporter, boo
 
                 reporter.Verbose($"Process id {process.Id} ran for {stopwatch.ElapsedMilliseconds}ms and exited with exit code {exitCode}.");
 
-                if (isUserApplication)
+                if (processSpec.IsUserApplication)
                 {
                     if (exitCode == 0)
                     {
@@ -154,6 +153,7 @@ private static Process CreateProcess(ProcessSpec processSpec, Action<OutputLine>
                     WorkingDirectory = processSpec.WorkingDirectory,
                     RedirectStandardOutput = onOutput != null,
                     RedirectStandardError = onOutput != null,
+                    CreateNewProcessGroup = processSpec.IsUserApplication && RuntimeInformation.IsOSPlatform(OSPlatform.Windows),
                 }
             };
 
@@ -210,24 +210,20 @@ private static Process CreateProcess(ProcessSpec processSpec, Action<OutputLine>
             return process;
         }
 
-        private async ValueTask TerminateProcessAsync(Process process, ProcessState state, IReporter reporter, CancellationToken cancellationToken)
+        private async ValueTask TerminateProcessAsync(Process process, ProcessSpec processSpec, ProcessState state, IReporter reporter, CancellationToken cancellationToken)
         {
             if (!shutdownCancellationToken.IsCancellationRequested)
             {
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                var forceOnly = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && !processSpec.IsUserApplication;
+
+                // Ctrl+C hasn't been sent.
+                TerminateProcess(process, state, reporter, forceOnly);
+
+                if (forceOnly)
                 {
-                    // Ctrl+C hasn't been sent, force termination.
-                    // We don't have means to terminate gracefully on Windows (https://github.com/dotnet/runtime/issues/109432)
-                    TerminateProcess(process, state, reporter, force: true);
                     _ = await WaitForExitAsync(process, state, timeout: null, reporter, cancellationToken);
-
                     return;
                 }
-                else
-                {
-                    // Ctrl+C hasn't been sent, send SIGTERM now:
-                    TerminateProcess(process, state, reporter, force: false);
-                }
             }
 
             // Ctlr+C/SIGTERM has been sent, wait for the process to exit gracefully.
@@ -327,40 +323,28 @@ private static void TerminateProcess(Process process, ProcessState state, IRepor
 
         private static void TerminateWindowsProcess(Process process, ProcessState state, IReporter reporter, bool force)
         {
-            // Needs API: https://github.com/dotnet/runtime/issues/109432
-            // Code below does not work because the process creation needs CREATE_NEW_PROCESS_GROUP flag.
-
-            reporter.Verbose($"Terminating process {state.ProcessId}.");
+            reporter.Verbose($"Terminating process {state.ProcessId} ({(force ? "Kill" : "Ctrl+C")}).");
 
             if (force)
             {
                 process.Kill();
             }
-#if TODO
             else
             {
                 const uint CTRL_C_EVENT = 0;
 
                 [DllImport("kernel32.dll", SetLastError = true)]
+                [return: MarshalAs(UnmanagedType.Bool)]
                 static extern bool GenerateConsoleCtrlEvent(uint dwCtrlEvent, uint dwProcessGroupId);
 
-                [DllImport("kernel32.dll", SetLastError = true)]
-                static extern bool AttachConsole(uint dwProcessId);
-
-                [DllImport("kernel32.dll", SetLastError = true)]
-                static extern bool FreeConsole();
-
-                if (AttachConsole((uint)state.ProcessId) &&
-                    GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0) &&
-                    FreeConsole())
+                if (GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0))
                 {
                     return;
                 }
 
                 var error = Marshal.GetLastPInvokeError();
                 reporter.Verbose($"Failed to send Ctrl+C to process {state.ProcessId}: {Marshal.GetPInvokeErrorMessage(error)} (code {error})");
             }
-#endif
         }
 
         private static void TerminateUnixProcess(ProcessState state, IReporter reporter, bool force)

src/BuiltInTools/dotnet-watch/Process/ProcessSpec.cs

@@ -15,6 +15,11 @@ internal sealed class ProcessSpec
         public ProcessExitAction? OnExit { get; set; }
         public CancellationToken CancelOutputCapture { get; set; }
 
+        /// <summary>
+        /// True if the process is a user application, false if it is a helper process (e.g. dotnet build).</param>
+        /// </summary>
+        public bool IsUserApplication { get; set; }
+
         public string? ShortDisplayName()
             => Path.GetFileNameWithoutExtension(Executable);
 

src/BuiltInTools/dotnet-watch/Process/ProjectLauncher.cs

@@ -47,8 +47,9 @@ public EnvironmentOptions EnvironmentOptions
         var processSpec = new ProcessSpec
         {
             Executable = EnvironmentOptions.MuxerPath,
+            IsUserApplication = true,
             WorkingDirectory = projectOptions.WorkingDirectory,
-            OnOutput = onOutput
+            OnOutput = onOutput,
         };
 
         var environmentBuilder = EnvironmentVariablesBuilder.FromCurrentEnvironment();

src/BuiltInTools/dotnet-watch/Watch/DotNetWatcher.cs

@@ -53,6 +53,7 @@ public static async Task WatchAsync(DotNetWatchContext context, CancellationToke
                 {
                     Executable = context.EnvironmentOptions.MuxerPath,
                     WorkingDirectory = context.EnvironmentOptions.WorkingDirectory,
+                    IsUserApplication = true,
                     Arguments = buildEvaluator.GetProcessArguments(iteration),
                     EnvironmentVariables =
                     {
@@ -81,7 +82,7 @@ public static async Task WatchAsync(DotNetWatchContext context, CancellationToke
 
                 fileSetWatcher.WatchContainingDirectories(evaluationResult.Files.Keys, includeSubdirectories: true);
 
-                var processTask = context.ProcessRunner.RunAsync(processSpec, context.Reporter, isUserApplication: true, launchResult: null, combinedCancellationSource.Token);
+                var processTask = context.ProcessRunner.RunAsync(processSpec, context.Reporter, launchResult: null, combinedCancellationSource.Token);
 
                 Task<ChangedFile?> fileSetTask;
                 Task finishedTask;

src/BuiltInTools/dotnet-watch/Watch/MsBuildFileSetFactory.cs

@@ -49,6 +49,7 @@ internal sealed class EvaluationResult(IReadOnlyDictionary<string, FileItem> fil
                 {
                     Executable = EnvironmentOptions.MuxerPath,
                     WorkingDirectory = projectDir,
+                    IsUserApplication = false,
                     Arguments = arguments,
                     OnOutput = line =>
                     {
@@ -61,7 +62,7 @@ internal sealed class EvaluationResult(IReadOnlyDictionary<string, FileItem> fil
 
                 Reporter.Verbose($"Running MSBuild target '{TargetName}' on '{rootProjectFile}'");
 
-                var exitCode = await processRunner.RunAsync(processSpec, Reporter, isUserApplication: false, launchResult: null, cancellationToken);
+                var exitCode = await processRunner.RunAsync(processSpec, Reporter, launchResult: null, cancellationToken);
 
                 var success = exitCode == 0 && File.Exists(watchList);