override BackgroundService.StartAsync to add logging

Author: smdn

src/Smdn.Net.MuninNode.Hosting/Smdn.Net.MuninNode.Hosting/MuninNodeBackgroundService.cs

@@ -16,6 +16,11 @@ public class MuninNodeBackgroundService : BackgroundService {
     eventId: default, // TODO
     formatString: "Munin node '{HostName}' starting."
   );
+  private static readonly Action<ILogger, string, Exception?> LogStarted = LoggerMessage.Define<string>(
+    LogLevel.Information,
+    eventId: default, // TODO
+    formatString: "Munin node '{HostName}' started."
+  );
   private static readonly Action<ILogger, string, Exception?> LogStopping = LoggerMessage.Define<string>(
     LogLevel.Information,
     eventId: default, // TODO
@@ -79,14 +84,27 @@ public override void Dispose()
     GC.SuppressFinalize(this);
   }
 
-  protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+  public override async Task StartAsync(CancellationToken cancellationToken)
   {
     if (node is null)
       throw new ObjectDisposedException(GetType().FullName);
 
+    cancellationToken.ThrowIfCancellationRequested();
+
     if (Logger is not null)
       LogStarting(Logger, node.HostName, null);
 
+    await base.StartAsync(cancellationToken).ConfigureAwait(false);
+
+    if (Logger is not null)
+      LogStarted(Logger, node.HostName, null);
+  }
+
+  protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+  {
+    if (node is null)
+      throw new ObjectDisposedException(GetType().FullName);
+
     await node.RunAsync(stoppingToken).ConfigureAwait(false);
   }
 

tests/Smdn.Net.MuninNode.Hosting/Smdn.Net.MuninNode.Hosting/MuninNodeBackgroundService.cs

@@ -132,6 +132,99 @@ await reader.ReadLineAsync(cancellationToken),
     }
   }
 
+  private class EmptyPluginProvider : IPluginProvider {
+    public IReadOnlyCollection<IPlugin> Plugins { get; } = [];
+    public INodeSessionCallback? SessionCallback => null;
+  }
+
+  private class EmptyNode : LocalNode {
+    public override IPluginProvider PluginProvider { get; } = new EmptyPluginProvider();
+    public override string HostName => "munin-node.localhost";
+
+    public EmptyNode()
+      : base(
+        listenerFactory: null,
+        accessRule: null,
+        logger: null
+      )
+    {
+    }
+  }
+
+  private class HookStartNode : EmptyNode {
+    public EventHandler? Starting = null;
+    public EventHandler? Started = null;
+
+    public HookStartNode()
+      : base()
+    {
+    }
+
+    protected override ValueTask StartingAsync(CancellationToken cancellationToken)
+    {
+      Starting?.Invoke(this, EventArgs.Empty);
+
+      return default;
+    }
+
+    protected override ValueTask StartedAsync(CancellationToken cancellationToken)
+    {
+      Started?.Invoke(this, EventArgs.Empty);
+
+      return default;
+    }
+  }
+
+  [Test]
+  public void StartAsync_CancellationRequestedBeforeStarting()
+  {
+    var numberOfTimesStartingInvoked = 0;
+    var numberOfTimesStartedInvoked = 0;
+
+    using var hookStartNode = new HookStartNode();
+
+    hookStartNode.Starting += (_, _) => numberOfTimesStartingInvoked++;
+    hookStartNode.Started += (_, _) => numberOfTimesStartedInvoked++;
+
+    using var muninNodeService = new MuninNodeBackgroundService(hookStartNode);
+
+    // start service
+    Assert.That(
+      async () => await muninNodeService.StartAsync(cancellationToken: new(canceled: true)),
+      Throws.InstanceOf<OperationCanceledException>()
+    );
+
+    Assert.That(numberOfTimesStartingInvoked, Is.Zero);
+    Assert.That(numberOfTimesStartedInvoked, Is.Zero);
+  }
+
+  [Test]
+  public void StartAsync_CancellationRequestedWhileStarting()
+  {
+    var numberOfTimesStartingInvoked = 0;
+    var numberOfTimesStartedInvoked = 0;
+
+    using var hookStartNode = new HookStartNode();
+    using var ctsStarting = new CancellationTokenSource();
+
+    hookStartNode.Starting += (_, _) => {
+      numberOfTimesStartingInvoked++;
+      ctsStarting.Cancel();
+    };
+    hookStartNode.Started += (_, _) => numberOfTimesStartedInvoked++;
+
+    using var muninNodeService = new MuninNodeBackgroundService(hookStartNode);
+
+    // start service
+    Assert.That(
+      async () => await muninNodeService.StartAsync(cancellationToken: ctsStarting.Token),
+      Throws.InstanceOf<OperationCanceledException>()
+    );
+
+    Assert.That(numberOfTimesStartingInvoked, Is.EqualTo(1));
+    Assert.That(numberOfTimesStartedInvoked, Is.Zero);
+  }
+
   private class NullMuninNode : IMuninNode {
     public string HostName => "munin-node.localhost";
     public EndPoint EndPoint { get; } = new IPEndPoint(IPAddress.Any, 0);
@@ -160,24 +253,12 @@ public async Task StopAsync_NodeDoesNotSupportGracefulShutdown(CancellationToken
     );
   }
 
-  private class HookStopNode : LocalNode {
-    private sealed class NullPluginProvider : IPluginProvider {
-      public IReadOnlyCollection<IPlugin> Plugins { get; } = [];
-      public INodeSessionCallback? SessionCallback => null;
-    }
-
-    public override IPluginProvider PluginProvider { get; } = new NullPluginProvider();
-    public override string HostName => "munin-node.localhost";
-
+  private class HookStopNode : EmptyNode {
     public EventHandler? Stopping = null;
     public EventHandler? Stopped = null;
 
     public HookStopNode()
-      : base(
-        listenerFactory: null,
-        accessRule: null,
-        logger: null
-      )
+      : base()
     {
     }