Do not return from CTRL_SHUTDOWN_EVENT (#116652)

* Do not return from CTRL_SHUTDOWN_EVENT

Windows will kill the process after it completes handling CTRL_SHUTDOWN_EVENT

To avoid this, we add a delay to our handler.  This allows the process
to exit before the handler returns.

We use HostOptions.ShutdownTimeout for the delay.  This does mean that
other SIGTERM handlers will not run, but that's a tradeoff we have to
make to ensure the process isn't killed.

* Update ConsoleLifetime.netcoreapp.cs

Author: ericstj

src/libraries/Microsoft.Extensions.Hosting/src/Internal/ConsoleLifetime.netcoreapp.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
+using System.Threading;
 
 namespace Microsoft.Extensions.Hosting.Internal
 {
@@ -20,7 +21,7 @@ private partial void RegisterShutdownHandlers()
                 Action<PosixSignalContext> handler = HandlePosixSignal;
                 _sigIntRegistration = PosixSignalRegistration.Create(PosixSignal.SIGINT, handler);
                 _sigQuitRegistration = PosixSignalRegistration.Create(PosixSignal.SIGQUIT, handler);
-                _sigTermRegistration = PosixSignalRegistration.Create(PosixSignal.SIGTERM, handler);
+                _sigTermRegistration = PosixSignalRegistration.Create(PosixSignal.SIGTERM, OperatingSystem.IsWindows() ? HandleWindowsShutdown : handler);
             }
         }
 
@@ -32,6 +33,24 @@ private void HandlePosixSignal(PosixSignalContext context)
             ApplicationLifetime.StopApplication();
         }
 
+        private void HandleWindowsShutdown(PosixSignalContext context)
+        {
+            // for SIGTERM on Windows we must block this thread until the application is finished
+            // otherwise the process will be killed immediately on return from this handler
+
+            // don't allow Dispose to unregister handlers, since Windows has a lock that prevents the unregistration while this handler is running
+            // just leak these, since the process is exiting
+            _sigIntRegistration = null;
+            _sigQuitRegistration = null;
+            _sigTermRegistration = null;
+
+            ApplicationLifetime.StopApplication();
+
+            // We could wait for a signal here, like Dispose as is done in non-netcoreapp case, but those inevitably could have user
+            // code that runs after them in the user's Main. Instead we just block this thread completely and let the main routine exit.
+            Thread.Sleep(HostOptions.ShutdownTimeout);
+        }
+
         private partial void UnregisterShutdownHandlers()
         {
             _sigIntRegistration?.Dispose();

src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/ConsoleLifetimeExitTests.cs

@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.IO;
+using System.IO.Pipes;
+using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
@@ -18,14 +21,22 @@ public class ConsoleLifetimeExitTests
         /// and the rest of "main" gets executed.
         /// </summary>
         [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        [PlatformSpecific(TestPlatforms.AnyUnix)]
         [InlineData(SIGTERM)]
         [InlineData(SIGINT)]
         [InlineData(SIGQUIT)]
         public async Task EnsureSignalContinuesMainMethod(int signal)
         {
-            using var remoteHandle = RemoteExecutor.Invoke(async () =>
+            // simulate signals on Windows by using a pipe to communicate with the remote process
+            using var messagePipe = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable);
+
+            using var remoteHandle = RemoteExecutor.Invoke(async (pipeHandleAsString) =>
             {
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    // kick off a thread to simulate the signal on Windows
+                    _ = Task.Run(() => SimulatePosixSignalWindows(pipeHandleAsString));
+                }
+
                 await Host.CreateDefaultBuilder()
                     .ConfigureServices((hostContext, services) =>
                     {
@@ -40,7 +51,7 @@ await Host.CreateDefaultBuilder()
 
                 Console.WriteLine("Run has completed");
                 return 123;
-            }, new RemoteInvokeOptions() { Start = false, ExpectedExitCode = 123 });
+            }, messagePipe.GetClientHandleAsString(), new RemoteInvokeOptions() { Start = false, ExpectedExitCode = 123 });
 
             remoteHandle.Process.StartInfo.RedirectStandardOutput = true;
             remoteHandle.Process.Start();
@@ -53,7 +64,16 @@ await Host.CreateDefaultBuilder()
             }
 
             // send the signal to the process
-            kill(remoteHandle.Process.Id, signal);
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                // on Windows, we use the pipe to signal the process
+                messagePipe.WriteByte((byte)signal);
+            }
+            else
+            {
+                // on Unix, we send the signal directly
+                kill(remoteHandle.Process.Id, signal);
+            }
 
             remoteHandle.Process.WaitForExit();
 
@@ -69,6 +89,69 @@ await Host.CreateDefaultBuilder()
         [DllImport("libc", SetLastError = true)]
         private static extern int kill(int pid, int sig);
 
+
+        private const int CTRL_C_EVENT = 0;
+        private const int CTRL_BREAK_EVENT = 1;
+        private const int CTRL_CLOSE_EVENT = 2;
+        private const int CTRL_LOGOFF_EVENT = 5;
+        private const int CTRL_SHUTDOWN_EVENT = 6;
+
+        private static unsafe void SimulatePosixSignalWindows(string pipeHandleAsString)
+        {
+            try
+            {
+                using var readPipe = new AnonymousPipeClientStream(PipeDirection.In, pipeHandleAsString);
+
+                int signal = (int)readPipe.ReadByte();
+
+                int ctrlType = (int)signal switch
+                {
+                    SIGINT => CTRL_C_EVENT,
+                    SIGQUIT => CTRL_BREAK_EVENT,
+                    SIGTERM => CTRL_SHUTDOWN_EVENT,
+                    _ => throw new ArgumentOutOfRangeException(nameof(signal), "Unsupported signal")
+                };
+
+#if NETFRAMEWORK
+            if (ctrlType == CTRL_C_EVENT || ctrlType == CTRL_BREAK_EVENT)            
+            {
+                var handlerMethod = Type.GetType("System.Console, mscorlib")?.GetMethod("BreakEvent", BindingFlags.NonPublic | BindingFlags.Static);
+                Assert.NotNull(handlerMethod);
+                handlerMethod.Invoke(null, [ctrlType]);
+            }
+            else // CTRL_SHUTDOWN_EVENT
+            {
+                var handlerField = typeof(AppDomain).GetField("_processExit", BindingFlags.NonPublic | BindingFlags.Instance);
+                Assert.NotNull(handlerField);
+                EventHandler handler = (EventHandler)handlerField.GetValue(AppDomain.CurrentDomain);
+                Assert.NotNull(handler);
+                handler.Invoke(AppDomain.CurrentDomain, null);
+            }
+#else
+                // get the System.Runtime.InteropServices.PosixSignalRegistration.HandlerRoutine private method
+                var handlerMethod = typeof(PosixSignalRegistration).GetMethod("HandlerRoutine", BindingFlags.NonPublic | BindingFlags.Static);
+                Assert.NotNull(handlerMethod);
+
+                var handlerPtr = handlerMethod.MethodHandle.GetFunctionPointer();
+                delegate* unmanaged<int, int> handler = (delegate* unmanaged<int, int>)handlerPtr;
+
+                handler(ctrlType);
+
+                if (signal == SIGTERM)
+                {
+                    // on Windows the OS will kill the process immediately after this
+                    Environment.FailFast("Simulating shutdown");
+                }
+#endif
+            }
+            catch (Exception ex)
+            {
+                // Exceptions on this thread will not be observed, nor will they cause the process to exit.
+                // Use failfast to ensure the process will exit without running any handlers. 
+                Environment.FailFast(ex.ToString());
+            }
+        }
+
         private class EnsureSignalContinuesMainMethodWorker : BackgroundService
         {
             protected override async Task ExecuteAsync(CancellationToken stoppingToken)

src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/Microsoft.Extensions.Hosting.Unit.Tests.csproj

@@ -4,6 +4,7 @@
     <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);$(NetFrameworkCurrent)</TargetFrameworks>
     <EnableDefaultItems>true</EnableDefaultItems>
     <IncludeRemoteExecutor>true</IncludeRemoteExecutor>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <AutoGenerateBindingRedirects Condition="$([MSBuild]::GetTargetFrameworkIdentifier('$(TargetFramework)')) == '.NETFramework'">true</AutoGenerateBindingRedirects>
     <EventSourceSupport Condition="'$(TestNativeAot)' == 'true'">true</EventSourceSupport>
   </PropertyGroup>