.NET Generic Host model

[lduchosal]

First of all, thank you for your work on this library — it’s been really helpful. I’m currently exploring ways to adapt it to work seamlessly with the .NET Generic Host model introduced in .NET Core and later.

Would you be open to discussing how this integration could be done? I’d be happy to contribute or collaborate on a possible update if you’re interested.

[smdn]

Thank you for using my library and offering to contribute!

What are your ideas/plans for integrating with .NET Generic Host?

If the change can be accomplished by adding some features or APIs, this type of change can be accepted via the pull request.
If it requires more changes, such as API changes, then we may need to have a discussion before making the change.

In any case, please let me know what kind of functionality is currently missing, or what kind of functionality you would like to add.

(Please note that I'm writing in English with the help of machine translation. So the discussion may not be well done.)

[lduchosal]

Configuration could be standardized

public interface IMnuninConfiguration
{
    public int Port { get; init; }
    public string Hostname { get; init; }
    IReadOnlyList<IPAddress>? AllowFrom { get; init; }
}

Utility function could be defined in interfaces

public interface ISocketCreator
{
    Socket CreateServerSocket();
}

public interface IMuninNode
{
    Task RunAsync(bool throwIfCancellationRequested, CancellationToken stoppingToken);
}

Static method (Node.Create) could be remove

public sealed class MuninNode : NodeBase, IMuninNode
{
    private IMnuninConfiguration Config { get; init; }
    private ISocketCreator SocketServer { get; init; }
    public override IPluginProvider PluginProvider { get; }
    public override string HostName { get; }

    public MuninNode(
        ILogger<MuninNode> logger,
        IAccessRule accessRule,
        IMnuninConfiguration config,
        IPluginProvider plugins,
        ISocketCreator socketServer
    ) : base(accessRule, logger)
    {
        Config = config;
        PluginProvider = plugins;
        SocketServer = socketServer;
        HostName = config.Hostname;
    }

    protected override Socket CreateServerSocket()
    {
        return SocketServer.CreateServerSocket();
    }

    public async Task RunAsync(bool throwIfCancellationRequested, CancellationToken stoppingToken)
    {
        await AcceptAsync(throwIfCancellationRequested, stoppingToken);
    }
}

Then IMuninNode could be used as a standard interface to create nodes

public sealed class Muninservice : BackgroundService
{
    private readonly ILogger<Muninservice> Logger;
    private readonly IMuninNode Node;
    
    public Muninservice(
        ILogger<Muninservice> logger,
        IMuninNode node
        )
    {
        Logger = logger;
        Node = node;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        Logger.LogInformation("ExecuteAsync");
        await Node.RunAsync(throwIfCancellationRequested: false, stoppingToken);
        Logger.LogInformation("ExecuteAsync Ended");
    }
}

And finaly could be used in .NET Generic Host :

var builder = WebApplication.CreateBuilder(args); // or console app

builder.Services
    .AddHostedService<Muninservice>()
    ;

To sum up, the changes would be :

• spectify configuration
• define interfaces
• don't use static method to create node
• use dependency injection

[smdn]

Thank you for suggesting a great idea!
I would like to adopt these changes and implement them based on your design, although details such as naming will need to be discussed.

I would like to make the changes in the following three steps. This means that the changes will be made with the three pull requests.

1. introduce 3 new interfaces
2. implement and add MuninNode class
3. implement and add MuninService class

In each of these steps, we will perform the tasks listed below.

1. Discuss the details of the changes
2. Write code and open PR (your task)
3. Review, clean up code, etc. and then merge PR (my task)

If this is OK with you, let's continue the discussion.
(I have suggestions for three new interfaces. I will get back to you tomorrow.)

[lduchosal]

I will not modify forward my pull request. Please accept it and refactor as you wish.

[smdn]

As for not modifying the PR, that's fine.
However, I would still like to adopt this idea itself.

Would you create another pull request that does not include changes to the sln and csproj files, if you don't mind?
Then I can take the work that I do in the rest of the work, like renaming and refactoring, and then do the merge.

You can also add copyright notices to your files if you wish.
When opening a PR, please include the following header in the newly added file:

// SPDX-FileCopyrightText: 2025 yourname <[email protected]>
// SPDX-License-Identifier: MIT

using System;
  :
  :

[lduchosal]

Started a PR #11 so we can start discussing the implementation

[smdn]

IMuninConfiguration

Comment about IMnuninConfiguration:

public interface IMnuninConfiguration
{
    public int Port { get; init; }
    public string Hostname { get; init; }
    IReadOnlyList<IPAddress>? AllowFrom { get; init; }
}

• The name IMuninNodeConfiguration is preferable because it is a configuration for munin-node, not for munin.
• Since it is an interface for defining the API, members need not have accessibilities and init accessors.
• We need to configure the address that munin-node listens to, so we need to have an IPAddress as you present in Feat: .NET generic host #12. Since there is a member named Port, the member name for this should be Address. (e.g. IPEndPoint.Port and IPEndPoint.Address)
• According to the .NET naming example, HostName is preferred instead of Hostname. (e.g. IPHostEntry.HostName, Dns.GetHostName)
• It is fine for using the namespace Smdn.Net.MuninNode for this interface, since there is no particular reason for the namespace to be separate with the NodeBase class.

I suggest the following code for the reasons I mentioned above.

namespace Smdn.Net.MuninNode;

public interface IMuninNodeConfiguration
{
    int Port { get; }
    IPAddress Address { get; }
    string HostName { get; }
    IReadOnlyList<IPAddress>? AllowFrom { get; }
}

[lduchosal]

You can accept the pull request and rename as you wish. Editors have a refactor / rename function. Feel free to modify as you wish.

[smdn]

IMuninNode

public interface IMuninNode
{
    Task RunAsync(bool throwIfCancellationRequested, CancellationToken stoppingToken);
}

I have no particular opinion on this. We can just decide on the namespace.

namespace Smdn.Net.MuninNode;

public interface IMuninNode
{
    Task RunAsync(bool throwIfCancellationRequested, CancellationToken stoppingToken);
}

That's all for today. I will comment on other interfaces tomorrow.

[smdn]

In PR #16, I added an IMuninNodeListenerFactory with reference to your idea ISocketCreator.
This PR is implemented to create an abstracted transport layer implementation, rather than directly creating a Socket as in the ISocketCreator.

I will continue to add support for dependency injection and .NET generic host.
Please be aware, however, that PR #12 will be closed as a result of this addition.
I will let you know again when the work progresses.

[smdn]

@lduchosal

I have implemented new features based on the ideas you have proposed, and released the following package.

• Smdn.Net.MuninNode version 2.2.0
• Smdn.Net.MuninNode.Hosting version 3.0.0

Thank you for proposing the idea!
Sorry for any inconvenience the late implementation may have caused you, but I hope this release helps you achieve your goals.

With this change, NodeBase.Start, NodeBase.LocalEndPoint, and other members are marked as obsolete.
Members marked as obsolete will be removed in a future release of Smdn.Net.MuninNode 3.0.

See the release notes above for more details, including API changes.

Also, this discussion will be considered complete and closed.
I welcome further contributions if you have any other ideas.