Properly report the exitcode without reporting we're stopping (or we won't trigger a restart)

Author: CodeCasterNL

docs/index.md

@@ -56,7 +56,13 @@ This library used to contain exception handling code in a base service, which is
 
 With the [retirement of .NET 5 on May 8, 2022](https://docs.microsoft.com/en-us/lifecycle/products/microsoft-net-and-net-core), this WindowsServiceExtensions library targets .NET (Platform Extensions) 6 going forward from v3.0.0.
 
-However, in the case of a background service excption, the service doesn't report an error to the Service Control Manager, who will think the process exited nicely. This library fixes that.
+However, in the case of a background service excption, the service doesn't report an error to the Service Control Manager, who will think the process exited nicely. So these are the scenarios:
+
+* You set `ServiceBase.ExitCode` to 0 and call `ServiceBase.Stop()`: no events will be logged, your service's recovery actions won't run.
+* You set `ServiceBase.ExitCode` to > 0 and call `ServiceBase.Stop()`: events 7023 ("service terminated with the following error") and 7034 (" service terminated unexpectedly") will be logged, your service's recovery actions won't run.
+* You set `ServiceBase.ExitCode` to > 0 and _don't_ call `ServiceBase.Stop()` but just exit the application: events 7031 ("service terminated unexpectedly.  It has done this N time(s).  The following corrective action will be taken") will be logged, your service's recovery actions will be executed.
+
+I prefer the latter, so that's what this library does.
 
 ## Host Builder (dependency injection)
 To receive session or power events, call `UseWindowsServiceExtensions()` on your Host Builder:

src/CodeCaster.WindowsServiceExtensions/Interop.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace CodeCaster.WindowsServiceExtensions
+{
+    internal static class Interop
+    {
+        internal static class Advapi32
+        {
+            [StructLayout(LayoutKind.Sequential)]
+            internal struct ServiceStatus
+            {
+                internal int serviceType;
+                internal int currentState;
+                internal int controlsAccepted;
+                internal int win32ExitCode;
+                internal int serviceSpecificExitCode;
+                internal int checkPoint;
+                internal int waitHint;
+            }
+
+            [DllImport("advapi32.dll", SetLastError = true)]
+            public static extern bool SetServiceStatus(IntPtr handle, ref ServiceStatus serviceStatus);
+        }
+    }
+}

src/CodeCaster.WindowsServiceExtensions/Lifetime/HostApplicationStartupLifetime.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Reflection;
+using System.ServiceProcess;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Hosting;
@@ -76,14 +78,50 @@ public HostApplicationStartupLifetime(IServiceProvider serviceProvider, IHostEnv
         /// </summary>
         public new Task StopAsync(CancellationToken cancellationToken)
         {
-            if (!OperatingSystem.IsWindows() || !WindowsServiceHelpers.IsWindowsService() || ExitCode == 0)
+            if (ExitCode == 0)
             {
                 base.StopAsync(cancellationToken);
             }
-            
+
             return Task.CompletedTask;
         }
 
+        /// <summary>
+        /// Sets the exit code and reports that back to the Service Control Manager.
+        ///
+        /// <see cref="ServiceBase.ExitCode"/> only gets flushed on Stop(), which we don't want to call on error.
+        /// </summary>
+        public new int ExitCode
+        {
+            get => base.ExitCode;
+            set
+            {
+                if (value < 0)
+                {
+                    throw new ArgumentException("ExitCode must be 0 or greater");
+                }
+
+                base.ExitCode = value;
+
+                var privateStatus = typeof(ServiceBase).GetField("_status", BindingFlags.NonPublic | BindingFlags.Instance)!.GetValue(this)!;
+
+                var finalStatus = new Interop.Advapi32.ServiceStatus
+                {
+                    win32ExitCode = value,
+                    //serviceSpecificExitCode = serviceSpecificExitCode,
+
+                    // Copy the properties from ServiceBase._status into a struct that we know.
+                    serviceType = GetStatusField(privateStatus, "serviceType"),
+                    checkPoint = GetStatusField(privateStatus, "checkPoint"),
+                    controlsAccepted = GetStatusField(privateStatus, "controlsAccepted"),
+                    waitHint = GetStatusField(privateStatus, "waitHint"),
+                    currentState = GetStatusField(privateStatus, "currentState"),
+                };
+
+                Interop.Advapi32.SetServiceStatus(ServiceHandle, ref finalStatus);
+            }
+        }
+
         /// <summary>
         /// Override to execute startup code, no need to call base. Async because who knows.
         /// </summary>
@@ -119,6 +157,12 @@ protected override void OnStart(string[] args)
             base.OnStart(args);
         }
 
+        private int GetStatusField(object privateStatus, string fieldName)
+        {
+            var field = privateStatus.GetType().GetField(fieldName);
+            return (int)field!.GetValue(privateStatus)!;
+        }
+
         /// <inheritdoc />
         protected override void Dispose(bool disposing)
         {

src/CodeCaster.WindowsServiceExtensions/Service/WindowsServiceBackgroundService.cs

@@ -63,25 +63,23 @@ protected sealed override async Task ExecuteAsync(CancellationToken stoppingToke
 
                 await TryExecuteAsync(stoppingToken);
             }
-            catch (Exception)
+            catch (Exception ex)
             {
-                Logger.LogInformation("Exception occurred, setting process exit code to {exitCode}", ErrorInvalidData);
+                Logger.LogInformation(ex, "Unhandled exception in {serviceType}, setting process exit code to {exitCode}:", GetType().FullName, ErrorInvalidData);
 
                 // The .NET host will shut down with code 0 if we don't do this.
                 Environment.ExitCode = ErrorInvalidData;
 
-#pragma warning disable CA1416 // Validate platform compatibility - we are a Windows Service.
                 if (ServiceLifetime != null)
                 {
                     Logger.LogDebug("Setting service exit code to {exitCode}", ErrorInvalidData);
 
                     // To report to the Service Control Manager on failure, is uint so > 0.
-                    ServiceLifetime.ExitCode = ErrorInvalidData + 1;
+                    // Do _not_ call ServiceBase.Stop() after this, or it'll think we exited successfully.
+                    ServiceLifetime.ExitCode = ErrorInvalidData;
                 }
-#pragma warning restore CA1416 // Validate platform compatibility
 
                 // Let the BackgroundService handle and log the exception.
-                // Do _not_ call ServiceBase.Stop(), or it'll think we exited successfully.
                 throw;
             }
         }

test/TestServiceThatThrows/Program.cs

@@ -25,7 +25,7 @@ public static async Task Main()
                 Debugger.Break();
             }
 
-            SecondsToWaitBeforeThrowing = Debugger.IsAttached ? 1 : 31;
+            SecondsToWaitBeforeThrowing = Debugger.IsAttached ? 1 : 5;
 
             await new HostBuilder()
                 .ConfigureLogging(l => l.AddConsole())