using EonaCat.Connections; using EonaCat.Connections.EventArguments; using EonaCat.Connections.Helpers; using EonaCat.Connections.Models; using EonaCat.Connections.gRPC.Proto; using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Server.Kestrel.Core; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; using System.Collections.Concurrent; using System.Net; using System.Security.Authentication; using System.Text; using ErrorEventArgs = EonaCat.Connections.EventArguments.ErrorEventArgs; namespace EonaCat.Connections.gRPC { public class GrpcNetworkServer : IDisposable, IAsyncDisposable { public static event EventHandler OnLog; private readonly Configuration _config; private readonly Stats _stats; private readonly ConcurrentDictionary _clients = new(); private readonly ConcurrentDictionary _lastPingTimes = new(); private WebApplication? _app; private CancellationTokenSource? _serverCts; private Task? _serverTask; private Task? _pingTask; private Task? _pongTask; private Task? _idleTask; private bool _disposed; public bool IsStarted => _serverCts != null && !_serverCts.IsCancellationRequested; public int ActiveConnections => GetActiveConnectionCount(); public int MaxConnections => _config.MaxConnections; public string IpAddress => _config.Host; public int Port => _config.Port; public long BytesSent => _stats.BytesSent; public long BytesReceived => _stats.BytesReceived; public long MessagesSent => _stats.MessagesSent; public long MessagesReceived => _stats.MessagesReceived; public double MessagesPerSecond => _stats.MessagesPerSecond; public long TotalConnections => _stats.TotalConnections; public long DroppedConnections => _stats.DroppedConnections; public TimeSpan Uptime => _stats.Uptime; public DateTime StartTime => _stats.StartTime; public HealthApiServer HealthApi { get; } public event EventHandler? OnConnected; public event EventHandler? OnDataReceived; public event EventHandler? OnDisconnected; public event EventHandler? OnGeneralError; public event EventHandler? OnClientPingResponse; public event EventHandler? OnPongMissed; public GrpcNetworkServer(Configuration config) { _config = config ?? throw new ArgumentNullException(nameof(config)); _stats = new Stats { StartTime = DateTime.UtcNow }; HealthApi = new HealthApiServer(BuildHealthJson, BuildStatusJson); } public Stats GetStats() { _stats.ActiveConnections = GetActiveConnectionCount(); return _stats; } private int GetActiveConnectionCount() { if (_clients.IsEmpty) { return 0; } int activeCount = 0; foreach (var client in _clients.Values) { if (client?.IsConnected == true) { activeCount++; } } return activeCount; } internal void TrackDisconnect(DisconnectReason reason) { if (reason == DisconnectReason.Error || reason == DisconnectReason.Timeout || reason == DisconnectReason.SSLError || reason == DisconnectReason.NoPongReceived || reason == DisconnectReason.ProtocolError) { _stats.IncrementDroppedConnections(); } } public async Task StartAsync() { _serverCts?.Dispose(); _serverCts = new CancellationTokenSource(); var builder = WebApplication.CreateBuilder(new WebApplicationOptions { Args = Array.Empty() }); builder.Services.AddSingleton(this); builder.Services.AddGrpc(options => { options.MaxReceiveMessageSize = _config.MAX_MESSAGE_SIZE; options.MaxSendMessageSize = _config.MAX_MESSAGE_SIZE; }); builder.WebHost.ConfigureKestrel(options => { options.Listen(IPAddress.Parse(_config.Host), _config.Port, listenOptions => { if (_config.Certificate != null && _config.UseSsl) { listenOptions.UseHttps(httpsOptions => { httpsOptions.ServerCertificate = _config.Certificate; httpsOptions.SslProtocols = SslProtocols.Tls12 | SslProtocols.Tls13; }); } listenOptions.Protocols = HttpProtocols.Http2; }); }); _app = builder.Build(); _app.MapGrpcService(); _serverTask = _app.RunAsync(_serverCts.Token); if (_config.EnableHeartbeat) { _pingTask = Task.Run(() => PingLoopAsync(_serverCts.Token), _serverCts.Token); _pongTask = Task.Run(() => PongMonitorLoopAsync(_serverCts.Token), _serverCts.Token); } if (_config.EnableHealthApi) { HealthApi.Start(_config.HealthApiPort, _config.HealthApiBindAddress); } OnLog?.Invoke(this, new LogMessage { Type = LogType.Trace, Message = $"EonaCat gRPC server started on {_config.Host}:{_config.Port}" }); } internal bool CanAcceptConnection() { return _config.MaxConnections <= 0 || GetActiveConnectionCount() < _config.MaxConnections; } internal void IncrementDroppedConnection() => _stats.IncrementDroppedConnections(); internal bool AddClient(string clientId, GrpcClientConnection connection) { if (_clients.TryAdd(clientId, connection)) { _stats.IncrementTotalConnections(); return true; } _stats.IncrementDroppedConnections(); return false; } internal bool RemoveClient(string clientId, out GrpcClientConnection? client) { var removed = _clients.TryRemove(clientId, out client); _lastPingTimes.TryRemove(clientId, out _); return removed; } internal void RaiseOnConnected(ConnectionEventArgs args) => HandlingHelpers.SafeInvokeEventHandler(OnConnected, this, args, nameof(OnConnected)); internal void RaiseOnDataReceived(DataReceivedEventArgs args) { _stats.IncrementMessagesReceived(); HandlingHelpers.SafeInvokeEventHandler(OnDataReceived, this, args, nameof(OnDataReceived)); } internal void RaiseOnDisconnected(ConnectionEventArgs args) => HandlingHelpers.SafeInvokeEventHandler(OnDisconnected, this, args, nameof(OnDisconnected)); internal void RaiseOnGeneralError(ErrorEventArgs args) => HandlingHelpers.SafeInvokeEventHandler(OnGeneralError, this, args, nameof(OnGeneralError)); internal void TrackBytesReceived(long bytes) => _stats.AddBytesReceived(bytes); internal void TrackBytesSent(long bytes) => _stats.AddBytesSent(bytes); public async Task SendToClientAsync(string clientId, byte[] data) { if (data == null || data.Length == 0) { return false; } if (!_clients.TryGetValue(clientId, out var client) || client.ResponseStream == null) { return false; } try { await client.WriteLock.WaitAsync().ConfigureAwait(false); try { var message = new ConnectorMessage { Type = MessageType.Data, Data = Google.Protobuf.ByteString.CopyFrom(data) }; await client.ResponseStream.WriteAsync(message).ConfigureAwait(false); } finally { client.WriteLock.Release(); } var sentAt = DateTime.UtcNow; client.LastDataSent = sentAt; client.LastActive = sentAt; client.BytesSent += data.Length; client.MessagesSent++; _stats.IncrementMessagesSent(); _stats.AddBytesSent(data.Length); return true; } catch (Exception exception) { HandlingHelpers.SafeInvokeEventHandler( OnGeneralError, this, new ErrorEventArgs { ClientId = clientId, Nickname = client.Nickname, Exception = exception, Message = "Error sending data to gRPC client" }, nameof(OnGeneralError)); return false; } } public async Task SendToClientAsync(string clientId, string message) => await SendToClientAsync(clientId, Encoding.UTF8.GetBytes(message)).ConfigureAwait(false); public async Task BroadcastAsync(byte[] data) { if (data == null || data.Length == 0) { return false; } bool any = false; foreach (var client in _clients) { if (await SendToClientAsync(client.Key, data).ConfigureAwait(false)) { any = true; } } return any; } public async Task BroadcastAsync(string message) => await BroadcastAsync(Encoding.UTF8.GetBytes(message)).ConfigureAwait(false); public async Task BroadcastExceptAsync(byte[] data, string excludeClientId) { if (data == null || data.Length == 0) { return false; } bool any = false; foreach (var client in _clients) { if (client.Key == excludeClientId) { continue; } if (await SendToClientAsync(client.Key, data).ConfigureAwait(false)) { any = true; } } return any; } public async Task BroadcastExceptAsync(string message, string excludeClientId) => await BroadcastExceptAsync(Encoding.UTF8.GetBytes(message), excludeClientId).ConfigureAwait(false); public ConcurrentDictionary GetClients() => _clients; public GrpcClientConnection? GetClient(string clientId) { _clients.TryGetValue(clientId, out var client); return client; } public async Task DisconnectClientAsync(string clientId, DisconnectReason reason = DisconnectReason.ServerShutdown) { if (!RemoveClient(clientId, out var client)) { return; } try { if (client?.ResponseStream != null) { await client.WriteLock.WaitAsync().ConfigureAwait(false); try { var msg = new ConnectorMessage { Type = MessageType.Disconnect }; await client.ResponseStream.WriteAsync(msg).ConfigureAwait(false); } catch { } finally { client.WriteLock.Release(); } } client?.CancellationSource?.Cancel(); } catch { } TrackDisconnect(reason); HandlingHelpers.SafeInvokeEventHandler( OnDisconnected, this, new ConnectionEventArgs { ClientId = clientId, Nickname = client?.Nickname, RemoteEndPoint = client?.RemoteEndPoint, Reason = reason }, nameof(OnDisconnected)); } private async Task PingLoopAsync(CancellationToken token) { while (!token.IsCancellationRequested) { try { await Task.Delay(TimeSpan.FromSeconds(_config.HeartbeatIntervalSeconds), token).ConfigureAwait(false); foreach (var kvp in _clients) { var clientId = kvp.Key; var client = kvp.Value; if (client.ResponseStream == null || !client.IsConnected) { continue; } try { await client.WriteLock.WaitAsync(token).ConfigureAwait(false); try { var pingMsg = new ConnectorMessage { Type = MessageType.Ping }; await client.ResponseStream.WriteAsync(pingMsg).ConfigureAwait(false); } finally { client.WriteLock.Release(); } client.LastPingSent = DateTime.UtcNow; _lastPingTimes[clientId] = DateTime.UtcNow; } catch (Exception ex) { OnLog?.Invoke(this, new LogMessage { Type = LogType.Error, Message = $"Error sending ping to {client.Nickname}: {ex.Message}" }); } } } catch (OperationCanceledException) { break; } catch (Exception ex) { HandlingHelpers.SafeInvokeEventHandler( OnGeneralError, this, new ErrorEventArgs { Exception = ex, Message = "Ping loop error" }, nameof(OnGeneralError)); } } } private async Task PongMonitorLoopAsync(CancellationToken token) { while (!token.IsCancellationRequested) { try { await Task.Delay(TimeSpan.FromSeconds(1), token).ConfigureAwait(false); var now = DateTime.UtcNow; var timeout = _config.HeartbeatIntervalSeconds * 2; foreach (var kvp in _lastPingTimes) { var clientId = kvp.Key; var lastPing = kvp.Value; if (!_clients.TryGetValue(clientId, out var client)) { _lastPingTimes.TryRemove(clientId, out _); continue; } var elapsed = (now - client.LastPongReceived).TotalSeconds; if (client.LastPongReceived == default) { elapsed = (now - lastPing).TotalSeconds; } if (elapsed > timeout) { OnPongMissed?.Invoke(this, new PingEventArgs { Id = client.Id, Nickname = client.Nickname, ReceivedTime = now, RemoteEndPoint = client.RemoteEndPoint }); if (_config.DisconectOnMissedPong) { OnLog?.Invoke(this, new LogMessage { Type = LogType.Trace, Message = $"gRPC client '{client.Nickname}' no PONG for {elapsed:F1}s, disconnecting." }); _ = DisconnectClientAsync(clientId, DisconnectReason.NoPongReceived); } } } } catch (OperationCanceledException) { break; } catch (Exception ex) { HandlingHelpers.SafeInvokeEventHandler( OnGeneralError, this, new ErrorEventArgs { Exception = ex, Message = "Pong monitor loop error" }, nameof(OnGeneralError)); } } } internal void HandlePongReceived(string clientId) { if (_clients.TryGetValue(clientId, out var client)) { client.LastPongReceived = DateTime.UtcNow; client.LastActive = DateTime.UtcNow; OnClientPingResponse?.Invoke(this, new PingEventArgs { Id = clientId, Nickname = client.Nickname, ReceivedTime = DateTime.UtcNow, RemoteEndPoint = client.RemoteEndPoint }); } } private string BuildHealthJson() { var E = HealthApiServer.JsonEscape; var stats = GetStats(); return "{" + "\"status\":\"ok\"," + "\"type\":\"grpc-server\"," + $"\"listenAddress\":{E(_config.Host + ":" + _config.Port)}," + $"\"isStarted\":{(IsStarted ? "true" : "false")}," + $"\"activeConnections\":{stats.ActiveConnections}," + $"\"maxConnections\":{_config.MaxConnections}," + $"\"uptimeSeconds\":{stats.Uptime.TotalSeconds:F1}," + $"\"startTimeUtc\":{E(stats.StartTime.ToString("O"))}" + "}"; } private string BuildStatusJson() { var E = HealthApiServer.JsonEscape; var stats = GetStats(); var sb = new StringBuilder(); sb.Append("{"); sb.Append("\"status\":\"ok\","); sb.Append("\"type\":\"grpc-server\","); sb.Append($"\"listenAddress\":{E(_config.Host + ":" + _config.Port)},"); sb.Append($"\"isStarted\":{(IsStarted ? "true" : "false")},"); sb.Append($"\"activeConnections\":{stats.ActiveConnections},"); sb.Append($"\"maxConnections\":{_config.MaxConnections},"); sb.Append($"\"totalConnections\":{stats.TotalConnections},"); sb.Append($"\"droppedConnections\":{stats.DroppedConnections},"); sb.Append($"\"bytesSent\":{stats.BytesSent},"); sb.Append($"\"bytesReceived\":{stats.BytesReceived},"); sb.Append($"\"messagesSent\":{stats.MessagesSent},"); sb.Append($"\"messagesReceived\":{stats.MessagesReceived},"); sb.Append($"\"messagesPerSecond\":{stats.MessagesPerSecond:F2},"); sb.Append($"\"uptimeSeconds\":{stats.Uptime.TotalSeconds:F1},"); sb.Append($"\"startTimeUtc\":{E(stats.StartTime.ToString("O"))},"); sb.Append("\"clients\":["); var clientList = _clients.Values.ToArray(); for (int i = 0; i < clientList.Length; i++) { var c = clientList[i]; if (i > 0) { sb.Append(","); } sb.Append("{"); sb.Append($"\"id\":{E(c.Id)},"); sb.Append($"\"nickname\":{E(c.Nickname)},"); sb.Append($"\"remoteEndPoint\":{E(c.RemoteEndPoint?.ToString())},"); sb.Append($"\"connectedAtUtc\":{E(c.ConnectedAt.ToString("O"))},"); sb.Append($"\"connectedTimeSeconds\":{c.ConnectedTime().TotalSeconds:F1},"); sb.Append($"\"idleTimeSeconds\":{c.IdleTime().TotalSeconds:F1},"); sb.Append($"\"bytesSent\":{c.BytesSent},"); sb.Append($"\"bytesReceived\":{c.BytesReceived},"); sb.Append($"\"messagesSent\":{c.MessagesSent},"); sb.Append($"\"messagesReceived\":{c.MessagesReceived}"); sb.Append("}"); } sb.Append("]"); sb.Append("}"); return sb.ToString(); } public void Stop() { _serverCts?.Cancel(); foreach (var client in _clients.Keys.ToList()) { DisconnectClientAsync(client, DisconnectReason.ServerShutdown).GetAwaiter().GetResult(); } _clients.Clear(); HealthApi.Stop(); try { _app?.StopAsync().GetAwaiter().GetResult(); } catch { } try { _app?.DisposeAsync().AsTask().GetAwaiter().GetResult(); } catch { } _app = null; } public async Task StopAsync() { _serverCts?.Cancel(); foreach (var client in _clients.Keys.ToList()) { await DisconnectClientAsync(client, DisconnectReason.ServerShutdown).ConfigureAwait(false); } _clients.Clear(); HealthApi.Stop(); try { if (_app != null) { await _app.StopAsync().ConfigureAwait(false); } } catch { } try { if (_app != null) { await _app.DisposeAsync().ConfigureAwait(false); } } catch { } _app = null; if (_serverTask != null) { try { await _serverTask.ConfigureAwait(false); } catch { } } } public void Dispose() { if (_disposed) { return; } _disposed = true; Stop(); _serverCts?.Dispose(); _stats.Dispose(); OnConnected = null; OnDisconnected = null; OnDataReceived = null; OnGeneralError = null; OnClientPingResponse = null; OnPongMissed = null; } public async ValueTask DisposeAsync() { if (_disposed) { return; } _disposed = true; await StopAsync().ConfigureAwait(false); _serverCts?.Dispose(); _stats.Dispose(); OnConnected = null; OnDisconnected = null; OnDataReceived = null; OnGeneralError = null; OnClientPingResponse = null; OnPongMissed = null; } } }