diff --git a/Networking/IConnection.cs b/Networking/IConnection.cs new file mode 100644 index 0000000..cd0cb95 --- /dev/null +++ b/Networking/IConnection.cs @@ -0,0 +1,22 @@ +using System.Net; + +namespace Server.Networking; + +public interface IConnection : IAsyncDisposable +{ + Guid Id { get; } + EndPoint? RemoteEndPoint { get; } + DateTime LastSeenUtc { get; } + + // Send a raw payload (already framed/serialized by caller) + ValueTask SendAsync(ReadOnlyMemory payload, CancellationToken ct = default); + + // Receive next **complete** message (length-prefixed by transport adapter) + ValueTask?> ReceiveAsync(CancellationToken ct = default); + + // For heartbeats/metrics + bool IsAlive { get; } + + // Close with reason + ValueTask CloseAsync(string reason, CancellationToken ct = default); +} diff --git a/Networking/MessageRouter.cs b/Networking/MessageRouter.cs new file mode 100644 index 0000000..e6f3157 --- /dev/null +++ b/Networking/MessageRouter.cs @@ -0,0 +1,38 @@ +using System; +using System.Threading; +using System.Threading.Tasks; +using Microsoft.Extensions.Logging; +using Server.Networking.Messages; + +namespace Server.Networking; + +public sealed class MessageRouter +{ + private readonly ILogger _logger; + private readonly IMessageSerializer _serializer = new JsonSerializerAdapter(); + + public MessageRouter(ILogger logger) => _logger = logger; + + public async Task OnMessageAsync(IConnection connection, ReadOnlyMemory data, CancellationToken cancellationToken) + { + var clientMessage = _serializer.Deserialize(data); + + switch (clientMessage.OpCode) + { + case 1: // Hello / Echo + _logger.LogDebug("HELLO from {ConnectionId}", connection.Id); + await SendAsync(connection, new ServerMessage(1, clientMessage.Payload), cancellationToken); + break; + + default: + _logger.LogWarning("Unknown opcode {OpCode} from {ConnectionId}", clientMessage.OpCode, connection.Id); + break; + } + } + + public Task SendAsync(IConnection connection, ServerMessage message, CancellationToken cancellationToken) + { + var bytes = _serializer.Serialize(message); + return connection.SendAsync(bytes, cancellationToken).AsTask(); + } +} diff --git a/Networking/Messages/Contract.cs b/Networking/Messages/Contract.cs new file mode 100644 index 0000000..f9158e6 --- /dev/null +++ b/Networking/Messages/Contract.cs @@ -0,0 +1,5 @@ +namespace Server.Networking.Messages; + +// Unified, descriptive contracts +public sealed record ClientMessage(int OpCode, byte[] Payload); +public sealed record ServerMessage(int OpCode, byte[] Payload); diff --git a/Networking/Messages/IMessageSerializer.cs b/Networking/Messages/IMessageSerializer.cs new file mode 100644 index 0000000..604f634 --- /dev/null +++ b/Networking/Messages/IMessageSerializer.cs @@ -0,0 +1,9 @@ +namespace Server.Networking.Messages; + + +public interface IMessageSerializer +{ + byte[] Serialize(T message); + T Deserialize(ReadOnlyMemory bytes); +} + diff --git a/Networking/Messages/JsonSerializerAdapter.cs b/Networking/Messages/JsonSerializerAdapter.cs new file mode 100644 index 0000000..165f81d --- /dev/null +++ b/Networking/Messages/JsonSerializerAdapter.cs @@ -0,0 +1,20 @@ +using System; +using System.Text.Json; + +namespace Server.Networking.Messages; + +public sealed class JsonSerializerAdapter : IMessageSerializer +{ + private static readonly JsonSerializerOptions Options = new() + { + PropertyNamingPolicy = JsonNamingPolicy.CamelCase, + WriteIndented = false, + IncludeFields = true + }; + + public byte[] Serialize(T message) => + JsonSerializer.SerializeToUtf8Bytes(message, Options); + + public T Deserialize(ReadOnlyMemory bytes) => + JsonSerializer.Deserialize(bytes.Span, Options)!; +} diff --git a/Networking/NetworkManager.cs b/Networking/NetworkManager.cs new file mode 100644 index 0000000..08a8198 --- /dev/null +++ b/Networking/NetworkManager.cs @@ -0,0 +1,144 @@ +using System.Collections.Concurrent; +using System.Net; +using System.Net.Sockets; +using System.Net.WebSockets; +using Microsoft.AspNetCore.Http; +using Microsoft.Extensions.Logging; + +namespace Server.Networking; + +public sealed class NetworkManager +{ + private readonly ILogger _log; + private readonly MessageRouter _router; + private readonly ConcurrentDictionary _connections = new(); + + private readonly TimeSpan _tickInterval; + private readonly TimeSpan _idleTimeout; + private readonly int _maxConnections; + + public NetworkManager(ILogger log, MessageRouter router) + { + _log = log; + _router = router; + + var tickHz = int.TryParse(Environment.GetEnvironmentVariable("TICK_RATE_HZ"), out var hz) ? Math.Clamp(hz, 1, 120) : 20; + _tickInterval = TimeSpan.FromMilliseconds(1000.0 / tickHz); + + _idleTimeout = TimeSpan.FromSeconds(int.TryParse(Environment.GetEnvironmentVariable("IDLE_TIMEOUT_S"), out var idle) ? Math.Clamp(idle, 10, 300) : 45); + _maxConnections = int.TryParse(Environment.GetEnvironmentVariable("MAX_CONN"), out var mc) ? Math.Max(mc, 100) : 10_000; + + _log.LogInformation("Tick={Hz}Hz IdleTimeout={Idle}s MaxConn={Max}", tickHz, _idleTimeout.TotalSeconds, _maxConnections); + } + + public async Task AcceptWebSocketAsync(HttpContext ctx, WebSocket ws) + { + if (_connections.Count >= _maxConnections) + { + await ws.CloseAsync(WebSocketCloseStatus.PolicyViolation, "server full", CancellationToken.None); + return; + } + + var conn = new WebSocketConnection(ws, ctx.Connection.RemoteIpAddress == null ? null : new IPEndPoint(ctx.Connection.RemoteIpAddress, ctx.Connection.RemotePort)); + _connections[conn.Id] = conn; + + _log.LogInformation("WS connected {Id} {Remote}", conn.Id, conn.RemoteEndPoint); + + try + { + while (conn.IsAlive) + { + using var cts = new CancellationTokenSource(_idleTimeout); + var data = await conn.ReceiveAsync(cts.Token); + if (data is null) break; + await _router.OnMessageAsync(conn, data.Value, CancellationToken.None); + } + } + catch (OperationCanceledException) { /* idle timeout */ } + catch (Exception ex) { _log.LogWarning(ex, "WS loop error {Id}", conn.Id); } + finally + { + await CleanupAsync(conn, "ws closed"); + } + } + + public async Task AcceptTcpLoopAsync(TcpListener listener, CancellationToken stopping) + { + while (!stopping.IsCancellationRequested) + { + TcpClient? client = null; + try + { + client = await listener.AcceptTcpClientAsync(stopping); + if (_connections.Count >= _maxConnections) { client.Close(); continue; } + + _ = HandleTcpClientAsync(client, stopping); + } + catch (OperationCanceledException) { break; } + catch (Exception ex) { _log.LogError(ex, "TCP accept failed"); client?.Close(); } + } + } + + private async Task HandleTcpClientAsync(TcpClient client, CancellationToken ct) + { + var conn = new TcpConnection(client); + _connections[conn.Id] = conn; + _log.LogInformation("TCP connected {Id} {Remote}", conn.Id, conn.RemoteEndPoint); + try + { + while (conn.IsAlive && !ct.IsCancellationRequested) + { + using var idleCts = new CancellationTokenSource(_idleTimeout); + var linked = CancellationTokenSource.CreateLinkedTokenSource(idleCts.Token, ct); + var data = await conn.ReceiveAsync(linked.Token); + if (data is null) break; + await _router.OnMessageAsync(conn, data.Value, ct); + } + } + catch (OperationCanceledException) { /* idle timeout or shutdown */ } + catch (Exception ex) { _log.LogWarning(ex, "TCP loop error {Id}", conn.Id); } + finally + { + await CleanupAsync(conn, "tcp closed"); + } + } + + public async Task RunTickLoopAsync(CancellationToken stopping) + { + var timer = new PeriodicTimer(_tickInterval); + try + { + while (!stopping.IsCancellationRequested && await timer.WaitForNextTickAsync(stopping)) + { + await TickAsync(stopping); + } + } + catch (OperationCanceledException) { /* shutting down */ } + finally { timer.Dispose(); } + } + + private Task TickAsync(CancellationToken ct) + { + // Example: prune idle, broadcast heartbeat, step simulation, etc. + var now = DateTime.UtcNow; + foreach (var (id, conn) in _connections) + { + if (now - conn.LastSeenUtc > _idleTimeout + TimeSpan.FromSeconds(5)) + { + _ = CleanupAsync(conn, "idle prune"); + } + } + // TODO: call your simulation step here + return Task.CompletedTask; + } + + private async Task CleanupAsync(IConnection conn, string reason) + { + if (_connections.TryRemove(conn.Id, out _)) + { + _log.LogInformation("Disconnected {Id} ({Reason})", conn.Id, reason); + await conn.CloseAsync(reason); + await conn.DisposeAsync(); + } + } +} diff --git a/Networking/TcpConnection.cs b/Networking/TcpConnection.cs new file mode 100644 index 0000000..9dcaa4c --- /dev/null +++ b/Networking/TcpConnection.cs @@ -0,0 +1,80 @@ +using System; +using System.Buffers; +using System.Net; +using System.Net.Sockets; +using System.Threading; +using System.Threading.Tasks; + +namespace Server.Networking; + +public sealed class TcpConnection : IConnection +{ + private readonly TcpClient _tcpClient; + private readonly NetworkStream _networkStream; + private volatile bool _isClosed; + + public Guid Id { get; } = Guid.NewGuid(); + public EndPoint? RemoteEndPoint => _tcpClient.Client.RemoteEndPoint; + public DateTime LastSeenUtc { get; private set; } = DateTime.UtcNow; + public bool IsAlive => !_isClosed && _tcpClient.Connected; + + public TcpConnection(TcpClient tcpClient) + { + _tcpClient = tcpClient; + _tcpClient.NoDelay = true; + _networkStream = tcpClient.GetStream(); + } + + public async ValueTask?> ReceiveAsync(CancellationToken cancellationToken = default) + { + var headerBuffer = new byte[4]; + + // Await the framework ReadExactlyAsync (no return value) + await _networkStream.ReadExactlyAsync(headerBuffer.AsMemory(0, 4), cancellationToken); + + int payloadLength = + (headerBuffer[0] << 24) | + (headerBuffer[1] << 16) | + (headerBuffer[2] << 8) | + headerBuffer[3]; + + if (payloadLength <= 0 || payloadLength > 4 * 1024 * 1024) + throw new InvalidOperationException("Invalid frame length."); + + byte[] payloadBuffer = ArrayPool.Shared.Rent(payloadLength); + await _networkStream.ReadExactlyAsync(payloadBuffer.AsMemory(0, payloadLength), cancellationToken); + + LastSeenUtc = DateTime.UtcNow; + return new ReadOnlyMemory(payloadBuffer, 0, payloadLength); + } + + public async ValueTask SendAsync(ReadOnlyMemory payload, CancellationToken cancellationToken = default) + { + int length = payload.Length; + + var header = new byte[4]; + header[0] = (byte)((length >> 24) & 0xFF); + header[1] = (byte)((length >> 16) & 0xFF); + header[2] = (byte)((length >> 8) & 0xFF); + header[3] = (byte)(length & 0xFF); + + await _networkStream.WriteAsync(header, cancellationToken); + await _networkStream.WriteAsync(payload, cancellationToken); + await _networkStream.FlushAsync(cancellationToken); + } + + public ValueTask CloseAsync(string reason, CancellationToken cancellationToken = default) + { + _isClosed = true; + try { _tcpClient.Close(); } catch { } + return ValueTask.CompletedTask; + } + + public ValueTask DisposeAsync() + { + _tcpClient.Dispose(); + return ValueTask.CompletedTask; + } +} + + diff --git a/Networking/WebSocketConnection.cs b/Networking/WebSocketConnection.cs new file mode 100644 index 0000000..74c7be3 --- /dev/null +++ b/Networking/WebSocketConnection.cs @@ -0,0 +1,113 @@ +using System.Buffers; +using System.Net; +using System.Net.WebSockets; +using System.Threading.Channels; + +namespace Server.Networking; + +public sealed class WebSocketConnection : IConnection +{ + private readonly WebSocket _webSocket; + private readonly EndPoint? _remoteEndPoint; + private readonly Channel _outboundQueue = Channel.CreateBounded(new BoundedChannelOptions(256) + { + SingleReader = true, + SingleWriter = false, + FullMode = BoundedChannelFullMode.DropOldest + }); + + private readonly Task _senderLoopTask; + private volatile bool _isClosed; + + public Guid Id { get; } = Guid.NewGuid(); + public EndPoint? RemoteEndPoint => _remoteEndPoint; + public DateTime LastSeenUtc { get; private set; } = DateTime.UtcNow; + public bool IsAlive => !_isClosed && _webSocket.State == WebSocketState.Open; + + public WebSocketConnection(WebSocket webSocket, EndPoint? remoteEndPoint) + { + _webSocket = webSocket; + _remoteEndPoint = remoteEndPoint; + _senderLoopTask = Task.Run(SenderLoopAsync); + } + + public async ValueTask?> ReceiveAsync(CancellationToken cancellationToken = default) + { + // Read exactly 4 bytes for the big-endian length header (could be fragmented) + var header = new byte[4]; + int headerFilled = 0; + + while (headerFilled < 4) + { + var result = await _webSocket.ReceiveAsync(new ArraySegment(header, headerFilled, 4 - headerFilled), cancellationToken); + if (result.MessageType == WebSocketMessageType.Close || result.Count == 0) return null; + headerFilled += result.Count; + } + + int payloadLength = + (header[0] << 24) | + (header[1] << 16) | + (header[2] << 8) | + header[3]; + + if (payloadLength <= 0 || payloadLength > 4 * 1024 * 1024) + throw new InvalidOperationException("Invalid frame length."); + + byte[] payloadBuffer = ArrayPool.Shared.Rent(payloadLength); + int filled = 0; + + while (filled < payloadLength) + { + var segment = new ArraySegment(payloadBuffer, filled, payloadLength - filled); + var result = await _webSocket.ReceiveAsync(segment, cancellationToken); + if (result.MessageType == WebSocketMessageType.Close) { ArrayPool.Shared.Return(payloadBuffer); return null; } + if (result.Count == 0) continue; + filled += result.Count; + } + + LastSeenUtc = DateTime.UtcNow; + return new ReadOnlyMemory(payloadBuffer, 0, payloadLength); + } + + public async ValueTask SendAsync(ReadOnlyMemory payload, CancellationToken cancellationToken = default) + { + int length = payload.Length; + var framed = new byte[length + 4]; + framed[0] = (byte)((length >> 24) & 0xFF); + framed[1] = (byte)((length >> 16) & 0xFF); + framed[2] = (byte)((length >> 8) & 0xFF); + framed[3] = (byte)(length & 0xFF); + payload.CopyTo(framed.AsMemory(4)); + + await _outboundQueue.Writer.WriteAsync(framed, cancellationToken); + } + + private async Task SenderLoopAsync() + { + try + { + while (await _outboundQueue.Reader.WaitToReadAsync()) + { + while (_outboundQueue.Reader.TryRead(out var framed)) + { + await _webSocket.SendAsync(framed, WebSocketMessageType.Binary, endOfMessage: true, CancellationToken.None); + } + } + } + catch { /* optional logging */ } + } + + public async ValueTask CloseAsync(string reason, CancellationToken cancellationToken = default) + { + if (_isClosed) return; + _isClosed = true; + try { await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, reason, cancellationToken); } + catch { /* ignore */ } + } + + public async ValueTask DisposeAsync() + { + await CloseAsync("dispose"); + _webSocket.Dispose(); + } +} diff --git a/Program.cs b/Program.cs index 6cf6935..d88dee2 100644 --- a/Program.cs +++ b/Program.cs @@ -1,6 +1,39 @@ +using System.Net; +using System.Net.Sockets; +using Server.Networking; + var builder = WebApplication.CreateBuilder(args); +builder.Services.AddSingleton(); +builder.Services.AddSingleton(); var app = builder.Build(); +app.UseWebSockets(new WebSocketOptions +{ + KeepAliveInterval = TimeSpan.FromSeconds(20), + ReceiveBufferSize = 64 * 1024 +}); -app.MapGet("/", () => "SystemRevival Server is up!"); +app.Map("/ws", async (HttpContext httpContext, NetworkManager networkManager) => +{ + if (!httpContext.WebSockets.IsWebSocketRequest) + { + httpContext.Response.StatusCode = StatusCodes.Status400BadRequest; + return; + } -app.Run(); \ No newline at end of file + var acceptedWebSocket = await httpContext.WebSockets.AcceptWebSocketAsync(); + await networkManager.AcceptWebSocketAsync(httpContext, acceptedWebSocket); +}); + +// Start TCP listener +int tcpPort = int.TryParse(Environment.GetEnvironmentVariable("TCP_PORT"), out var parsed) ? parsed : 40000; +var tcpListener = new TcpListener(IPAddress.Any, tcpPort); +tcpListener.Start(); +app.Logger.LogInformation("TCP listening on {Port}", tcpPort); + +var networkManagerInstance = app.Services.GetRequiredService(); +_ = networkManagerInstance.AcceptTcpLoopAsync(tcpListener, app.Lifetime.ApplicationStopping); + +// Tick loop +_ = networkManagerInstance.RunTickLoopAsync(app.Lifetime.ApplicationStopping); + +await app.RunAsync(); \ No newline at end of file