feat: add event listeners for connection context

Author: CypherPotato

cadente/Sisk.Cadente/HttpConnection.cs

@@ -18,6 +18,7 @@ sealed class HttpConnection : IDisposable {
     private readonly HttpHost _host;
     private readonly IPEndPoint _endpoint;
     private readonly Stream _connectionStream;
+    private readonly HttpHostClientContext _clientContext;
     private bool disposedValue;
 
 #if DEBUG
@@ -30,7 +31,8 @@ sealed class HttpConnection : IDisposable {
     public const int REQUEST_BUFFER_SIZE = 8192;
     public const int RESPONSE_BUFFER_SIZE = 4096;
 
-    public HttpConnection ( Stream connectionStream, HttpHost host, IPEndPoint endpoint ) {
+    public HttpConnection ( HttpHostClientContext clientContext, Stream connectionStream, HttpHost host, IPEndPoint endpoint ) {
+        this._clientContext = clientContext;
         this._connectionStream = connectionStream;
         this._host = host;
         this._endpoint = endpoint;
@@ -50,6 +52,7 @@ public async Task<HttpConnectionState> HandleConnectionEvents () {
                 }
 
                 HttpHostContext managedSession = new HttpHostContext ( nextRequest, this._endpoint, this._connectionStream );
+                await this._clientContext.InvokeContextCreated ( managedSession );
                 await this._host.InvokeContextCreated ( managedSession );
 
                 if (!managedSession.KeepAlive || !nextRequest.CanKeepAlive) {

cadente/Sisk.Cadente/HttpContextHandler.cs

@@ -14,4 +14,11 @@ namespace Sisk.Cadente;
 /// </summary>
 /// <param name="sender">The <see cref="HttpHost"/> which created the <see cref="HttpHostContext"/> object.</param>
 /// <param name="session">The HTTP session associated with the action.</param>
-public delegate Task HttpContextHandler ( HttpHost sender, HttpHostContext session );
+public delegate Task HttpContextHandler ( HttpHost sender, HttpHostContext session );
+
+/// <summary>
+/// Represents a method that takes an <see cref="HttpHostClientContext"/> as a parameter and does not return a value.
+/// </summary>
+/// <param name="sender">The <see cref="HttpHost"/> which created the <see cref="HttpHostContext"/> object.</param>
+/// <param name="context">The HTTP context associated with the action.</param>
+public delegate Task HttpClientContextHandler ( HttpHost sender, HttpHostClientContext context );

cadente/Sisk.Cadente/HttpHost.cs

@@ -33,6 +33,11 @@ public sealed class HttpHost : IDisposable {
     /// </summary>
     public event HttpContextHandler? ContextCreated;
 
+    /// <summary>
+    /// Gets or sets the action handler for incoming HTTP clients.
+    /// </summary>
+    public event HttpClientContextHandler? ClientCreated;
+
     /// <summary>
     /// Gets a value indicating whether this <see cref="HttpHost"/> has been disposed.
     /// </summary>
@@ -108,7 +113,10 @@ private async Task HandleTcpClient ( TcpClient client ) {
                 connectionStream = clientStream;
             }
 
-            using (HttpConnection connection = new HttpConnection ( connectionStream, this, (IPEndPoint) client.Client.RemoteEndPoint! )) {
+            IPEndPoint clientEndpoint = (IPEndPoint) client.Client.RemoteEndPoint!;
+            using HttpHostClientContext clientContext = new HttpHostClientContext ( client, this, clientEndpoint );
+
+            using (HttpConnection connection = new HttpConnection ( clientContext, connectionStream, this, clientEndpoint )) {
 
                 if (connectionStream is SslStream sslStream) {
                     try {
@@ -117,6 +125,8 @@ await sslStream.AuthenticateAsServerAsync (
                             clientCertificateRequired: this.HttpsOptions.ClientCertificateRequired,
                             checkCertificateRevocation: this.HttpsOptions.CheckCertificateRevocation,
                             enabledSslProtocols: this.HttpsOptions.AllowedProtocols );
+
+                        clientContext.RemoteCertificate = sslStream.RemoteCertificate;
                     }
                     catch (Exception) {
                         return;
@@ -144,6 +154,8 @@ private void Dispose ( bool disposing ) {
 
     [MethodImpl ( MethodImplOptions.AggressiveInlining )]
     internal async ValueTask InvokeContextCreated ( HttpHostContext context ) {
+        if (!this.disposedValue)
+            return;
         if (ContextCreated != null)
             await ContextCreated.Invoke ( this, context );
     }

cadente/Sisk.Cadente/HttpHostClientContext.cs

@@ -0,0 +1,95 @@
+// The Sisk Framework source code
+// Copyright (c) 2024- PROJECT PRINCIPIUM and all Sisk contributors
+//
+// The code below is licensed under the MIT license as
+// of the date of its publication, available at
+//
+// File name:   HttpHostClientContext.cs
+// Repository:  https://github.com/sisk-http/core
+
+using System.Net;
+using System.Net.Sockets;
+using System.Runtime.CompilerServices;
+using System.Security.Cryptography.X509Certificates;
+
+namespace Sisk.Cadente;
+
+/// <summary>
+/// Represents an HTTP connection state that manages the entire client connection.
+/// </summary>
+public sealed class HttpHostClientContext : IDisposable {
+
+    private TcpClient client;
+    private AutoResetEvent disposedEvent = new AutoResetEvent ( false );
+    private HttpHost baseHost;
+    bool ended = false;
+
+    /// <summary>
+    /// Gets the remote address of the connected client.
+    /// </summary>
+    public IPEndPoint RemoteAddress { get; }
+
+    /// <summary>
+    /// Gets the remote certificate of the connected client if authenticated with an SSL connection.
+    /// </summary>
+    public X509Certificate? RemoteCertificate { get; internal set; }
+
+    /// <summary>
+    /// Gets or sets the action handler for incoming HTTP requests within this client context.
+    /// </summary>
+    public event HttpContextHandler? ContextCreated;
+
+    /// <summary>
+    /// Closes the client connection.
+    /// </summary>
+
+    // Note: This method shouldn't be called on the dispose. The HttpHost.HandleTcpClient method should
+    // dispose the TcpClient instead.
+    public void Close () {
+        this.client.Close ();
+        this.ended = true;
+    }
+
+    /// <summary>
+    /// Blocks the current thread until this <see cref="HttpHostClientContext"/> connection
+    /// is terminated.
+    /// </summary>
+    public bool WaitUntilClose () {
+        return this.disposedEvent.WaitOne ();
+    }
+
+    /// <summary>
+    /// Blocks the current thread until this <see cref="HttpHostClientContext"/> connection
+    /// is terminated, using a maximum timeout interval.
+    /// </summary>
+    /// <param name="timeout">Defines the maximum time waiting for the connection termination.</param>
+    /// <param name="closeOnTimeout">Defines if this client context should terminate the client connection if the timeout is reached.</param>
+    public bool WaitUntilClose ( TimeSpan timeout, bool closeOnTimeout = false ) {
+        var b = this.disposedEvent.WaitOne ( timeout );
+        if (!b && closeOnTimeout)
+            this.Close ();
+
+        return b;
+    }
+
+    internal HttpHostClientContext ( TcpClient client, HttpHost baseHost, IPEndPoint remoteAddress ) {
+        this.baseHost = baseHost;
+        this.RemoteAddress = remoteAddress;
+        this.client = client;
+    }
+
+    [MethodImpl ( MethodImplOptions.AggressiveInlining )]
+    internal async ValueTask InvokeContextCreated ( HttpHostContext context ) {
+        if (this.ended)
+            return;
+        if (ContextCreated != null)
+            await ContextCreated.Invoke ( this.baseHost, context );
+    }
+
+    /// <inheritdoc/>
+    public void Dispose () {
+        this.ended = true;
+        this.disposedEvent.Set ();
+        this.disposedEvent.Dispose ();
+    }
+}