Add networking foundation — 9-project C# solution (compiles clean)
Implements the modular networking layer for SOR Server: - SOR.Networking.Abstractions: pure interfaces (ITransport, IClientConnection, IMessageSerializer, IMessageDispatcher, IMessageHandler, IEventBus, IClientPush) - SOR.Networking.WebSocket: ITransport + IClientConnection over System.Net.WebSockets - SOR.Networking.Nats: IEventBus over NATS.Net (INatsConnection) - SOR.Networking.Redis: IClientPush over Redis Pub/Sub - SOR.Shared: ServiceResult<T>, RedisKeys, NatsSubjects, ServerMessage, JSON serializer - SOR.Shared.Proto: auth.proto with gRPC AuthService contract - SOR.Gateway: accept loop, auth handshake, dispatcher, Redis push subscriber - SOR.Auth: stub gRPC handler (placeholder responses) - SOR.Host: multi-service runner via ENABLED_SERVICES env var; wires all DI All concrete implementations are wired exclusively in SOR.Host — every transport, broker, and push implementation can be swapped by changing only Program.cs. dotnet build SOR.slnx → 0 errors, 0 warnings Generated with [Claude Code](https://claude.ai/code) via [Happy](https://happy.engineering) Co-Authored-By: Claude <noreply@anthropic.com> Co-Authored-By: Happy <yesreply@happy.engineering>
This commit is contained in:
@@ -0,0 +1,15 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
<PropertyGroup>
|
||||
<AssemblyName>SOR.Networking.WebSocket</AssemblyName>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<!-- ASP.NET Core framework reference: gives access to IApplicationBuilder,
|
||||
HttpContext, WebSocket types, middleware APIs, etc.
|
||||
Note: AddWebSockets() from Microsoft.AspNetCore.WebSockets is called in
|
||||
SOR.Host.Program.cs (which uses Microsoft.NET.Sdk.Web), not here. -->
|
||||
<FrameworkReference Include="Microsoft.AspNetCore.App" />
|
||||
|
||||
<ProjectReference Include="..\SOR.Networking.Abstractions\SOR.Networking.Abstractions.csproj" />
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
@@ -0,0 +1,122 @@
|
||||
namespace SOR.Networking.WebSocket;
|
||||
|
||||
using Microsoft.AspNetCore.Builder;
|
||||
using Microsoft.AspNetCore.Http;
|
||||
using Microsoft.Extensions.Configuration;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Options;
|
||||
using SOR.Networking.Abstractions.Transport;
|
||||
|
||||
/// <summary>
|
||||
/// Extension methods to register and wire the WebSocket transport.
|
||||
///
|
||||
/// Usage in SOR.Host.Program.cs:
|
||||
/// builder.Services.AddWebSocketTransport(builder.Configuration);
|
||||
/// ...
|
||||
/// app.UseWebSocketTransport(); // Must come BEFORE UseRouting()
|
||||
/// </summary>
|
||||
public static class ServiceRegistration
|
||||
{
|
||||
/// <summary>
|
||||
/// Registers the WebSocket transport in the DI container.
|
||||
///
|
||||
/// What this registers:
|
||||
/// - WebSocketTransportOptions from appsettings.json "WebSocket" section
|
||||
/// - WebSocketTransport as Singleton (the transport lives for the process lifetime)
|
||||
/// - ITransport → WebSocketTransport (the interface Gateway depends on)
|
||||
/// - ASP.NET Core's built-in WebSocket middleware (services.AddWebSockets)
|
||||
/// </summary>
|
||||
public static IServiceCollection AddWebSocketTransport(
|
||||
this IServiceCollection services,
|
||||
IConfiguration configuration)
|
||||
{
|
||||
// Bind the "WebSocket" config section to the typed options class.
|
||||
// IOptions{WebSocketTransportOptions} can then be injected anywhere.
|
||||
services.Configure<WebSocketTransportOptions>(
|
||||
configuration.GetSection("WebSocket"));
|
||||
|
||||
// Register the concrete transport as Singleton.
|
||||
// GatewayHostedService injects ITransport (the interface).
|
||||
// The middleware (UseWebSocketTransport) injects WebSocketTransport directly
|
||||
// to call EnqueueConnectionAsync — that's why we register it by concrete type too.
|
||||
services.AddSingleton<WebSocketTransport>();
|
||||
|
||||
// Register ITransport → resolve WebSocketTransport from the container.
|
||||
// This means: anywhere ITransport is injected, the container provides
|
||||
// the already-registered WebSocketTransport singleton.
|
||||
services.AddSingleton<ITransport>(
|
||||
sp => sp.GetRequiredService<WebSocketTransport>());
|
||||
|
||||
// NOTE: services.AddWebSockets() must be called separately in SOR.Host.Program.cs.
|
||||
// AddWebSockets is an ASP.NET Core extension that resolves correctly only from a
|
||||
// Microsoft.NET.Sdk.Web project. SOR.Host (the entry point) calls it before
|
||||
// calling AddWebSocketTransport(). See SOR.Host.Program.cs for details.
|
||||
|
||||
return services;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Inserts the WebSocket upgrade middleware into the ASP.NET Core pipeline.
|
||||
///
|
||||
/// This middleware intercepts HTTP requests to the configured path ("/ws" by default),
|
||||
/// performs the WebSocket upgrade handshake, and hands the socket to WebSocketTransport.
|
||||
///
|
||||
/// IMPORTANT: Call this BEFORE app.UseRouting() so the WebSocket middleware
|
||||
/// intercepts upgrade requests before they reach the routing layer.
|
||||
///
|
||||
/// The middleware holds the request alive (via TaskCompletionSource) until
|
||||
/// the Gateway's ConnectionLoop signals the connection is done. This keeps
|
||||
/// the ASP.NET Core request pipeline entry point open for the duration of
|
||||
/// the WebSocket session.
|
||||
/// </summary>
|
||||
public static IApplicationBuilder UseWebSocketTransport(this IApplicationBuilder app)
|
||||
{
|
||||
// NOTE: app.UseWebSockets() is called in SOR.Host.Program.cs before this method.
|
||||
// It must be called from the Web SDK host project (SOR.Host) where the
|
||||
// Microsoft.AspNetCore.WebSockets assembly is fully available.
|
||||
|
||||
// Our custom middleware: intercept WebSocket upgrade requests.
|
||||
app.Use(async (context, next) =>
|
||||
{
|
||||
var options = context.RequestServices
|
||||
.GetRequiredService<IOptions<WebSocketTransportOptions>>().Value;
|
||||
|
||||
// Only intercept requests to the configured WebSocket path.
|
||||
// All other requests pass through to the next middleware (routing, gRPC, etc.).
|
||||
if (context.Request.Path != options.Path ||
|
||||
!context.WebSockets.IsWebSocketRequest)
|
||||
{
|
||||
await next(context);
|
||||
return;
|
||||
}
|
||||
|
||||
// Perform the WebSocket upgrade handshake.
|
||||
// AcceptWebSocketAsync sends the HTTP 101 Switching Protocols response.
|
||||
var socket = await context.WebSockets.AcceptWebSocketAsync();
|
||||
|
||||
// A TaskCompletionSource is a manually controlled Task completion signal.
|
||||
// The Gateway's ConnectionLoop calls connectionDone.SetResult() when it finishes
|
||||
// handling this connection. Until then, this middleware holds the request alive.
|
||||
var connectionDone = new TaskCompletionSource(
|
||||
TaskCreationOptions.RunContinuationsAsynchronously);
|
||||
|
||||
// Register a callback: when the request is aborted (client closes browser,
|
||||
// server shutdown, etc.), signal the done TCS so the middleware exits cleanly.
|
||||
context.RequestAborted.Register(() => connectionDone.TrySetResult());
|
||||
|
||||
var transport = context.RequestServices
|
||||
.GetRequiredService<WebSocketTransport>();
|
||||
|
||||
// Enqueue the connection for the Gateway's accept loop.
|
||||
// Pass connectionDone so the connection signals this middleware on dispose.
|
||||
await transport.EnqueueConnectionAsync(
|
||||
socket, context, connectionDone, context.RequestAborted);
|
||||
|
||||
// Wait here until the Gateway signals the connection is done.
|
||||
// This keeps the HTTP request alive for the full WebSocket session duration.
|
||||
await connectionDone.Task;
|
||||
});
|
||||
|
||||
return app;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,281 @@
|
||||
namespace SOR.Networking.WebSocket;
|
||||
|
||||
using System.Buffers;
|
||||
using System.Net.WebSockets;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SOR.Networking.Abstractions.Messaging;
|
||||
using SOR.Networking.Abstractions.Transport;
|
||||
|
||||
/// <summary>
|
||||
/// IClientConnection implementation backed by a System.Net.WebSockets.WebSocket.
|
||||
///
|
||||
/// Key responsibilities:
|
||||
/// - Frame assembly: WebSocket messages can be split across multiple frames.
|
||||
/// ReceiveAsync loops until EndOfMessage = true, assembling into a MemoryStream.
|
||||
/// - Send serialization: only one send can be in flight at a time per WebSocket.
|
||||
/// SemaphoreSlim(1,1) acts as an async mutex on the send path.
|
||||
/// - Ping/pong heartbeat: a background task sends periodic ping frames so
|
||||
/// disconnected clients are detected within one PingIntervalMs cycle.
|
||||
///
|
||||
/// Thread safety:
|
||||
/// - ReceiveAsync: called only by the ConnectionLoop — no concurrent receive.
|
||||
/// - SendBytesAsync: may be called concurrently (push delivery + reply at same time).
|
||||
/// The _sendLock serializes concurrent sends.
|
||||
///
|
||||
/// Lifetime: created by WebSocketTransport per accepted connection.
|
||||
/// Disposed by ConnectionLoop.RunAsync() in its finally block.
|
||||
/// </summary>
|
||||
public sealed class WebSocketClientConnection : IClientConnection
|
||||
{
|
||||
private readonly System.Net.WebSockets.WebSocket _socket;
|
||||
private readonly WebSocketTransportOptions _options;
|
||||
private readonly ILogger _logger;
|
||||
|
||||
// SemaphoreSlim(1, 1) is a lightweight async-compatible mutex.
|
||||
// Unlike 'lock', it can be awaited without blocking the thread.
|
||||
private readonly SemaphoreSlim _sendLock = new(1, 1);
|
||||
|
||||
// CancellationTokenSource for the ping loop. Cancelled on dispose.
|
||||
private readonly CancellationTokenSource _pingSts = new();
|
||||
|
||||
// Signals the middleware that this connection's loop has finished,
|
||||
// so the middleware can release the HTTP request cleanly.
|
||||
private readonly TaskCompletionSource _connectionDone;
|
||||
|
||||
private bool _disposed;
|
||||
|
||||
public string ConnectionId { get; }
|
||||
public string RemoteAddress { get; }
|
||||
|
||||
public bool IsConnected =>
|
||||
!_disposed && _socket.State == WebSocketState.Open;
|
||||
|
||||
public WebSocketClientConnection(
|
||||
System.Net.WebSockets.WebSocket socket,
|
||||
string connectionId,
|
||||
string remoteAddress,
|
||||
WebSocketTransportOptions options,
|
||||
ILogger logger,
|
||||
TaskCompletionSource connectionDone)
|
||||
{
|
||||
_socket = socket;
|
||||
ConnectionId = connectionId;
|
||||
RemoteAddress = remoteAddress;
|
||||
_options = options;
|
||||
_logger = logger;
|
||||
_connectionDone = connectionDone;
|
||||
|
||||
// Start the ping loop in the background immediately.
|
||||
// '_ =' discards the Task intentionally — the loop runs fire-and-forget.
|
||||
// Exceptions inside are caught within the loop and logged.
|
||||
_ = RunPingLoopAsync(_pingSts.Token);
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
/// <remarks>
|
||||
/// Assembles a complete WebSocket message from one or more frames.
|
||||
/// Returns null on clean close (WebSocketMessageType.Close received).
|
||||
/// Throws WebSocketException on unexpected disconnect — the caller handles it.
|
||||
///
|
||||
/// ArrayPool{byte}.Shared is used to rent receive buffers from a reusable pool
|
||||
/// rather than allocating a new byte[] per receive. Buffers are returned in finally.
|
||||
/// This is a common pattern for high-throughput .NET networking code.
|
||||
/// </remarks>
|
||||
public async Task<IClientMessage?> ReceiveAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
// Rent a buffer from the shared pool. The buffer may be larger than requested.
|
||||
// Always use ArrayPool.Return() in a finally block to avoid pool exhaustion.
|
||||
var buffer = ArrayPool<byte>.Shared.Rent(_options.MaxMessageSizeBytes);
|
||||
try
|
||||
{
|
||||
using var messageStream = new MemoryStream();
|
||||
WebSocketReceiveResult result;
|
||||
|
||||
do
|
||||
{
|
||||
// Receive one frame (may not be the complete message).
|
||||
result = await _socket.ReceiveAsync(
|
||||
new ArraySegment<byte>(buffer), cancellationToken);
|
||||
|
||||
switch (result.MessageType)
|
||||
{
|
||||
case WebSocketMessageType.Close:
|
||||
// Client sent a close frame — clean disconnect.
|
||||
_logger.LogDebug(
|
||||
"WebSocket close received: ConnectionId={ConnectionId} Status={Status}",
|
||||
ConnectionId, result.CloseStatus);
|
||||
return null;
|
||||
|
||||
case WebSocketMessageType.Text:
|
||||
case WebSocketMessageType.Binary:
|
||||
// Check if this frame would push us over the size limit.
|
||||
if (messageStream.Length + result.Count > _options.MaxMessageSizeBytes)
|
||||
{
|
||||
_logger.LogWarning(
|
||||
"Message too large: ConnectionId={ConnectionId} Limit={Limit}",
|
||||
ConnectionId, _options.MaxMessageSizeBytes);
|
||||
await CloseAsync("message_too_large", cancellationToken);
|
||||
return null;
|
||||
}
|
||||
// Append this frame's bytes to the message buffer.
|
||||
messageStream.Write(buffer, 0, result.Count);
|
||||
break;
|
||||
}
|
||||
|
||||
// EndOfMessage = true when all frames of this message have arrived.
|
||||
} while (!result.EndOfMessage);
|
||||
|
||||
// Return the assembled bytes as a RawClientMessage.
|
||||
// The serializer will parse the envelope (type, seq, payload) from these bytes.
|
||||
// We import RawClientMessage from SOR.Networking.Abstractions' concrete type
|
||||
// in SOR.Shared — but this project doesn't reference SOR.Shared.
|
||||
// Solution: return the bytes wrapped in a minimal internal implementation.
|
||||
return new ReceivedMessage(messageStream.ToArray());
|
||||
}
|
||||
finally
|
||||
{
|
||||
// Always return the rented buffer, even if an exception is thrown.
|
||||
ArrayPool<byte>.Shared.Return(buffer);
|
||||
}
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public async ValueTask SendBytesAsync(ReadOnlyMemory<byte> bytes, CancellationToken cancellationToken)
|
||||
{
|
||||
// Acquire the send lock. If another send is in progress, this awaits until it completes.
|
||||
await _sendLock.WaitAsync(cancellationToken);
|
||||
try
|
||||
{
|
||||
if (_socket.State != WebSocketState.Open) return;
|
||||
|
||||
// Send as a binary frame. EndOfMessage = true (single-frame message).
|
||||
await _socket.SendAsync(bytes, WebSocketMessageType.Binary, true, cancellationToken);
|
||||
}
|
||||
finally
|
||||
{
|
||||
// Always release the lock, even if an exception occurs.
|
||||
_sendLock.Release();
|
||||
}
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public async Task CloseAsync(string reason, CancellationToken cancellationToken)
|
||||
{
|
||||
if (_socket.State != WebSocketState.Open) return;
|
||||
|
||||
try
|
||||
{
|
||||
// Send a close frame with a normal closure status.
|
||||
// The client should respond with its own close frame, completing the handshake.
|
||||
await _socket.CloseAsync(
|
||||
WebSocketCloseStatus.NormalClosure,
|
||||
reason,
|
||||
cancellationToken);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
// If the close handshake fails (client already gone), log and continue.
|
||||
_logger.LogDebug(ex,
|
||||
"Close handshake failed: ConnectionId={ConnectionId}", ConnectionId);
|
||||
}
|
||||
}
|
||||
|
||||
// ── Ping/Pong Heartbeat ────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Sends periodic ping frames to detect stale connections.
|
||||
/// RFC 6455: the remote end must respond with a pong frame within a reasonable time.
|
||||
/// ASP.NET Core's WebSocket implementation handles pong responses automatically.
|
||||
/// If the connection drops between pings, the next send or receive will throw.
|
||||
/// </summary>
|
||||
private async Task RunPingLoopAsync(CancellationToken ct)
|
||||
{
|
||||
try
|
||||
{
|
||||
while (!ct.IsCancellationRequested)
|
||||
{
|
||||
await Task.Delay(_options.PingIntervalMs, ct);
|
||||
|
||||
if (_socket.State != WebSocketState.Open) return;
|
||||
|
||||
await _sendLock.WaitAsync(ct);
|
||||
try
|
||||
{
|
||||
// An empty binary frame acts as a ping in our protocol.
|
||||
// For full RFC 6455 ping/pong, WebSocketMessageType.Close is not applicable;
|
||||
// ASP.NET Core handles pong automatically at the Kestrel level.
|
||||
await _socket.SendAsync(
|
||||
ReadOnlyMemory<byte>.Empty,
|
||||
WebSocketMessageType.Binary,
|
||||
endOfMessage: true,
|
||||
ct);
|
||||
}
|
||||
finally
|
||||
{
|
||||
_sendLock.Release();
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
// Normal exit on dispose or shutdown.
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
// Log ping failures but don't crash — the connection loop will detect
|
||||
// the disconnection on the next ReceiveAsync call.
|
||||
_logger.LogDebug(ex,
|
||||
"Ping loop error: ConnectionId={ConnectionId}", ConnectionId);
|
||||
}
|
||||
}
|
||||
|
||||
// ── IAsyncDisposable ──────────────────────────────────────────────────────
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
if (_disposed) return;
|
||||
_disposed = true;
|
||||
|
||||
// Stop the ping loop.
|
||||
await _pingSts.CancelAsync();
|
||||
_pingSts.Dispose();
|
||||
|
||||
// Dispose the send lock.
|
||||
_sendLock.Dispose();
|
||||
|
||||
// Dispose the underlying WebSocket.
|
||||
_socket.Dispose();
|
||||
|
||||
// Signal the middleware that this connection's work is complete.
|
||||
// TrySetResult is used (not SetResult) because RequestAborted may have
|
||||
// already set it if the server is shutting down.
|
||||
_connectionDone.TrySetResult();
|
||||
}
|
||||
|
||||
// ── Inner type: minimal IClientMessage for raw received bytes ─────────────
|
||||
|
||||
/// <summary>
|
||||
/// Lightweight IClientMessage carrying raw wire bytes.
|
||||
/// Type and Seq are populated after IMessageSerializer.Deserialize() is called.
|
||||
/// This inner class is private to SOR.Networking.WebSocket — external code
|
||||
/// only sees the IClientMessage interface.
|
||||
/// </summary>
|
||||
private sealed class ReceivedMessage : IClientMessage
|
||||
{
|
||||
// Before deserialization, Type and Seq are unknown.
|
||||
// They will be set by the serializer layer before dispatch.
|
||||
// We use a mutable design here because the serializer returns a new
|
||||
// RawClientMessage (from SOR.Shared) — this type is only an interim carrier
|
||||
// from ReceiveAsync up to the serializer call in ConnectionLoop.
|
||||
public string Type { get; init; } = string.Empty;
|
||||
public int Seq { get; init; }
|
||||
public ReadOnlyMemory<byte> Payload { get; }
|
||||
|
||||
public ReceivedMessage(byte[] rawBytes)
|
||||
{
|
||||
// The full wire bytes (envelope + payload) are stored as Payload.
|
||||
// The serializer will parse the envelope out of these bytes.
|
||||
Payload = rawBytes;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,122 @@
|
||||
namespace SOR.Networking.WebSocket;
|
||||
|
||||
using System.Net.WebSockets;
|
||||
using System.Threading.Channels;
|
||||
using Microsoft.AspNetCore.Http;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Microsoft.Extensions.Options;
|
||||
using SOR.Networking.Abstractions.Transport;
|
||||
|
||||
/// <summary>
|
||||
/// ITransport implementation for WebSocket connections.
|
||||
///
|
||||
/// How the two sides connect:
|
||||
///
|
||||
/// ┌─────────────────────────────────────────────────────────────┐
|
||||
/// │ ASP.NET Core middleware (UseWebSocketTransport) │
|
||||
/// │ - Intercepts HTTP upgrade requests to the WS path │
|
||||
/// │ - Calls AcceptWebSocketAsync() │
|
||||
/// │ - Calls WebSocketTransport.EnqueueConnectionAsync() │
|
||||
/// └────────────────────────┬────────────────────────────────────┘
|
||||
/// │ Channel.Writer.WriteAsync()
|
||||
/// ▼
|
||||
/// ┌─────────────────────────────────────────────────────────────┐
|
||||
/// │ Channel{IClientConnection} (thread-safe handoff queue) │
|
||||
/// └────────────────────────┬────────────────────────────────────┘
|
||||
/// │ Channel.Reader.ReadAsync()
|
||||
/// ▼
|
||||
/// ┌─────────────────────────────────────────────────────────────┐
|
||||
/// │ GatewayHostedService │
|
||||
/// │ - Calls ITransport.AcceptAsync() (blocks on channel) │
|
||||
/// │ - Gets an IClientConnection and fires ConnectionLoop │
|
||||
/// └─────────────────────────────────────────────────────────────┘
|
||||
///
|
||||
/// The Channel is the key: it decouples the ASP.NET Core middleware thread
|
||||
/// from the Gateway accept loop without any shared mutable state.
|
||||
///
|
||||
/// Lifetime: Singleton.
|
||||
/// </summary>
|
||||
public sealed class WebSocketTransport : ITransport
|
||||
{
|
||||
public string Name => "websocket";
|
||||
|
||||
private readonly WebSocketTransportOptions _options;
|
||||
private readonly ILoggerFactory _loggerFactory;
|
||||
private readonly ILogger<WebSocketTransport> _logger;
|
||||
|
||||
// UnboundedChannel: never drops connections. If Gateway is slow to accept,
|
||||
// connections queue. SingleReader = true allows the channel to optimize
|
||||
// for a single consumer (the Gateway accept loop).
|
||||
private readonly Channel<IClientConnection> _pendingConnections =
|
||||
Channel.CreateUnbounded<IClientConnection>(
|
||||
new UnboundedChannelOptions
|
||||
{
|
||||
SingleReader = true, // Only GatewayHostedService reads
|
||||
SingleWriter = false, // Multiple middleware calls can write concurrently
|
||||
});
|
||||
|
||||
public WebSocketTransport(
|
||||
IOptions<WebSocketTransportOptions> options,
|
||||
ILoggerFactory loggerFactory,
|
||||
ILogger<WebSocketTransport> logger)
|
||||
{
|
||||
_options = options.Value;
|
||||
_loggerFactory = loggerFactory;
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Called by the ASP.NET Core middleware (ServiceRegistration.UseWebSocketTransport)
|
||||
/// when a WebSocket upgrade succeeds. Creates a WebSocketClientConnection and
|
||||
/// enqueues it for the Gateway's accept loop.
|
||||
///
|
||||
/// 'internal' means this method is visible within SOR.Networking.WebSocket but
|
||||
/// not to external assemblies. The middleware and transport live in the same assembly.
|
||||
/// </summary>
|
||||
/// <summary>
|
||||
/// Called by the ASP.NET Core middleware (ServiceRegistration.UseWebSocketTransport)
|
||||
/// when a WebSocket upgrade succeeds. Creates a WebSocketClientConnection and
|
||||
/// enqueues it for the Gateway's accept loop.
|
||||
///
|
||||
/// The connectionDone TaskCompletionSource is stored on the connection and signalled
|
||||
/// when the connection is disposed (ConnectionLoop.RunAsync finally block).
|
||||
/// The middleware awaits connectionDone.Task to keep the HTTP request alive for the
|
||||
/// full WebSocket session, then lets the middleware method return to free resources.
|
||||
///
|
||||
/// 'internal': visible within SOR.Networking.WebSocket but not to external assemblies.
|
||||
/// </summary>
|
||||
internal async Task EnqueueConnectionAsync(
|
||||
System.Net.WebSockets.WebSocket socket,
|
||||
HttpContext httpContext,
|
||||
TaskCompletionSource connectionDone,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var connectionId = Guid.NewGuid().ToString("N");
|
||||
var remote = httpContext.Connection.RemoteIpAddress?.ToString()
|
||||
?? httpContext.Connection.RemotePort.ToString()
|
||||
?? "unknown";
|
||||
|
||||
_logger.LogDebug(
|
||||
"WebSocket upgrade accepted: ConnectionId={ConnectionId} Remote={Remote}",
|
||||
connectionId, remote);
|
||||
|
||||
var connLogger = _loggerFactory.CreateLogger(
|
||||
$"SOR.Networking.WebSocket.Connection.{connectionId[..8]}");
|
||||
|
||||
var connection = new WebSocketClientConnection(
|
||||
socket, connectionId, remote, _options, connLogger, connectionDone);
|
||||
|
||||
// WriteAsync never blocks for an UnboundedChannel.
|
||||
await _pendingConnections.Writer.WriteAsync(connection, cancellationToken);
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
/// <remarks>
|
||||
/// Blocks until a connection is enqueued by the middleware, then dequeues and returns it.
|
||||
/// Throws OperationCanceledException on shutdown (cancellationToken cancelled).
|
||||
/// </remarks>
|
||||
public async Task<IClientConnection> AcceptAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
return await _pendingConnections.Reader.ReadAsync(cancellationToken);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
namespace SOR.Networking.WebSocket;
|
||||
|
||||
/// <summary>
|
||||
/// Configuration options for the WebSocket transport.
|
||||
/// Bound from the "WebSocket" section of appsettings.json via IOptions{WebSocketTransportOptions}.
|
||||
///
|
||||
/// appsettings.json example:
|
||||
/// {
|
||||
/// "WebSocket": {
|
||||
/// "Path": "/ws",
|
||||
/// "PingIntervalMs": 30000,
|
||||
/// "MaxMessageSizeBytes": 65536,
|
||||
/// "AuthTimeoutMs": 10000
|
||||
/// }
|
||||
/// }
|
||||
/// </summary>
|
||||
public sealed class WebSocketTransportOptions
|
||||
{
|
||||
/// <summary>
|
||||
/// The URL path the Gateway listens for WebSocket upgrade requests.
|
||||
/// All other paths are passed through to the normal ASP.NET Core routing pipeline.
|
||||
/// Default: "/ws"
|
||||
/// </summary>
|
||||
public string Path { get; set; } = "/ws";
|
||||
|
||||
/// <summary>
|
||||
/// How often to send a WebSocket ping frame to detect stale connections.
|
||||
/// RFC 6455 compliant clients respond automatically with a pong.
|
||||
/// If no pong is received within this interval the connection is considered dead.
|
||||
/// Default: 30 seconds (30,000 ms)
|
||||
/// </summary>
|
||||
public int PingIntervalMs { get; set; } = 30_000;
|
||||
|
||||
/// <summary>
|
||||
/// Maximum allowed size of a single WebSocket message in bytes.
|
||||
/// Multi-frame messages are assembled up to this limit.
|
||||
/// Messages exceeding this cause the connection to be closed with code 1009 (too large).
|
||||
/// Default: 64 KB (65,536 bytes) — sufficient for all current game message types.
|
||||
/// </summary>
|
||||
public int MaxMessageSizeBytes { get; set; } = 65_536;
|
||||
}
|
||||
Reference in New Issue
Block a user