Merge pull request #17 from smdn/add-di-apis

Add APIs to support dependency injection

Author: smdn

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

@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: 2025 smdn <smdn@smdn.jp>
+// SPDX-License-Identifier: MIT
+
+using System;
+using System.Net;
+
+using Microsoft.Extensions.Logging;
+
+using Smdn.Net.MuninNode.AccessRules;
+using Smdn.Net.MuninNode.Transport;
+using Smdn.Net.MuninPlugin;
+
+namespace Smdn.Net.MuninNode.DependencyInjection;
+
+/// <summary>
+/// Implement a <c>Munin-Node</c> that can be configured by IServiceProvider or other interfaces.
+/// </summary>
+internal sealed class DefaultMuninNode : NodeBase, IMuninNode {
+  private readonly MuninNodeOptions options;
+
+  public override string HostName => options.HostName;
+  public override IPluginProvider PluginProvider { get; }
+
+  /// <summary>
+  /// Initializes a new instance of the <see cref="DefaultMuninNode"/> class.
+  /// </summary>
+  /// <param name="options">
+  /// The <see cref="MuninNodeOptions"/> to configure the <c>Munin-Node</c>.
+  /// </param>
+  /// <param name="pluginProvider">
+  /// The <see cref="IPluginProvider"/> to provide <c>Munin plugins</c> for this instance.
+  /// </param>
+  /// <param name="listenerFactory">
+  /// The <see cref="IMuninNodeListenerFactory"/> to create a listener for this instance.
+  /// If <see langword="null"/>, the default factory will be used.
+  /// </param>
+  /// <param name="logger">
+  /// The <see cref="ILogger"/> to report the situation.
+  /// </param>
+  /// <remarks>
+  /// If <see cref="MuninNodeOptions.AccessRule"/> is <see langword="null"/>, only allow access from the loopback address.
+  /// </remarks>
+  /// <exception cref="ArgumentNullException">
+  /// <paramref name="options"/> is <see langword="null"/>, or
+  /// <paramref name="pluginProvider"/> is <see langword="null"/>.
+  /// </exception>
+  public DefaultMuninNode(
+    MuninNodeOptions options,
+    IPluginProvider pluginProvider,
+    IMuninNodeListenerFactory? listenerFactory,
+    ILogger? logger
+  )
+    : base(
+      listenerFactory: listenerFactory ?? MuninNodeListenerFactory.Instance,
+      accessRule: (options ?? throw new ArgumentNullException(nameof(options))).AccessRule ?? LoopbackOnlyAccessRule.Instance,
+      logger: logger
+    )
+  {
+    this.options = options;
+    PluginProvider = pluginProvider ?? throw new ArgumentNullException(nameof(pluginProvider));
+  }
+
+  protected override EndPoint GetLocalEndPointToBind()
+    => new IPEndPoint(options.Address, options.Port);
+}

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

@@ -0,0 +1,101 @@
+// SPDX-FileCopyrightText: 2025 smdn <smdn@smdn.jp>
+// SPDX-License-Identifier: MIT
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+using Smdn.Net.MuninNode.Transport;
+using Smdn.Net.MuninPlugin;
+
+namespace Smdn.Net.MuninNode.DependencyInjection;
+
+internal sealed class DefaultMuninNodeBuilder : IMuninNodeBuilder {
+  private readonly List<Func<IServiceProvider, IPlugin>> pluginFactories = new(capacity: 4);
+  private Func<IServiceProvider, IPluginProvider>? buildPluginProvider;
+  private Func<IServiceProvider, INodeSessionCallback>? buildSessionCallback;
+  private Func<IServiceProvider, IMuninNodeListenerFactory>? buildListenerFactory;
+
+  public IServiceCollection Services { get; }
+  public string ServiceKey { get; }
+
+  public DefaultMuninNodeBuilder(IMuninServiceBuilder serviceBuilder, string serviceKey)
+  {
+    Services = (serviceBuilder ?? throw new ArgumentNullException(nameof(serviceBuilder))).Services;
+    ServiceKey = serviceKey ?? throw new ArgumentNullException(nameof(serviceKey));
+  }
+
+  public void AddPluginFactory(Func<IServiceProvider, IPlugin> buildPlugin)
+  {
+    if (buildPlugin is null)
+      throw new ArgumentNullException(nameof(buildPlugin));
+
+    pluginFactories.Add(serviceProvider => buildPlugin(serviceProvider));
+  }
+
+  public void SetPluginProviderFactory(
+    Func<IServiceProvider, IPluginProvider> buildPluginProvider
+  )
+  {
+    if (buildPluginProvider is null)
+      throw new ArgumentNullException(nameof(buildPluginProvider));
+
+    this.buildPluginProvider = buildPluginProvider;
+  }
+
+  public void SetSessionCallbackFactory(
+    Func<IServiceProvider, INodeSessionCallback> buildSessionCallback
+  )
+  {
+    if (buildSessionCallback is null)
+      throw new ArgumentNullException(nameof(buildSessionCallback));
+
+    this.buildSessionCallback = buildSessionCallback;
+  }
+
+  public void SetListenerFactory(
+    Func<IServiceProvider, IMuninNodeListenerFactory> buildListenerFactory
+  )
+  {
+    if (buildListenerFactory is null)
+      throw new ArgumentNullException(nameof(buildListenerFactory));
+
+    this.buildListenerFactory = buildListenerFactory;
+  }
+
+  public IMuninNode Build(IServiceProvider serviceProvider)
+  {
+    if (serviceProvider is null)
+      throw new ArgumentNullException(nameof(serviceProvider));
+
+    return new DefaultMuninNode(
+      options: serviceProvider.GetRequiredService<IOptionsMonitor<MuninNodeOptions>>().Get(name: ServiceKey),
+      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>()
+    );
+  }
+
+  private sealed class PluginProvider : IPluginProvider {
+    public IReadOnlyCollection<IPlugin> Plugins { get; }
+    public INodeSessionCallback? SessionCallback { get; }
+
+    public PluginProvider(
+      IReadOnlyCollection<IPlugin> plugins,
+      INodeSessionCallback? sessionCallback
+    )
+    {
+      Plugins = plugins ?? throw new ArgumentNullException(nameof(plugins));
+      SessionCallback = sessionCallback;
+    }
+  }
+}

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

@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: 2025 smdn <smdn@smdn.jp>
+// SPDX-License-Identifier: MIT
+#pragma warning disable CS0419
+
+using System;
+
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Smdn.Net.MuninNode.DependencyInjection;
+
+/// <summary>
+/// An interface for configuring the <c>Munin-Node</c> service providers.
+/// </summary>
+/// <see cref="IMuninNodeBuilderExtensions.AddPlugin"/>
+/// <see cref="IMuninNodeBuilderExtensions.UseListenerFactory"/>
+/// <see cref="IMuninNodeBuilderExtensions.UseSessionCallback"/>
+public interface IMuninNodeBuilder {
+  /// <summary>
+  /// Gets the <see cref="IServiceCollection"/> where the <c>Munin-Node</c> services are configured.
+  /// </summary>
+  IServiceCollection Services { get; }
+
+  /// <summary>
+  /// Gets the <see cref="string"/> key of <c>Munin-Node</c> service.
+  /// </summary>
+  /// <remarks>
+  /// The value set as the hostname of the <c>Munin-Node</c> (see <see cref="MuninNodeOptions.HostName"/>) is used as the service key.
+  /// </remarks>
+  /// <see cref="IMuninServiceBuilderExtensions.AddNode(IMuninServiceBuilder, Action{MuninNodeOptions})"/>
+  string ServiceKey { get; }
+
+  /// <summary>
+  /// Builds the <c>Munin-Node</c> with current configurations.
+  /// </summary>
+  /// <param name="serviceProvider">
+  /// An <see cref="IServiceProvider"/> that provides the services to be used by the <see cref="IMuninNode"/> being built.
+  /// </param>
+  /// <returns>An initialized <see cref="IMuninNode"/>.</returns>
+  IMuninNode Build(IServiceProvider serviceProvider);
+}