refactor implementation of AcceptSingleSessionAsync()

Author: smdn

src/Smdn.Net.MuninNode/Smdn.Net.MuninNode/NodeBase.cs

@@ -201,107 +201,129 @@ public async ValueTask AcceptSingleSessionAsync(
 #endif
       .ConfigureAwait(false);
 
-    IPEndPoint? remoteEndPoint = null;
+    // holds a reference to the endpoint before the client being disposed
+    var remoteEndPoint = client.RemoteEndPoint;
 
     try {
       cancellationToken.ThrowIfCancellationRequested();
 
-      remoteEndPoint = client.RemoteEndPoint as IPEndPoint;
+      if (!CanAccept(client))
+        return;
+
+      await ProcessSessionAsync(
+        client,
+        cancellationToken
+      ).ConfigureAwait(false);
+    }
+    finally {
+      client.Close();
 
-      if (remoteEndPoint is null) {
+      Logger?.LogInformation("[{RemoteEndPoint}] connection closed", remoteEndPoint);
+    }
+
+    bool CanAccept(Socket client)
+    {
+      if (client.RemoteEndPoint is not IPEndPoint remoteIPEndPoint) {
         Logger?.LogWarning(
           "cannot accept {RemoteEndPoint} ({RemoteEndPointAddressFamily})",
           client.RemoteEndPoint?.ToString() ?? "(null)",
           client.RemoteEndPoint?.AddressFamily
         );
-        return;
+
+        return false;
       }
 
-      if (accessRule is not null && !accessRule.IsAcceptable(remoteEndPoint)) {
-        Logger?.LogWarning("access refused: {RemoteEndPoint}", remoteEndPoint);
-        return;
+      if (accessRule is not null && !accessRule.IsAcceptable(remoteIPEndPoint)) {
+        Logger?.LogWarning("access refused: {RemoteEndPoint}", remoteIPEndPoint);
+
+        return false;
       }
 
-      var sessionId = GenerateSessionId(server.LocalEndPoint, remoteEndPoint);
+      return true;
+    }
+  }
 
-      cancellationToken.ThrowIfCancellationRequested();
+  private async ValueTask ProcessSessionAsync(
+    Socket client,
+    CancellationToken cancellationToken
+  )
+  {
+    cancellationToken.ThrowIfCancellationRequested();
 
-      Logger?.LogDebug("[{RemoteEndPoint}] sending banner", remoteEndPoint);
+    // holds a reference to the endpoint before the client being disposed
+    var remoteEndPoint = client.RemoteEndPoint;
+    var sessionId = GenerateSessionId(server!.LocalEndPoint, remoteEndPoint);
 
-      try {
-        await SendResponseAsync(
-          client,
-          $"# munin node at {HostName}",
-          cancellationToken
-        ).ConfigureAwait(false);
-      }
-      catch (SocketException ex) when (
-        ex.SocketErrorCode is
-          SocketError.Shutdown or // EPIPE (32)
-          SocketError.ConnectionAborted or // WSAECONNABORTED (10053)
-          SocketError.OperationAborted or // ECANCELED (125)
-          SocketError.ConnectionReset // ECONNRESET (104)
-      ) {
-        Logger?.LogWarning(
-          "[{RemoteEndPoint}] client closed session while sending banner",
-          remoteEndPoint
-        );
+    Logger?.LogDebug("[{RemoteEndPoint}] sending banner", remoteEndPoint);
 
-        return;
-      }
+    try {
+      await SendResponseAsync(
+        client,
+        $"# munin node at {HostName}",
+        cancellationToken
+      ).ConfigureAwait(false);
+    }
+    catch (SocketException ex) when (
+      ex.SocketErrorCode is
+        SocketError.Shutdown or // EPIPE (32)
+        SocketError.ConnectionAborted or // WSAECONNABORTED (10053)
+        SocketError.OperationAborted or // ECANCELED (125)
+        SocketError.ConnectionReset // ECONNRESET (104)
+    ) {
+      Logger?.LogWarning(
+        "[{RemoteEndPoint}] client closed session while sending banner",
+        remoteEndPoint
+      );
+
+      return;
+    }
 #pragma warning disable CA1031
-      catch (Exception ex) {
-        Logger?.LogCritical(
-          ex,
-          "[{RemoteEndPoint}] unexpected exception occured while sending banner",
-          remoteEndPoint
-        );
+    catch (Exception ex) {
+      Logger?.LogCritical(
+        ex,
+        "[{RemoteEndPoint}] unexpected exception occured while sending banner",
+        remoteEndPoint
+      );
 
-        return;
-      }
+      return;
+    }
 #pragma warning restore CA1031
 
-      cancellationToken.ThrowIfCancellationRequested();
-
-      Logger?.LogInformation("[{RemoteEndPoint}] session started; ID={SessionId}", remoteEndPoint, sessionId);
+    cancellationToken.ThrowIfCancellationRequested();
 
-      try {
-        if (PluginProvider.SessionCallback is not null)
-          await PluginProvider.SessionCallback.ReportSessionStartedAsync(sessionId, cancellationToken).ConfigureAwait(false);
+    Logger?.LogInformation("[{RemoteEndPoint}] session started; ID={SessionId}", remoteEndPoint, sessionId);
 
-        foreach (var plugin in PluginProvider.Plugins) {
-          if (plugin.SessionCallback is not null)
-            await plugin.SessionCallback.ReportSessionStartedAsync(sessionId, cancellationToken).ConfigureAwait(false);
-        }
+    try {
+      if (PluginProvider.SessionCallback is not null)
+        await PluginProvider.SessionCallback.ReportSessionStartedAsync(sessionId, cancellationToken).ConfigureAwait(false);
 
-        // https://docs.microsoft.com/ja-jp/dotnet/standard/io/pipelines
-        var pipe = new Pipe();
+      foreach (var plugin in PluginProvider.Plugins) {
+        if (plugin.SessionCallback is not null)
+          await plugin.SessionCallback.ReportSessionStartedAsync(sessionId, cancellationToken).ConfigureAwait(false);
+      }
 
-        await Task.WhenAll(
-          ReceiveCommandAsync(client, remoteEndPoint, pipe.Writer, cancellationToken),
-          ProcessCommandAsync(client, remoteEndPoint, pipe.Reader, cancellationToken)
-        ).ConfigureAwait(false);
+      // https://docs.microsoft.com/ja-jp/dotnet/standard/io/pipelines
+      var pipe = new Pipe();
 
-        Logger?.LogInformation("[{RemoteEndPoint}] session closed; ID={SessionId}", remoteEndPoint, sessionId);
-      }
-      finally {
-        foreach (var plugin in PluginProvider.Plugins) {
-          if (plugin.SessionCallback is not null)
-            await plugin.SessionCallback.ReportSessionClosedAsync(sessionId, cancellationToken).ConfigureAwait(false);
-        }
+      await Task.WhenAll(
+        ReceiveCommandAsync(client, remoteEndPoint, pipe.Writer, cancellationToken),
+        ProcessCommandAsync(client, remoteEndPoint, pipe.Reader, cancellationToken)
+      ).ConfigureAwait(false);
 
-        if (PluginProvider.SessionCallback is not null)
-          await PluginProvider.SessionCallback.ReportSessionClosedAsync(sessionId, cancellationToken).ConfigureAwait(false);
-      }
+      Logger?.LogInformation("[{RemoteEndPoint}] session closed; ID={SessionId}", remoteEndPoint, sessionId);
     }
     finally {
-      client.Close();
+      foreach (var plugin in PluginProvider.Plugins) {
+        if (plugin.SessionCallback is not null)
+          await plugin.SessionCallback.ReportSessionClosedAsync(sessionId, cancellationToken).ConfigureAwait(false);
+      }
 
-      Logger?.LogInformation("[{RemoteEndPoint}] connection closed", remoteEndPoint);
+      if (PluginProvider.SessionCallback is not null)
+        await PluginProvider.SessionCallback.ReportSessionClosedAsync(sessionId, cancellationToken).ConfigureAwait(false);
     }
   }
 
-  private static string GenerateSessionId(EndPoint? localEndPoint, IPEndPoint remoteEndPoint)
+  private static string GenerateSessionId(EndPoint? localEndPoint, EndPoint? remoteEndPoint)
   {
 #if SYSTEM_SECURITY_CRYPTOGRAPHY_SHA1_HASHSIZEINBYTES
     const int SHA1HashSizeInBytes = SHA1.HashSizeInBytes;
@@ -328,7 +350,7 @@ private static string GenerateSessionId(EndPoint? localEndPoint, IPEndPoint remo
 
   private async Task ReceiveCommandAsync(
     Socket socket,
-    IPEndPoint remoteEndPoint,
+    EndPoint? remoteEndPoint,
     PipeWriter writer,
     CancellationToken cancellationToken
   )
@@ -406,7 +428,7 @@ ex.SocketErrorCode is
 
   private async Task ProcessCommandAsync(
     Socket socket,
-    IPEndPoint remoteEndPoint,
+    EndPoint? remoteEndPoint,
     PipeReader reader,
     CancellationToken cancellationToken
   )