114 lines
4.0 KiB
C#
114 lines
4.0 KiB
C#
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<byte[]> _outboundQueue = Channel.CreateBounded<byte[]>(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<ReadOnlyMemory<byte>?> 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<byte>(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<byte>.Shared.Rent(payloadLength);
|
|
int filled = 0;
|
|
|
|
while (filled < payloadLength)
|
|
{
|
|
var segment = new ArraySegment<byte>(payloadBuffer, filled, payloadLength - filled);
|
|
var result = await _webSocket.ReceiveAsync(segment, cancellationToken);
|
|
if (result.MessageType == WebSocketMessageType.Close) { ArrayPool<byte>.Shared.Return(payloadBuffer); return null; }
|
|
if (result.Count == 0) continue;
|
|
filled += result.Count;
|
|
}
|
|
|
|
LastSeenUtc = DateTime.UtcNow;
|
|
return new ReadOnlyMemory<byte>(payloadBuffer, 0, payloadLength);
|
|
}
|
|
|
|
public async ValueTask SendAsync(ReadOnlyMemory<byte> 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();
|
|
}
|
|
}
|