add support for specifying the service type and implementation type of registering nodes

Author: smdn

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

@@ -239,4 +239,22 @@ Func<IServiceProvider, IMuninNodeListenerFactory> buildListenerFactory
 
     return builder;
   }
+
+  internal static TMuninNode Build<TMuninNode>(
+    this IMuninNodeBuilder builder,
+    IServiceProvider serviceProvider
+  ) where TMuninNode : IMuninNode
+  {
+    if (builder is null)
+      throw new ArgumentNullException(nameof(builder));
+    if (serviceProvider is null)
+      throw new ArgumentNullException(nameof(serviceProvider));
+
+    var n = builder.Build(serviceProvider);
+
+    if (n is not TMuninNode node)
+      throw new InvalidOperationException($"The type '{n.GetType()}' of the constructed instance did not match the requested type '{typeof(TMuninNode)}'.");
+
+    return node;
+  }
 }

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

@@ -39,6 +39,8 @@ public static IMuninNodeBuilder AddNode(
     Action<MuninNodeOptions> configure
   )
     => AddNode<
+      IMuninNode,
+      IMuninNode,
       MuninNodeOptions,
       MuninNodeBuilder
     >(
@@ -67,21 +69,132 @@ Action<MuninNodeOptions> configure
   /// An <see cref="Func{TMuninNodeBuilder}"/> to create <typeparamref name="TMuninNodeBuilder"/> to build
   /// the <c>Munin-Node</c>.
   /// </param>
+  /// <returns>The current <typeparamref name="TMuninNodeBuilder"/> so that additional calls can be chained.</returns>
+  /// <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
+  TMuninNodeBuilder AddNode<
+    TMuninNodeOptions,
+    TMuninNodeBuilder
+  >(
+    this IMuninServiceBuilder builder,
+    Action<TMuninNodeOptions> configure,
+    Func<IMuninServiceBuilder, string, TMuninNodeBuilder> createBuilder
+  )
+    where TMuninNodeOptions : MuninNodeOptions, new()
+    where TMuninNodeBuilder : MuninNodeBuilder
+    => AddNode<
+      IMuninNode,
+      IMuninNode,
+      TMuninNodeOptions,
+      TMuninNodeBuilder
+    >(
+      builder: builder ?? throw new ArgumentNullException(nameof(builder)),
+      configure: configure ?? throw new ArgumentNullException(nameof(configure)),
+      createBuilder: createBuilder ?? throw new ArgumentNullException(nameof(createBuilder))
+    );
+
+  /// <summary>
+  /// Adds a <typeparamref name="TMuninNode"/> to the <see cref="IMuninServiceBuilder"/> with specified configurations.
+  /// </summary>
+  /// <typeparam name="TMuninNode">
+  /// The type of <see cref="IMuninNode"/> service to add to the <seealso cref="IServiceCollection"/>.
+  /// </typeparam>
+  /// <typeparam name="TMuninNodeOptions">
+  /// The extended type of <see cref="MuninNodeOptions"/> to configure the <typeparamref name="TMuninNode"/>.
+  /// </typeparam>
+  /// <typeparam name="TMuninNodeBuilder">
+  /// The extended type of <see cref="MuninNodeBuilder"/> to build the <typeparamref name="TMuninNode"/>.
+  /// </typeparam>
+  /// <param name="builder">
+  /// An <see cref="IMuninServiceBuilder"/> that the built <typeparamref name="TMuninNode"/> will be added to.
+  /// </param>
+  /// <param name="configure">
+  /// An <see cref="Action{TMuninNodeOptions}"/> to setup <typeparamref name="TMuninNodeOptions"/> to
+  /// configure the <typeparamref name="TMuninNode"/> to be built.
+  /// </param>
+  /// <param name="createBuilder">
+  /// An <see cref="Func{TMuninNodeBuilder}"/> to create <typeparamref name="TMuninNodeBuilder"/> to build
+  /// the <typeparamref name="TMuninNode"/>.
+  /// </param>
+  /// <returns>The current <typeparamref name="TMuninNodeBuilder"/> so that additional calls can be chained.</returns>
+  /// <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
+  TMuninNodeBuilder AddNode<
+    TMuninNode,
+    TMuninNodeOptions,
+    TMuninNodeBuilder
+  >(
+    this IMuninServiceBuilder builder,
+    Action<TMuninNodeOptions> configure,
+    Func<IMuninServiceBuilder, string, TMuninNodeBuilder> createBuilder
+  )
+    where TMuninNode : class, IMuninNode
+    where TMuninNodeOptions : MuninNodeOptions, new()
+    where TMuninNodeBuilder : MuninNodeBuilder
+    => AddNode<
+      TMuninNode,
+      TMuninNode,
+      TMuninNodeOptions,
+      TMuninNodeBuilder
+    >(
+      builder: builder ?? throw new ArgumentNullException(nameof(builder)),
+      configure: configure ?? throw new ArgumentNullException(nameof(configure)),
+      createBuilder: createBuilder ?? throw new ArgumentNullException(nameof(createBuilder))
+    );
+
+  /// <summary>
+  /// Adds a <typeparamref name="TMuninNodeImplementation"/> to the <see cref="IMuninServiceBuilder"/> with specified configurations.
+  /// </summary>
+  /// <typeparam name="TMuninNodeService">
+  /// The type of <see cref="IMuninNode"/> service to add to the <seealso cref="IServiceCollection"/>.
+  /// </typeparam>
+  /// <typeparam name="TMuninNodeImplementation">
+  /// The type of <typeparamref name="TMuninNodeService"/> implementation.
+  /// </typeparam>
+  /// <typeparam name="TMuninNodeOptions">
+  /// The extended type of <see cref="MuninNodeOptions"/> to configure the <typeparamref name="TMuninNodeImplementation"/>.
+  /// </typeparam>
+  /// <typeparam name="TMuninNodeBuilder">
+  /// The extended type of <see cref="MuninNodeBuilder"/> to build the <typeparamref name="TMuninNodeImplementation"/>.
+  /// </typeparam>
+  /// <param name="builder">
+  /// An <see cref="IMuninServiceBuilder"/> that the built <typeparamref name="TMuninNodeImplementation"/> will be added to.
+  /// </param>
+  /// <param name="configure">
+  /// An <see cref="Action{TMuninNodeOptions}"/> to setup <typeparamref name="TMuninNodeOptions"/> to
+  /// configure the <typeparamref name="TMuninNodeImplementation"/> to be built.
+  /// </param>
+  /// <param name="createBuilder">
+  /// An <see cref="Func{TMuninNodeBuilder}"/> to create <typeparamref name="TMuninNodeBuilder"/> to build
+  /// the <typeparamref name="TMuninNodeImplementation"/>.
+  /// </param>
   /// <returns>The current <see cref="IMuninNodeBuilder"/> so that additional calls can be chained.</returns>
   /// <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<
+  TMuninNodeBuilder AddNode<
+    TMuninNodeService,
+    TMuninNodeImplementation,
     TMuninNodeOptions,
     TMuninNodeBuilder
   >(
     this IMuninServiceBuilder builder,
     Action<TMuninNodeOptions> configure,
     Func<IMuninServiceBuilder, string, TMuninNodeBuilder> createBuilder
   )
+    where TMuninNodeService : class, IMuninNode
+    where TMuninNodeImplementation : class, TMuninNodeService
     where TMuninNodeOptions : MuninNodeOptions, new()
     where TMuninNodeBuilder : MuninNodeBuilder
   {
@@ -107,27 +220,31 @@ Func<IMuninServiceBuilder, string, TMuninNodeBuilder> createBuilder
     );
 
     builder.Services.Add(
-      ServiceDescriptor.KeyedSingleton<IMuninNodeBuilder>(
+      ServiceDescriptor.KeyedSingleton<TMuninNodeBuilder>(
         serviceKey: nodeBuilder.ServiceKey,
         implementationFactory: (_, _) => nodeBuilder
       )
     );
 
     // add keyed/singleton IMuninNode
     builder.Services.Add(
-      ServiceDescriptor.KeyedSingleton<IMuninNode>(
+      ServiceDescriptor.KeyedSingleton<TMuninNodeService, TMuninNodeImplementation>(
         serviceKey: nodeBuilder.ServiceKey,
         static (serviceProvider, serviceKey)
-            => serviceProvider.GetRequiredKeyedService<IMuninNodeBuilder>(serviceKey).Build(serviceProvider)
+          => serviceProvider
+            .GetRequiredKeyedService<TMuninNodeBuilder>(serviceKey)
+            .Build<TMuninNodeImplementation>(serviceProvider)
       )
     );
 
     // add keyless/multiple IMuninNode
+#pragma warning disable IDE0200
     builder.Services.Add(
-      ServiceDescriptor.Transient<IMuninNode>(
-        nodeBuilder.Build
+      ServiceDescriptor.Transient<TMuninNodeService, TMuninNodeImplementation>(
+        serviceProvider => nodeBuilder.Build<TMuninNodeImplementation>(serviceProvider)
       )
     );
+#pragma warning restore IDE0200
 
     return nodeBuilder;
   }

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

@@ -251,6 +251,133 @@ public void AddNode_CustomBuilderType()
     Assert.That(keyedNode.HostName, Is.EqualTo(HostName));
   }
 
+  [Test]
+  public void AddNode_CustomBuilderType_AbstractServiceType()
+  {
+    const string HostName = "munin-node.localhost";
+    var services = new ServiceCollection();
+
+    services.AddMunin(configure: builder => {
+      builder.AddNode<IMuninNode, CustomMuninNode, 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));
+  }
+
+  [Test]
+  public void AddNode_CustomBuilderType_ConcreteServiceType()
+  {
+    const string HostName = "munin-node.localhost";
+    var services = new ServiceCollection();
+
+    services.AddMunin(configure: builder => {
+      builder.AddNode<CustomMuninNode, 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<CustomMuninNode>();
+
+    Assert.That(node, Is.Not.Null);
+    Assert.That(node.HostName, Is.EqualTo(HostName));
+
+    var keyedNode = serviceProvider.GetKeyedService<CustomMuninNode>(HostName);
+
+    Assert.That(keyedNode, Is.Not.Null);
+    Assert.That(keyedNode.HostName, Is.EqualTo(HostName));
+  }
+
+  private class ExtendedCustomMuninNode : CustomMuninNode {
+    public ExtendedCustomMuninNode(
+      MuninNodeOptions options,
+      IPluginProvider pluginProvider,
+      IMuninNodeListenerFactory? listenerFactory
+    )
+      : base(
+        options: options,
+        pluginProvider: pluginProvider,
+        listenerFactory: listenerFactory
+      )
+    {
+    }
+  }
+
+  [Test]
+  public void AddNode_CustomBuilderType_ConcreteServiceType_ImplementationTypeMismatch()
+  {
+    const string HostName = "munin-node.localhost";
+    var services = new ServiceCollection();
+
+    services.AddMunin(configure: builder => {
+      builder.AddNode<ExtendedCustomMuninNode, 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();
+
+    Assert.That(
+      () => serviceProvider.GetService<ExtendedCustomMuninNode>(),
+      Throws.InvalidOperationException
+    );
+    Assert.That(
+      () => serviceProvider.GetService<CustomMuninNode>(),
+      Is.Null
+    );
+
+    Assert.That(
+      () => serviceProvider.GetKeyedService<ExtendedCustomMuninNode>(HostName),
+      Throws.InvalidOperationException
+    );
+    Assert.That(
+      () => serviceProvider.GetKeyedService<CustomMuninNode>(HostName),
+      Is.Null
+    );
+  }
+
   private class CustomMuninNodeOptions : MuninNodeOptions {
     public string? ExtraOption { get; set; }
 
@@ -297,5 +424,27 @@ public void AddNode_CustomOptionsType()
 
     Assert.That(options.HostName, Is.EqualTo(HostName));
     Assert.That(options.ExtraOption, Is.EqualTo(ExtraOptionValue));
+
+    var node = serviceProvider.GetService<IMuninNode>();
+
+    Assert.That(node, Is.Not.Null);
+    Assert.That(node, Is.TypeOf<CustomMuninNode>());
+
+    var customNode = (CustomMuninNode)node;
+
+    Assert.That(customNode.Options, Is.TypeOf<CustomMuninNodeOptions>());
+    Assert.That((customNode.Options as CustomMuninNodeOptions)!.ExtraOption, Is.EqualTo(ExtraOptionValue));
+    Assert.That(customNode.HostName, Is.EqualTo(HostName));
+
+    var keyedNode = serviceProvider.GetKeyedService<IMuninNode>(HostName);
+
+    Assert.That(keyedNode, Is.Not.Null);
+    Assert.That(keyedNode, Is.TypeOf<CustomMuninNode>());
+
+    var customKeyedNode = (CustomMuninNode)keyedNode;
+
+    Assert.That(customKeyedNode.Options, Is.TypeOf<CustomMuninNodeOptions>());
+    Assert.That((customKeyedNode.Options as CustomMuninNodeOptions)!.ExtraOption, Is.EqualTo(ExtraOptionValue));
+    Assert.That(customKeyedNode.HostName, Is.EqualTo(HostName));
   }
 }