2

Author: tmat

src/BuiltInTools/DotNetDeltaApplier/StartupHook.cs

@@ -3,7 +3,6 @@
 
 using System.Diagnostics;
 using System.IO.Pipes;
-using System.Reflection;
 using Microsoft.DotNet.HotReload;
 
 /// <summary>
@@ -16,14 +15,22 @@ internal sealed class StartupHook
     private static readonly bool s_logToStandardOutput = Environment.GetEnvironmentVariable(AgentEnvironmentVariables.HotReloadDeltaClientLogMessages) == "1";
     private static readonly string? s_namedPipeName = Environment.GetEnvironmentVariable(AgentEnvironmentVariables.DotNetWatchHotReloadNamedPipeName);
 
+#if NET10_0_OR_GREATER
+    private const string TargetFramework = "net10.0";
+
+    private static PosixSignalRegistration? s_signalRegistration;
+#else
+    private const string TargetFramework = "netstandard2.1";
+#endif
+
     /// <summary>
     /// Invoked by the runtime when the containing assembly is listed in DOTNET_STARTUP_HOOKS.
     /// </summary>
     public static void Initialize()
     {
         var processPath = Environment.GetCommandLineArgs().FirstOrDefault();
 
-        Log($"Loaded into process: {processPath}");
+        Log($"Loaded into process: {processPath} ({TargetFramework})");
 
         HotReloadAgent.ClearHotReloadEnvironmentVariables(typeof(StartupHook));
 
@@ -85,11 +92,11 @@ private static void RegisterPosixSignalHandlers()
         // Note: registered handlers are executed in reverse order of their registration.
         // Since the startup hook is executed before any code of the application, it is the first handler registered and thus the last to run.
 
-        _ = PosixSignalRegistration.Create(PosixSignal.SIGTERM, context =>
+        s_signalRegistration = PosixSignalRegistration.Create(PosixSignal.SIGTERM, context =>
         {
             Log($"SIGTERM received. Cancel={context.Cancel}");
 
-            if (!context.Cancel)
+            //if (!context.Cancel)
             {
                 Environment.Exit(0);
             }

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

@@ -3,6 +3,7 @@
 
 
 using System.Diagnostics;
+using Microsoft.DotNet.Cli.Utils;
 
 namespace Microsoft.DotNet.Watch
 {
@@ -84,7 +85,7 @@ public async Task<int> RunAsync(ProcessSpec processSpec, IReporter reporter, boo
             {
                 try
                 {
-                    _ = await WaitForExitAsync(process, timeout: null, processTerminationToken);
+                    _ = await WaitForExitAsync(process, timeout: null, reporter: null, processTerminationToken);
                 }
                 catch (OperationCanceledException)
                 {
@@ -221,7 +222,7 @@ private async ValueTask TerminateProcessAsync(Process process, ProcessState stat
                     // 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, timeout: null, cancellationToken);
+                    _ = await WaitForExitAsync(process, state, timeout: null, reporter, cancellationToken);
 
                     return;
                 }
@@ -233,30 +234,39 @@ private async ValueTask TerminateProcessAsync(Process process, ProcessState stat
             }
 
             // Ctlr+C/SIGTERM has been sent, wait for the process to exit gracefully.
-            if (!await WaitForExitAsync(process, processCleanupTimeout, cancellationToken))
+            if (!await WaitForExitAsync(process, state, processCleanupTimeout, reporter, cancellationToken))
             {
                 // Force termination if the process is still running after the timeout.
                 TerminateProcess(process, state, reporter, force: true);
 
-                _ = await WaitForExitAsync(process, timeout: null, cancellationToken);
+                _ = await WaitForExitAsync(process, state, timeout: null, reporter, cancellationToken);
             }
         }
 
-        private static async ValueTask<bool> WaitForExitAsync(Process process, TimeSpan? timeout, CancellationToken cancellationToken)
+        private static async ValueTask<bool> WaitForExitAsync(Process process, ProcessState state, TimeSpan? timeout, IReporter? reporter, CancellationToken cancellationToken)
         {
             var task = process.WaitForExitAsync(cancellationToken);
 
             if (timeout.HasValue)
             {
                 try
                 {
+                    reporter?.Verbose($"Waiting for process {state.ProcessId} to exit within {timeout.Value.TotalSeconds}s.");
                     await task.WaitAsync(timeout.Value, cancellationToken);
                 }
                 catch (TimeoutException)
                 {
                     return false;
                 }
             }
+            else if (reporter?.IsVerbose == true)
+            {
+                int i = 0;
+                while (Task.WaitAny([task, Task.Delay(TimeSpan.FromSeconds(5), cancellationToken)], cancellationToken) != 0)
+                {
+                    reporter.Verbose($"Waiting for process {state.ProcessId} to exit ({i++}).");
+                }
+            }
             else
             {
                 await task;
@@ -265,6 +275,7 @@ private static async ValueTask<bool> WaitForExitAsync(Process process, TimeSpan?
             // ensures that all process output has been reported:
             try
             {
+                reporter?.Verbose($"Waiting for output of process {state.ProcessId} to complete.");
                 process.WaitForExit();
             }
             catch