add support for building with custom MuninNodeBuilder types

Author: smdn

src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.DependencyInjection/IMuninServiceBuilderExtensions.cs

@@ -38,9 +38,13 @@ public static IMuninNodeBuilder AddNode(
     this IMuninServiceBuilder builder,
     Action<MuninNodeOptions> configure
   )
-    => AddNode<MuninNodeOptions>(
+    => AddNode<
+      MuninNodeOptions,
+      MuninNodeBuilder
+    >(
       builder: builder ?? throw new ArgumentNullException(nameof(builder)),
-      configure: configure ?? throw new ArgumentNullException(nameof(configure))
+      configure: configure ?? throw new ArgumentNullException(nameof(configure)),
+      createBuilder: static (serviceBuilder, serviceKey) => new(serviceBuilder, serviceKey)
     );
 
   /// <summary>
@@ -49,32 +53,52 @@ Action<MuninNodeOptions> configure
   /// <typeparam name="TMuninNodeOptions">
   /// The extended type of <see cref="MuninNodeOptions"/> to configure the <c>Munin-Node</c>.
   /// </typeparam>
+  /// <typeparam name="TMuninNodeBuilder">
+  /// The extended type of <see cref="MuninNodeBuilder"/> to build the <c>Munin-Node</c>.
+  /// </typeparam>
   /// <param name="builder">
   /// An <see cref="IMuninServiceBuilder"/> that the built <c>Munin-Node</c> will be added to.
   /// </param>
   /// <param name="configure">
   /// An <see cref="Action{TMuninNodeOptions}"/> to setup <typeparamref name="TMuninNodeOptions"/> to
   /// configure the <c>Munin-Node</c> to be built.
   /// </param>
+  /// <param name="createBuilder">
+  /// An <see cref="Func{TMuninNodeBuilder}"/> to create <typeparamref name="TMuninNodeBuilder"/> to build
+  /// the <c>Munin-Node</c>.
+  /// </param>
   /// <returns>The current <see cref="IMuninNodeBuilder"/> so that additional calls can be chained.</returns>
-  public static IMuninNodeBuilder AddNode<TMuninNodeOptions>(
+  /// <exception cref="ArgumentNullException">
+  /// <paramref name="builder"/> is <see langword="null"/>, or
+  /// <paramref name="configure"/> is <see langword="null"/>, or
+  /// <paramref name="createBuilder"/> is <see langword="null"/>.
+  /// </exception>
+  public static
+  IMuninNodeBuilder AddNode<
+    TMuninNodeOptions,
+    TMuninNodeBuilder
+  >(
     this IMuninServiceBuilder builder,
-    Action<TMuninNodeOptions> configure
+    Action<TMuninNodeOptions> configure,
+    Func<IMuninServiceBuilder, string, TMuninNodeBuilder> createBuilder
   )
     where TMuninNodeOptions : MuninNodeOptions, new()
+    where TMuninNodeBuilder : MuninNodeBuilder
   {
     if (builder is null)
       throw new ArgumentNullException(nameof(builder));
     if (configure is null)
       throw new ArgumentNullException(nameof(configure));
+    if (createBuilder is null)
+      throw new ArgumentNullException(nameof(createBuilder));
 
     var configuredOptions = new TMuninNodeOptions();
 
     configure(configuredOptions);
 
-    var nodeBuilder = new MuninNodeBuilder(
-      serviceBuilder: builder,
-      serviceKey: configuredOptions.HostName // use configured hostname as a service key and option name
+    var nodeBuilder = createBuilder(
+      /* serviceBuilder: */ builder,
+      /* serviceKey: */ configuredOptions.HostName // use configured hostname as a service key and option name
     );
 
     _ = builder.Services.Configure<TMuninNodeOptions>(

src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.DependencyInjection/MuninNodeBuilder.cs

@@ -23,7 +23,7 @@ public class MuninNodeBuilder : IMuninNodeBuilder {
   public IServiceCollection Services { get; }
   public string ServiceKey { get; }
 
-  internal MuninNodeBuilder(IMuninServiceBuilder serviceBuilder, string serviceKey)
+  protected internal MuninNodeBuilder(IMuninServiceBuilder serviceBuilder, string serviceKey)
   {
     Services = (serviceBuilder ?? throw new ArgumentNullException(nameof(serviceBuilder))).Services;
     ServiceKey = serviceKey ?? throw new ArgumentNullException(nameof(serviceKey));
@@ -72,16 +72,15 @@ public IMuninNode Build(IServiceProvider serviceProvider)
     if (serviceProvider is null)
       throw new ArgumentNullException(nameof(serviceProvider));
 
-    return new DefaultMuninNode(
-      options: GetConfiguredOptions<MuninNodeOptions>(serviceProvider),
+    return Build(
       pluginProvider: buildPluginProvider is null
         ? new PluginProvider(
             plugins: pluginFactories.Select(factory => factory(serviceProvider)).ToList(),
             sessionCallback: buildSessionCallback?.Invoke(serviceProvider)
           )
         : buildPluginProvider.Invoke(serviceProvider),
       listenerFactory: buildListenerFactory?.Invoke(serviceProvider),
-      logger: serviceProvider.GetService<ILoggerFactory>()?.CreateLogger<DefaultMuninNode>()
+      serviceProvider: serviceProvider
     );
   }
 
@@ -99,6 +98,23 @@ public PluginProvider(
     }
   }
 
+  protected virtual IMuninNode Build(
+    IPluginProvider pluginProvider,
+    IMuninNodeListenerFactory? listenerFactory,
+    IServiceProvider serviceProvider
+  )
+  {
+    if (serviceProvider is null)
+      throw new ArgumentNullException(nameof(serviceProvider));
+
+    return new DefaultMuninNode(
+      options: GetConfiguredOptions<MuninNodeOptions>(serviceProvider),
+      pluginProvider: pluginProvider,
+      listenerFactory: listenerFactory,
+      logger: serviceProvider.GetService<ILoggerFactory>()?.CreateLogger<DefaultMuninNode>()
+    );
+  }
+
   protected TMuninNodeOptions GetConfiguredOptions<TMuninNodeOptions>(IServiceProvider serviceProvider)
     where TMuninNodeOptions : MuninNodeOptions
   {

tests/Smdn.Net.MuninNode/Smdn.Net.MuninNode.DependencyInjection/IMuninServiceBuilderExtensions.cs

@@ -8,6 +8,9 @@
 
 using NUnit.Framework;
 
+using Smdn.Net.MuninNode.Transport;
+using Smdn.Net.MuninPlugin;
+
 namespace Smdn.Net.MuninNode.DependencyInjection;
 
 [TestFixture]
@@ -163,6 +166,91 @@ public void AddNode_Multiple_GetKeyedService(string hostName)
     Assert.That(node, Is.Not.SameAs(anotherNode));
   }
 
+  private class CustomMuninNodeBuilder<TMuninNodeOptions> : MuninNodeBuilder
+    where TMuninNodeOptions : MuninNodeOptions
+  {
+    private readonly Func<TMuninNodeOptions, IPluginProvider, IMuninNodeListenerFactory?, IServiceProvider, IMuninNode> nodeFactory;
+
+    public CustomMuninNodeBuilder(
+      IMuninServiceBuilder serviceBuilder,
+      string serviceKey,
+      Func<TMuninNodeOptions, IPluginProvider, IMuninNodeListenerFactory?, IServiceProvider, IMuninNode> nodeFactory
+    )
+      : base(serviceBuilder, serviceKey)
+    {
+      this.nodeFactory = nodeFactory;
+    }
+
+    protected override IMuninNode Build(
+      IPluginProvider pluginProvider,
+      IMuninNodeListenerFactory? listenerFactory,
+      IServiceProvider serviceProvider
+    )
+      => nodeFactory(
+        GetConfiguredOptions<TMuninNodeOptions>(serviceProvider),
+        pluginProvider,
+        listenerFactory,
+        serviceProvider
+      );
+  }
+
+  private class CustomMuninNode : LocalNode {
+    public MuninNodeOptions Options { get; }
+    public override string HostName => Options.HostName;
+    public override IPluginProvider PluginProvider { get; }
+
+    public CustomMuninNode(
+      MuninNodeOptions options,
+      IPluginProvider pluginProvider,
+      IMuninNodeListenerFactory? listenerFactory
+    )
+      : base(
+        listenerFactory: listenerFactory,
+        accessRule: null,
+        logger: null
+      )
+    {
+      Options = options;
+      PluginProvider = pluginProvider;
+    }
+  }
+
+  [Test]
+  public void AddNode_CustomBuilderType()
+  {
+    const string HostName = "munin-node.localhost";
+    var services = new ServiceCollection();
+
+    services.AddMunin(configure: builder => {
+      builder.AddNode<MuninNodeOptions, CustomMuninNodeBuilder<MuninNodeOptions>>(
+        configure: options => options.HostName = HostName,
+        createBuilder: static (serviceBuilder, serviceKey) => new CustomMuninNodeBuilder<MuninNodeOptions>(
+          serviceBuilder: serviceBuilder,
+          serviceKey: serviceKey,
+          nodeFactory: static (options, pluginProvider, listenerFactory, serviceProvider) => new CustomMuninNode(
+            options,
+            pluginProvider,
+            listenerFactory
+          )
+        )
+      );
+    });
+
+    var serviceProvider = services.BuildServiceProvider();
+
+    var node = serviceProvider.GetService<IMuninNode>();
+
+    Assert.That(node, Is.Not.Null);
+    Assert.That(node, Is.TypeOf<CustomMuninNode>());
+    Assert.That(node.HostName, Is.EqualTo(HostName));
+
+    var keyedNode = serviceProvider.GetKeyedService<IMuninNode>(HostName);
+
+    Assert.That(keyedNode, Is.Not.Null);
+    Assert.That(keyedNode, Is.TypeOf<CustomMuninNode>());
+    Assert.That(keyedNode.HostName, Is.EqualTo(HostName));
+  }
+
   private class CustomMuninNodeOptions : MuninNodeOptions {
     public string? ExtraOption { get; set; }
 
@@ -184,11 +272,20 @@ public void AddNode_CustomOptionsType()
     var services = new ServiceCollection();
 
     services.AddMunin(configure: builder => {
-      builder.AddNode<CustomMuninNodeOptions>(
+      builder.AddNode<CustomMuninNodeOptions, CustomMuninNodeBuilder<CustomMuninNodeOptions>>(
         configure: options => {
           options.HostName = HostName;
           options.ExtraOption = ExtraOptionValue;
-        }
+        },
+        createBuilder: static (serviceBuilder, serviceKey) => new CustomMuninNodeBuilder<CustomMuninNodeOptions>(
+          serviceBuilder: serviceBuilder,
+          serviceKey: serviceKey,
+          nodeFactory: static (options, pluginProvider, listenerFactory, serviceProvider) => new CustomMuninNode(
+            options,
+            pluginProvider,
+            listenerFactory
+          )
+        )
       );
     });