use the term 'listener' instead of 'server', for objects that wait for connections from clients

Author: smdn

src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.Transport/IMuninNodeClient.cs

@@ -13,7 +13,7 @@ namespace Smdn.Net.MuninNode.Transport;
 /// Provides an interface that abstracts the client implementation of
 /// the transport layer that connects to the <c>Munin-Node</c>.
 /// </summary>
-/// <seealso cref="IMuninNodeServer"/>
+/// <seealso cref="IMuninNodeListener"/>
 public interface IMuninNodeClient : IDisposable, IAsyncDisposable {
   /// <summary>
   /// Gets the <see cref="EndPoint"/> that is bound with this instance.

….MuninNode.Transport/IMuninNodeServer.cs …uninNode.Transport/IMuninNodeListener.cssrc/Smdn.Net.MuninNode/Smdn.Net.MuninNode.Transport/IMuninNodeServer.cs renamed to src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.Transport/IMuninNodeListener.cs src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.Transport/IMuninNodeServer.cs renamed to src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.Transport/IMuninNodeListener.cs

@@ -9,31 +9,31 @@
 namespace Smdn.Net.MuninNode.Transport;
 
 /// <summary>
-/// Provides an interface that abstracts the server implementation of
+/// Provides an interface that abstracts the listener implementation of
 /// the transport layer that accepts the connections to the <c>Munin-Node</c>.
 /// </summary>
 /// <seealso cref="IMuninNodeClient"/>
-/// <seealso cref="IMuninNodeServerFactory"/>
-public interface IMuninNodeServer : IDisposable, IAsyncDisposable {
+/// <seealso cref="IMuninNodeListenerFactory"/>
+public interface IMuninNodeListener : IDisposable, IAsyncDisposable {
   /// <summary>
   /// Gets the <see cref="EndPoint"/> that is bound with this instance.
   /// </summary>
-  /// <exception cref="ObjectDisposedException">The server has been disposed.</exception>
-  /// <exception cref="InvalidOperationException">The server is not started yet.</exception>
+  /// <exception cref="ObjectDisposedException">The instance has been disposed.</exception>
+  /// <exception cref="InvalidOperationException">The instance is not started yet.</exception>
   /// <value>
-  /// <see langword="null"/> if this server does not have <see cref="EndPoint"/>.
+  /// <see langword="null"/> if this instance does not have <see cref="EndPoint"/>.
   /// </value>
   EndPoint? EndPoint { get; }
 
   /// <summary>
-  /// Start the server and enable to accept connections from clients.
+  /// Start the listener and enable to accept connections from clients.
   /// </summary>
   /// <param name="cancellationToken">
   /// The <see cref="CancellationToken"/> to monitor for cancellation requests.
   /// </param>
   /// <returns>
   /// The <see cref="ValueTask"/> that represents the asynchronous operation,
-  /// starting the server.
+  /// starting the listener.
   /// </returns>
   ValueTask StartAsync(CancellationToken cancellationToken);
 

…ode.Transport/IMuninNodeServerFactory.cs …e.Transport/IMuninNodeListenerFactory.cssrc/Smdn.Net.MuninNode/Smdn.Net.MuninNode.Transport/IMuninNodeServerFactory.cs renamed to src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.Transport/IMuninNodeListenerFactory.cs src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.Transport/IMuninNodeServerFactory.cs renamed to src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.Transport/IMuninNodeListenerFactory.cs

@@ -8,33 +8,33 @@
 namespace Smdn.Net.MuninNode.Transport;
 
 /// <summary>
-/// Provides an interface that abstracts the factory for creating
-/// server implementation of the transport layer used by <c>Munin-Node</c>.
+/// Provides an interface that abstracts the factory for creating the client
+/// listener implementation of the transport layer used by <c>Munin-Node</c>.
 /// </summary>
-/// <seealso cref="IMuninNodeServer"/>
-public interface IMuninNodeServerFactory {
+/// <seealso cref="IMuninNodeListener"/>
+public interface IMuninNodeListenerFactory {
   /// <summary>
-  /// Creates and returns a <see cref="IMuninNodeServer"/> for the specific <c>Munin-Node</c>.
+  /// Creates and returns a <see cref="IMuninNodeListener"/> for the specific <c>Munin-Node</c>.
   /// </summary>
   /// <param name="endPoint">
-  /// The <see cref="EndPoint"/> that will be bound with the <see cref="IMuninNodeServer"/> used by the <c>Munin-Node</c> to be created.
+  /// The <see cref="EndPoint"/> that will be bound with the <see cref="IMuninNodeListener"/> used by the <c>Munin-Node</c> to be created.
   /// </param>
   /// <param name="node">
-  /// The <see cref="IMuninNode"/> representing the <c>Munin-Node</c> where the <see cref="IMuninNodeServer"/> to be created will be used.
+  /// The <see cref="IMuninNode"/> representing the <c>Munin-Node</c> where the <see cref="IMuninNodeListener"/> to be created will be used.
   /// </param>
   /// <param name="cancellationToken">
   /// The <see cref="CancellationToken"/> to monitor for cancellation requests.
   /// </param>
   /// <remarks>
   /// The <paramref name="node"/> parameter should not be used to determine an endpoint to bind to.
   /// It is intended to be used as a key for the management and identification of the
-  /// <see cref="IMuninNodeServer"/> that has been created.
+  /// <see cref="IMuninNodeListener"/> that has been created.
   /// </remarks>
   /// <returns>
-  /// The <see cref="ValueTask{IMuninNodeServer}"/> that represents the asynchronous operation,
-  /// creating the <see cref="IMuninNodeServer"/> bound to the <paramref name="endPoint"/>.
+  /// The <see cref="ValueTask{IMuninNodeListener}"/> that represents the asynchronous operation,
+  /// creating the <see cref="IMuninNodeListener"/> bound to the <paramref name="endPoint"/>.
   /// </returns>
-  ValueTask<IMuninNodeServer> CreateAsync(
+  ValueTask<IMuninNodeListener> CreateAsync(
     EndPoint endPoint,
     IMuninNode node,
     CancellationToken cancellationToken

src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.Transport/MuninNodeListener.Obsolete.cs

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: 2025 smdn <smdn@smdn.jp>
+// SPDX-License-Identifier: MIT
+
+using System;
+using System.Net.Sockets;
+
+using Microsoft.Extensions.Logging;
+
+namespace Smdn.Net.MuninNode.Transport;
+
+#pragma warning disable IDE0040
+partial class MuninNodeListener {
+#pragma warning disable IDE0040
+  /// <remarks>
+  /// This constructor is used to maintain the functionality of the old API of
+  /// creating server sockets with the <see cref="NodeBase.CreateServerSocket"/>.
+  /// </remarks>
+  [Obsolete]
+  private MuninNodeListener(Socket listener, ILogger? logger)
+  {
+    if (listener is null)
+      throw new ArgumentNullException(nameof(listener));
+    if (listener.LocalEndPoint is null)
+      throw new ArgumentException(message: "Must be a socket already bound to an endpoint.", paramName: nameof(listener));
+
+    endPoint = listener.LocalEndPoint; // although set, this value would never be used
+    this.listener = listener;
+    this.logger = logger;
+  }
+
+  [Obsolete]
+  internal static MuninNodeListener CreateFromStartedSocket(Socket listener, ILogger? logger)
+  {
+    if (listener is null)
+      throw new ArgumentNullException(nameof(listener));
+
+    return new(listener, logger);
+  }
+}

…t.MuninNode.Transport/MuninNodeServer.cs …MuninNode.Transport/MuninNodeListener.cssrc/Smdn.Net.MuninNode/Smdn.Net.MuninNode.Transport/MuninNodeServer.cs renamed to src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.Transport/MuninNodeListener.cs src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.Transport/MuninNodeServer.cs renamed to src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.Transport/MuninNodeListener.cs

@@ -12,27 +12,27 @@
 
 namespace Smdn.Net.MuninNode.Transport;
 
-internal sealed partial class MuninNodeServer : IMuninNodeServer {
+internal sealed partial class MuninNodeListener : IMuninNodeListener {
   private readonly EndPoint endPoint;
   private readonly ILogger? logger;
   private readonly IServiceProvider? serviceProvider;
-  private Socket? server;
+  private Socket? listener;
   private bool isRunning;
 
-  public EndPoint? EndPoint => server?.LocalEndPoint;
+  public EndPoint? EndPoint => listener?.LocalEndPoint;
 
   private const bool EnableDualMode = true; // XXX: this should be configurable(?)
 
-  internal MuninNodeServer(EndPoint endPoint, IServiceProvider? serviceProvider)
+  internal MuninNodeListener(EndPoint endPoint, IServiceProvider? serviceProvider)
     : this(
       endPoint: endPoint,
-      logger: serviceProvider?.GetService<ILoggerFactory>()?.CreateLogger<MuninNodeServer>(),
+      logger: serviceProvider?.GetService<ILoggerFactory>()?.CreateLogger<MuninNodeListener>(),
       serviceProvider: serviceProvider
     )
   {
   }
 
-  internal MuninNodeServer(EndPoint endPoint, ILogger? logger, IServiceProvider? serviceProvider)
+  internal MuninNodeListener(EndPoint endPoint, ILogger? logger, IServiceProvider? serviceProvider)
   {
     this.endPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
     this.logger = logger;
@@ -61,21 +61,21 @@ public async ValueTask DisposeAsync()
   ValueTask DisposeAsyncCore()
   {
     try {
-      if (server is not null && server.Connected) {
+      if (listener is not null && listener.Connected) {
 #if SYSTEM_NET_SOCKETS_SOCKET_DISCONNECTASYNC_REUSESOCKET_CANCELLATIONTOKEN
-        await server.DisconnectAsync(reuseSocket: false).ConfigureAwait(false);
+        await listener.DisconnectAsync(reuseSocket: false).ConfigureAwait(false);
 #else
-        server.Disconnect(reuseSocket: false);
+        listener.Disconnect(reuseSocket: false);
 #endif
       }
     }
     catch (SocketException) {
       // swallow
     }
 
-    server?.Close();
-    server?.Dispose();
-    server = null;
+    listener?.Close();
+    listener?.Dispose();
+    listener = null;
 
 #if !SYSTEM_NET_SOCKETS_SOCKET_DISCONNECTASYNC_REUSESOCKET_CANCELLATIONTOKEN
     return default;
@@ -89,16 +89,16 @@ private void Dispose(bool disposing)
       return;
 
     try {
-      if (server is not null && server.Connected)
-        server.Disconnect(reuseSocket: false);
+      if (listener is not null && listener.Connected)
+        listener.Disconnect(reuseSocket: false);
     }
     catch (SocketException) {
       // swallow
     }
 
-    server?.Close();
-    server?.Dispose();
-    server = null!;
+    listener?.Close();
+    listener?.Dispose();
+    listener = null!;
   }
 
   public ValueTask StartAsync(CancellationToken cancellationToken)
@@ -107,19 +107,19 @@ public ValueTask StartAsync(CancellationToken cancellationToken)
       throw new InvalidOperationException("already started");
 
     try {
-      if (server is null) {
-        server = CreateServerSocket(endPoint);
+      if (listener is null) {
+        listener = CreateServerSocket(endPoint);
       }
       else {
-        // since the `server` has already been assigned to a bound socket, treat as running state
+        // since the `listener` has already been assigned to a bound socket, treat as running state
       }
 
       isRunning = true;
 
       return default;
     }
     catch {
-      server = null;
+      listener = null;
 
       throw;
     }
@@ -165,10 +165,10 @@ public async ValueTask<IMuninNodeClient> AcceptAsync(CancellationToken cancellat
   {
     if (!isRunning)
       throw new InvalidOperationException("not started or already closed");
-    if (server is null)
-      throw new InvalidOperationException("invalid state: server is not initialized");
+    if (listener is null)
+      throw new InvalidOperationException("invalid state: listener is not initialized");
 
-    var client = await server
+    var client = await listener
 #if SYSTEM_NET_SOCKETS_SOCKET_ACCEPTASYNC_CANCELLATIONTOKEN
       .AcceptAsync(cancellationToken: cancellationToken)
 #else

src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.Transport/MuninNodeServer.Obsolete.cs

@@ -42,7 +42,7 @@ public ConcreteLocalNode(
       IServiceProvider? serviceProvider = null
     )
       : base(
-        serverFactory: new ServerFactory(serviceProvider?.GetService<ILoggerFactory>()?.CreateLogger<LocalNode>()),
+        listenerFactory: new ListenerFactory(serviceProvider?.GetService<ILoggerFactory>()?.CreateLogger<LocalNode>()),
         accessRule: accessRule ?? serviceProvider?.GetService<IAccessRule>(),
         logger: serviceProvider?.GetService<ILoggerFactory>()?.CreateLogger<LocalNode>()
       )
@@ -58,15 +58,15 @@ protected override EndPoint GetLocalEndPointToBind()
         port: port
       );
 
-    private new sealed class ServerFactory(ILogger? logger) : IMuninNodeServerFactory {
-      public ValueTask<IMuninNodeServer> CreateAsync(
+    private new sealed class ListenerFactory(ILogger? logger) : IMuninNodeListenerFactory {
+      public ValueTask<IMuninNodeListener> CreateAsync(
         EndPoint endPoint,
         IMuninNode node,
         CancellationToken cancellationToken
       )
 #pragma warning disable CA2000
         => new(
-          new MuninNodeServer(
+          new MuninNodeListener(
             endPoint: endPoint,
             logger: logger,
             serviceProvider: null

src/Smdn.Net.MuninNode/Smdn.Net.MuninNode/LocalNode.Create.cs

@@ -21,7 +21,7 @@ partial class LocalNode {
   /// <param name="logger">
   /// The <see cref="ILogger"/> to report the situation.
   /// </param>
-  [Obsolete($"Use a constructor overload that takes {nameof(IMuninNodeServerFactory)} as an argument.")]
+  [Obsolete($"Use a constructor overload that takes {nameof(IMuninNodeListenerFactory)} as an argument.")]
   protected LocalNode(
     IAccessRule? accessRule,
     ILogger? logger = null
@@ -33,7 +33,7 @@ protected LocalNode(
   {
   }
 
-  [Obsolete($"Use {nameof(IMuninNodeServerFactory)} and {nameof(StartAsync)} instead.")]
+  [Obsolete($"Use {nameof(IMuninNodeListenerFactory)} and {nameof(StartAsync)} instead.")]
   protected override Socket CreateServerSocket()
-    => MuninNodeServer.CreateServerSocket(endPoint: GetLocalEndPointToBind());
+    => MuninNodeListener.CreateServerSocket(endPoint: GetLocalEndPointToBind());
 }

src/Smdn.Net.MuninNode/Smdn.Net.MuninNode/LocalNode.Obsolete.cs

@@ -19,9 +19,9 @@ public abstract partial class LocalNode : NodeBase {
   /// <summary>
   /// Initializes a new instance of the <see cref="LocalNode"/> class.
   /// </summary>
-  /// <param name="serverFactory">
-  /// The <see cref="IMuninNodeServerFactory"/> factory to create an <see cref="IMuninNodeServer"/> to be used in this instance.
-  /// If <see langword="null"/>, the default <see cref="IMuninNodeServerFactory"/> implementation is used.
+  /// <param name="listenerFactory">
+  /// The <see cref="IMuninNodeListenerFactory"/> factory to create an <see cref="IMuninNodeListener"/> to be used in this instance.
+  /// If <see langword="null"/>, the default <see cref="IMuninNodeListenerFactory"/> implementation is used.
   /// </param>
   /// <param name="accessRule">
   /// The <see cref="IAccessRule"/> to determine whether to accept or reject a remote host that connects to <see cref="LocalNode"/>.
@@ -30,29 +30,29 @@ public abstract partial class LocalNode : NodeBase {
   /// The <see cref="ILogger"/> to report the situation.
   /// </param>
   protected LocalNode(
-    IMuninNodeServerFactory? serverFactory,
+    IMuninNodeListenerFactory? listenerFactory,
     IAccessRule? accessRule,
     ILogger? logger
   )
     : base(
-      serverFactory: serverFactory ?? ServerFactory.Instance,
+      listenerFactory: listenerFactory ?? ListenerFactory.Instance,
       accessRule: accessRule,
       logger: logger
     )
   {
   }
 
-  private sealed class ServerFactory : IMuninNodeServerFactory {
-    public static readonly ServerFactory Instance = new();
+  private sealed class ListenerFactory : IMuninNodeListenerFactory {
+    public static readonly ListenerFactory Instance = new();
 
-    public ValueTask<IMuninNodeServer> CreateAsync(
+    public ValueTask<IMuninNodeListener> CreateAsync(
       EndPoint endPoint,
       IMuninNode node,
       CancellationToken cancellationToken
     )
 #pragma warning disable CA2000
       => new(
-        new MuninNodeServer(
+        new MuninNodeListener(
           endPoint: endPoint,
           logger: null,
           serviceProvider: null