Common networking stuffs
This commit is contained in:
38
Abstract/HandlerManager.cs
Normal file
38
Abstract/HandlerManager.cs
Normal file
@@ -0,0 +1,38 @@
|
||||
using Serilog;
|
||||
|
||||
namespace CommonSocketLibrary.Abstract
|
||||
{
|
||||
public abstract class HandlerManager<Client, Handler>
|
||||
{
|
||||
private readonly IDictionary<int, Handler> _handlers;
|
||||
protected readonly ILogger _logger;
|
||||
|
||||
public IDictionary<int, Handler> Handlers { get => _handlers; }
|
||||
|
||||
|
||||
public HandlerManager(ILogger logger)
|
||||
{
|
||||
_handlers = new Dictionary<int, Handler>();
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
|
||||
protected void Add(int op, Handler handler)
|
||||
{
|
||||
_handlers.Add(op, handler);
|
||||
}
|
||||
|
||||
public async Task Execute<T>(Client sender, int opcode, T val)
|
||||
{
|
||||
if (opcode < 0 || !_handlers.TryGetValue(opcode, out Handler? handler) || handler == null)
|
||||
{
|
||||
_logger.Warning("Invalid opcode received: " + opcode);
|
||||
return;
|
||||
}
|
||||
|
||||
await Execute(sender, handler, val);
|
||||
}
|
||||
|
||||
protected abstract Task Execute<T>(Client sender, Handler handler, T value);
|
||||
}
|
||||
}
|
||||
45
Abstract/HandlerTypeManager.cs
Normal file
45
Abstract/HandlerTypeManager.cs
Normal file
@@ -0,0 +1,45 @@
|
||||
using Serilog;
|
||||
|
||||
namespace CommonSocketLibrary.Abstract
|
||||
{
|
||||
public abstract class HandlerTypeManager<Client, Handler>
|
||||
{
|
||||
private readonly IDictionary<int, Type> _types;
|
||||
public IDictionary<int, Type> HandlerTypes { get => _types; }
|
||||
protected readonly ILogger _logger;
|
||||
|
||||
|
||||
public HandlerTypeManager(ILogger logger, HandlerManager<Client, Handler> handlers)
|
||||
{
|
||||
_types = new Dictionary<int, Type>();
|
||||
_logger = logger;
|
||||
|
||||
GenerateHandlerTypes(handlers.Handlers);
|
||||
}
|
||||
|
||||
|
||||
private void GenerateHandlerTypes(IDictionary<int, Handler> handlers)
|
||||
{
|
||||
foreach (var entry in handlers)
|
||||
{
|
||||
if (entry.Value == null)
|
||||
{
|
||||
_logger.Error($"Failed to link websocket handler #{entry.Key} due to null value.");
|
||||
continue;
|
||||
}
|
||||
|
||||
var type = entry.Value.GetType();
|
||||
var target = FetchMessageType(type);
|
||||
if (target == null)
|
||||
{
|
||||
_logger.Error($"Failed to link websocket handler #{entry.Key} due to no match for {target}.");
|
||||
continue;
|
||||
}
|
||||
_types.Add(entry.Key, target);
|
||||
_logger.Debug($"Linked websocket handler #{entry.Key} to type {target.AssemblyQualifiedName}.");
|
||||
}
|
||||
}
|
||||
|
||||
protected abstract Type? FetchMessageType(Type handlerType);
|
||||
}
|
||||
}
|
||||
164
Abstract/SocketClient.cs
Normal file
164
Abstract/SocketClient.cs
Normal file
@@ -0,0 +1,164 @@
|
||||
using Serilog;
|
||||
using System.Net.WebSockets;
|
||||
using System.Text;
|
||||
using System.Text.Json;
|
||||
|
||||
namespace CommonSocketLibrary.Abstract
|
||||
{
|
||||
public abstract class SocketClient<Message> : IDisposable
|
||||
{
|
||||
private ClientWebSocket? _socket;
|
||||
private CancellationTokenSource? _cts;
|
||||
|
||||
protected readonly ILogger _logger;
|
||||
protected readonly JsonSerializerOptions _options;
|
||||
|
||||
public bool Connected { get; set; }
|
||||
public int ReceiveBufferSize { get; } = 8192;
|
||||
|
||||
|
||||
public SocketClient(ILogger logger, JsonSerializerOptions options)
|
||||
{
|
||||
_logger = logger;
|
||||
_options = options;
|
||||
Connected = false;
|
||||
}
|
||||
|
||||
public async Task ConnectAsync(string url)
|
||||
{
|
||||
if (_socket != null)
|
||||
{
|
||||
if (_socket.State == WebSocketState.Open) return;
|
||||
else _socket.Dispose();
|
||||
}
|
||||
|
||||
_socket = new ClientWebSocket();
|
||||
_socket.Options.RemoteCertificateValidationCallback = (o, c, ch, er) => true;
|
||||
_socket.Options.UseDefaultCredentials = false;
|
||||
if (_cts != null) _cts.Dispose();
|
||||
_cts = new CancellationTokenSource();
|
||||
await _socket.ConnectAsync(new Uri(url), _cts.Token);
|
||||
await Task.Factory.StartNew(ReceiveLoop, _cts.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
|
||||
await OnConnection();
|
||||
}
|
||||
|
||||
public async Task DisconnectAsync()
|
||||
{
|
||||
if (_socket == null || _cts == null) return;
|
||||
// TODO: requests cleanup code, sub-protocol dependent.
|
||||
if (_socket.State == WebSocketState.Open)
|
||||
{
|
||||
_cts.CancelAfter(TimeSpan.FromMilliseconds(500));
|
||||
await _socket.CloseOutputAsync(WebSocketCloseStatus.Empty, "", CancellationToken.None);
|
||||
await _socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
|
||||
}
|
||||
|
||||
Connected = false;
|
||||
_socket.Dispose();
|
||||
_socket = null;
|
||||
_cts.Dispose();
|
||||
_cts = null;
|
||||
}
|
||||
|
||||
public void Dispose() => DisconnectAsync().Wait();
|
||||
|
||||
private async Task ReceiveLoop()
|
||||
{
|
||||
if (_socket == null || _cts == null) return;
|
||||
|
||||
var loopToken = _cts.Token;
|
||||
MemoryStream? outputStream = null;
|
||||
WebSocketReceiveResult? receiveResult = null;
|
||||
var buffer = new byte[ReceiveBufferSize];
|
||||
try
|
||||
{
|
||||
while (!loopToken.IsCancellationRequested)
|
||||
{
|
||||
outputStream = new MemoryStream(ReceiveBufferSize);
|
||||
do
|
||||
{
|
||||
receiveResult = await _socket.ReceiveAsync(buffer, _cts.Token);
|
||||
if (receiveResult.MessageType != WebSocketMessageType.Close)
|
||||
outputStream.Write(buffer, 0, receiveResult.Count);
|
||||
}
|
||||
while (!receiveResult.EndOfMessage);
|
||||
if (receiveResult.MessageType == WebSocketMessageType.Close) break;
|
||||
outputStream.Position = 0;
|
||||
await ResponseReceived(outputStream);
|
||||
}
|
||||
}
|
||||
catch (TaskCanceledException) { }
|
||||
finally
|
||||
{
|
||||
outputStream?.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task SendRaw(string content)
|
||||
{
|
||||
if (!Connected) return;
|
||||
|
||||
var bytes = new byte[1024 * 4];
|
||||
var array = new ArraySegment<byte>(bytes);
|
||||
var total = Encoding.UTF8.GetBytes(content).Length;
|
||||
var current = 0;
|
||||
|
||||
while (current < total)
|
||||
{
|
||||
var size = Encoding.UTF8.GetBytes(content.Substring(current), array);
|
||||
await _socket.SendAsync(array, WebSocketMessageType.Text, true, _cts.Token);
|
||||
current += size;
|
||||
}
|
||||
await OnMessageSend(-1, content);
|
||||
}
|
||||
|
||||
public async Task Send<T>(int opcode, T data)
|
||||
{
|
||||
try
|
||||
{
|
||||
var message = GenerateMessage(opcode, data);
|
||||
var content = JsonSerializer.Serialize(message, _options);
|
||||
|
||||
var bytes = Encoding.UTF8.GetBytes(content);
|
||||
var array = new ArraySegment<byte>(bytes);
|
||||
var total = bytes.Length;
|
||||
var current = 0;
|
||||
|
||||
while (current < total)
|
||||
{
|
||||
var size = Encoding.UTF8.GetBytes(content.Substring(current), array);
|
||||
await _socket.SendAsync(array, WebSocketMessageType.Text, current + size >= total, _cts.Token);
|
||||
current += size;
|
||||
}
|
||||
await OnMessageSend(opcode, content);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
Connected = false;
|
||||
_logger.Error(e, "Failed to send a message: " + opcode);
|
||||
}
|
||||
}
|
||||
|
||||
private async Task ResponseReceived(Stream stream)
|
||||
{
|
||||
try
|
||||
{
|
||||
var data = await JsonSerializer.DeserializeAsync<Message>(stream);
|
||||
await OnResponseReceived(data);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.Error(ex, "Failed to read or execute a websocket message.");
|
||||
}
|
||||
finally
|
||||
{
|
||||
stream.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
protected abstract Message GenerateMessage<T>(int opcode, T data);
|
||||
protected abstract Task OnResponseReceived(Message? content);
|
||||
protected abstract Task OnMessageSend(int opcode, string? content);
|
||||
protected abstract Task OnConnection();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user