[增加] Http 模块新增 HttpResponse、HttpResponseEncoder、HttpKeepAliveFilter、ServerSentEventWriter、HttpExtensions 等 HTTP 服务功能

Author: AlianBlank

src/GameFrameX.SuperSocket.Http/HttpExtensions.cs

@@ -0,0 +1,123 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using GameFrameX.SuperSocket.Http;
+using GameFrameX.SuperSocket.Server.Abstractions.Session;
+using SuperSocket.Connection;
+
+namespace SuperSocket.Http
+{
+    /// <summary>
+    /// Extension methods for easier HTTP functionality usage.
+    /// </summary>
+    public static class HttpExtensions
+    {
+        /// <summary>
+        /// Sends an HTTP response to the session.
+        /// </summary>
+        /// <param name="session">The session to send the response to.</param>
+        /// <param name="response">The HTTP response to send.</param>
+        /// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
+        /// <returns>A task that represents the asynchronous operation.</returns>
+        public static async ValueTask SendHttpResponseAsync(
+            this IAppSession session, 
+            HttpResponse response, 
+            CancellationToken cancellationToken = default)
+        {
+            await session.SendAsync(HttpResponseEncoder.Instance, response, cancellationToken);
+        }
+
+        /// <summary>
+        /// Sends a simple HTTP response with the specified status and body.
+        /// </summary>
+        /// <param name="session">The session to send the response to.</param>
+        /// <param name="statusCode">The HTTP status code.</param>
+        /// <param name="body">The response body.</param>
+        /// <param name="contentType">The content type. Defaults to "text/plain".</param>
+        /// <param name="keepAlive">Whether to keep the connection alive.</param>
+        /// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
+        /// <returns>A task that represents the asynchronous operation.</returns>
+        public static async ValueTask SendHttpResponseAsync(
+            this IAppSession session,
+            int statusCode,
+            string body = "",
+            string contentType = "text/plain",
+            bool keepAlive = true,
+            CancellationToken cancellationToken = default)
+        {
+            var response = new HttpResponse(statusCode);
+            response.SetContentType(contentType);
+            response.Body = body;
+            response.KeepAlive = keepAlive;
+
+            await session.SendHttpResponseAsync(response, cancellationToken);
+        }
+
+        /// <summary>
+        /// Sends a JSON HTTP response.
+        /// </summary>
+        /// <param name="session">The session to send the response to.</param>
+        /// <param name="jsonData">The JSON data to send.</param>
+        /// <param name="statusCode">The HTTP status code. Defaults to 200.</param>
+        /// <param name="keepAlive">Whether to keep the connection alive.</param>
+        /// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
+        /// <returns>A task that represents the asynchronous operation.</returns>
+        public static async ValueTask SendJsonResponseAsync(
+            this IAppSession session,
+            string jsonData,
+            int statusCode = 200,
+            bool keepAlive = true,
+            CancellationToken cancellationToken = default)
+        {
+            await session.SendHttpResponseAsync(statusCode, jsonData, "application/json", keepAlive, cancellationToken);
+        }
+
+        /// <summary>
+        /// Creates a Server-Sent Events writer for the session.
+        /// </summary>
+        /// <param name="session">The session to create the SSE writer for.</param>
+        /// <param name="options">Optional SSE configuration options.</param>
+        /// <returns>A new ServerSentEventWriter instance.</returns>
+        public static ServerSentEventWriter CreateSSEWriter(this IAppSession session, ServerSentEventsOptions options = null)
+        {
+            return new ServerSentEventWriter(session.Connection, options);
+        }
+
+        /// <summary>
+        /// Starts a Server-Sent Events stream for the session.
+        /// </summary>
+        /// <param name="session">The session to start SSE for.</param>
+        /// <param name="options">Optional SSE configuration options.</param>
+        /// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
+        /// <returns>A new ServerSentEventWriter instance that has already sent the initial response.</returns>
+        public static async ValueTask<ServerSentEventWriter> StartSSEAsync(
+            this IAppSession session, 
+            ServerSentEventsOptions options = null,
+            CancellationToken cancellationToken = default)
+        {
+            var writer = session.CreateSSEWriter(options);
+            await writer.SendInitialResponseAsync(cancellationToken);
+            return writer;
+        }
+
+        /// <summary>
+        /// Checks if the HTTP request accepts Server-Sent Events.
+        /// </summary>
+        /// <param name="request">The HTTP request to check.</param>
+        /// <returns>True if the request accepts SSE, false otherwise.</returns>
+        public static bool IsSSERequest(this HttpRequest request)
+        {
+            return request.AcceptsEventStream;
+        }
+
+        /// <summary>
+        /// Checks if the HTTP request wants to keep the connection alive.
+        /// </summary>
+        /// <param name="request">The HTTP request to check.</param>
+        /// <returns>True if keep-alive is requested, false otherwise.</returns>
+        public static bool IsKeepAliveRequest(this HttpRequest request)
+        {
+            return request.KeepAlive;
+        }
+    }
+}

src/GameFrameX.SuperSocket.Http/HttpKeepAliveFilter.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Buffers;
+using GameFrameX.SuperSocket.Http;
+using GameFrameX.SuperSocket.ProtoBase;
+using SuperSocket.ProtoBase;
+
+namespace SuperSocket.Http
+{
+    /// <summary>
+    /// Represents a pipeline filter for parsing HTTP requests with keep-alive support.
+    /// This filter can handle multiple requests over a single connection.
+    /// </summary>
+    public class HttpKeepAliveFilter : IPipelineFilter<HttpRequest>
+    {
+        private readonly HttpPipelineFilter _innerFilter;
+        private bool _connectionClosed = false;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="HttpKeepAliveFilter"/> class.
+        /// </summary>
+        public HttpKeepAliveFilter()
+        {
+            _innerFilter = new HttpPipelineFilter();
+        }
+
+        /// <summary>
+        /// Gets or sets the package decoder for the HTTP request.
+        /// </summary>
+        public IPackageDecoder<HttpRequest> Decoder 
+        { 
+            get => _innerFilter.Decoder; 
+            set => _innerFilter.Decoder = value; 
+        }
+
+        /// <summary>
+        /// Gets or sets the next pipeline filter in the chain.
+        /// </summary>
+        public IPipelineFilter<HttpRequest> NextFilter 
+        { 
+            get => _connectionClosed ? null : this;
+            set { } // Keep-alive filter manages its own chain
+        }
+
+        /// <summary>
+        /// Gets or sets the context associated with the pipeline filter.
+        /// </summary>
+        public object Context 
+        { 
+            get => _innerFilter.Context; 
+            set => _innerFilter.Context = value; 
+        }
+
+        /// <summary>
+        /// Filters the data stream to parse an HTTP request with keep-alive support.
+        /// </summary>
+        /// <param name="reader">The sequence reader for the data stream.</param>
+        /// <returns>The parsed <see cref="HttpRequest"/>, or <c>null</c> if more data is needed.</returns>
+        public HttpRequest Filter(ref SequenceReader<byte> reader)
+        {
+            if (_connectionClosed)
+                return null;
+
+            var request = _innerFilter.Filter(ref reader);
+            
+            if (request != null)
+            {
+                // Reset the inner filter for the next request
+                _innerFilter.Reset();
+                
+                // Check if this request should close the connection
+                if (!request.KeepAlive)
+                {
+                    _connectionClosed = true;
+                }
+            }
+
+            return request;
+        }
+
+        /// <summary>
+        /// Resets the state of the pipeline filter.
+        /// </summary>
+        public void Reset()
+        {
+            _innerFilter.Reset();
+            _connectionClosed = false;
+        }
+
+        /// <summary>
+        /// Marks the connection as closed, preventing further request processing.
+        /// </summary>
+        public void CloseConnection()
+        {
+            _connectionClosed = true;
+        }
+    }
+}

src/GameFrameX.SuperSocket.Http/HttpOptions.cs

@@ -0,0 +1,64 @@
+using System;
+
+namespace SuperSocket.Http
+{
+    /// <summary>
+    /// Configuration options for HTTP Keep-Alive functionality.
+    /// </summary>
+    public class HttpKeepAliveOptions
+    {
+        /// <summary>
+        /// Gets or sets the timeout for keep-alive connections in seconds.
+        /// Default is 30 seconds.
+        /// </summary>
+        public int KeepAliveTimeoutSeconds { get; set; } = 30;
+
+        /// <summary>
+        /// Gets or sets the maximum number of requests allowed per connection.
+        /// Default is 1000. Set to 0 for unlimited.
+        /// </summary>
+        public int MaxRequestsPerConnection { get; set; } = 1000;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether keep-alive is enabled by default.
+        /// Default is true for HTTP/1.1.
+        /// </summary>
+        public bool EnableKeepAlive { get; set; } = true;
+    }
+
+    /// <summary>
+    /// Configuration options for Server-Sent Events functionality.
+    /// </summary>
+    public class ServerSentEventsOptions
+    {
+        /// <summary>
+        /// Gets or sets the heartbeat interval in seconds.
+        /// Default is 30 seconds. Set to 0 to disable heartbeat.
+        /// </summary>
+        public int HeartbeatIntervalSeconds { get; set; } = 30;
+
+        /// <summary>
+        /// Gets or sets the retry interval suggested to clients in milliseconds.
+        /// Default is 3000 (3 seconds).
+        /// </summary>
+        public int DefaultRetryIntervalMs { get; set; } = 3000;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether CORS headers should be automatically added.
+        /// Default is true.
+        /// </summary>
+        public bool EnableCors { get; set; } = true;
+
+        /// <summary>
+        /// Gets or sets the CORS origin header value.
+        /// Default is "*" (allow all origins).
+        /// </summary>
+        public string CorsOrigin { get; set; } = "*";
+
+        /// <summary>
+        /// Gets or sets the allowed CORS headers.
+        /// Default is "Cache-Control".
+        /// </summary>
+        public string CorsAllowedHeaders { get; set; } = "Cache-Control";
+    }
+}

src/GameFrameX.SuperSocket.Http/HttpRequest.cs

@@ -33,6 +33,23 @@ public class HttpRequest
         /// </summary>
         public string Body { get; set; }
 
+        /// <summary>
+        /// Gets a value indicating whether the client requests a keep-alive connection.
+        /// </summary>
+        public bool KeepAlive => GetKeepAliveFromHeaders();
+
+        /// <summary>
+        /// Gets a value indicating whether this request supports Server-Sent Events.
+        /// </summary>
+        public bool AcceptsEventStream => 
+            Items?["Accept"]?.Contains("text/event-stream") == true ||
+            Items?["Accept"]?.Contains("*/*") == true;
+
+        /// <summary>
+        /// Gets the value of the Last-Event-ID header for SSE reconnection.
+        /// </summary>
+        public string LastEventId => Items?["Last-Event-ID"];
+
         /// <summary>
         /// Initializes a new instance of the <see cref="HttpRequest"/> class with the specified method, path, version, and items.
         /// </summary>
@@ -47,5 +64,17 @@ public HttpRequest(string method, string path, string httpVersion, NameValueColl
             HttpVersion = httpVersion;
             Items = items;
         }
+
+        private bool GetKeepAliveFromHeaders()
+        {
+            var connection = Items?["Connection"];
+            if (string.IsNullOrEmpty(connection))
+            {
+                // HTTP/1.1 defaults to keep-alive, HTTP/1.0 defaults to close
+                return HttpVersion?.Contains("1.1") == true;
+            }
+
+            return connection.ToLowerInvariant().Contains("keep-alive");
+        }
     }
 }