379 lines
14 KiB
C#
379 lines
14 KiB
C#
using System.Collections.Concurrent;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
using System.Net.WebSockets;
|
|
using System.Reflection.Emit;
|
|
using GameServices.Auth;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.Extensions.Logging;
|
|
using Server.Networking.Messages;
|
|
using Server.Redis;
|
|
using StackExchange.Redis;
|
|
|
|
namespace Server.Networking;
|
|
|
|
/// <summary>
|
|
/// Manages all network connections (WebSocket and TCP), tick loop, and keepalive/ping system.
|
|
/// Now includes automatic ping mechanism to prevent idle timeout disconnections.
|
|
/// </summary>
|
|
public sealed class NetworkManager
|
|
{
|
|
private readonly ILogger<NetworkManager> _log;
|
|
private readonly MessageRouter _router;
|
|
private readonly ConcurrentDictionary<Guid, IConnection> _connections = new();
|
|
private readonly ISessionRegistry _sessions;
|
|
private readonly IRedisManager _redis;
|
|
private readonly ISessionAudit _sessionAudit;
|
|
private readonly IMessageSerializer _serializer;
|
|
|
|
private readonly TimeSpan _tickInterval;
|
|
private readonly TimeSpan _idleTimeout;
|
|
private readonly TimeSpan _pingInterval;
|
|
private readonly int _maxConnections;
|
|
|
|
public NetworkManager(
|
|
ILogger<NetworkManager> log,
|
|
MessageRouter router,
|
|
IMessageSerializer serializer,
|
|
ISessionRegistry sessions,
|
|
IRedisManager redis,
|
|
ISessionAudit sessionAudit)
|
|
{
|
|
_log = log;
|
|
_router = router;
|
|
_serializer = serializer;
|
|
_sessions = sessions;
|
|
_redis = redis;
|
|
_sessionAudit = sessionAudit;
|
|
|
|
// Parse tick rate from environment variable (default: 20 Hz)
|
|
var tickHz = int.TryParse(Environment.GetEnvironmentVariable("TICK_RATE_HZ"), out var hz)
|
|
? Math.Clamp(hz, 1, 120)
|
|
: 20;
|
|
_tickInterval = TimeSpan.FromMilliseconds(1000.0 / tickHz);
|
|
|
|
// Parse idle timeout from environment variable (default: 90 seconds to allow for ping delays)
|
|
_idleTimeout = TimeSpan.FromSeconds(
|
|
int.TryParse(Environment.GetEnvironmentVariable("IDLE_TIMEOUT_S"), out var idle)
|
|
? Math.Clamp(idle, 10, 300)
|
|
: 90
|
|
);
|
|
|
|
// Ping interval should be less than half of idle timeout to ensure keepalive
|
|
// Default: 30 seconds (gives 3 attempts before 90 second timeout)
|
|
_pingInterval = TimeSpan.FromSeconds(
|
|
int.TryParse(Environment.GetEnvironmentVariable("PING_INTERVAL_S"), out var ping)
|
|
? Math.Clamp(ping, 5, 60)
|
|
: 30
|
|
);
|
|
|
|
// Parse max connections from environment variable (default: 10,000)
|
|
_maxConnections = int.TryParse(Environment.GetEnvironmentVariable("MAX_CONN"), out var mc)
|
|
? Math.Max(mc, 100)
|
|
: 10_000;
|
|
|
|
_log.LogInformation(
|
|
"NetworkManager initialized: Tick={Hz}Hz, IdleTimeout={Idle}s, PingInterval={Ping}s, MaxConn={Max}",
|
|
tickHz,
|
|
_idleTimeout.TotalSeconds,
|
|
_pingInterval.TotalSeconds,
|
|
_maxConnections
|
|
);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Accept and handle a WebSocket connection from a client.
|
|
/// Implements ping/pong keepalive mechanism to prevent idle timeouts.
|
|
/// </summary>
|
|
public async Task AcceptWebSocketAsync(HttpContext ctx, WebSocket ws)
|
|
{
|
|
// Check if server is at capacity
|
|
if (_connections.Count >= _maxConnections)
|
|
{
|
|
await ws.CloseAsync(WebSocketCloseStatus.PolicyViolation, "server full", CancellationToken.None);
|
|
return;
|
|
}
|
|
|
|
// Create connection wrapper
|
|
var conn = new WebSocketConnection(
|
|
ws,
|
|
ctx.Connection.RemoteIpAddress == null
|
|
? null
|
|
: new IPEndPoint(ctx.Connection.RemoteIpAddress, ctx.Connection.RemotePort)
|
|
);
|
|
|
|
_connections[conn.Id] = conn;
|
|
_log.LogInformation("WebSocket connected: ConnectionId={Id}, RemoteEndPoint={Remote}", conn.Id, conn.RemoteEndPoint);
|
|
|
|
// Start ping sender task
|
|
using var pingCancellationTokenSource = new CancellationTokenSource();
|
|
var pingTask = SendPeriodicPingsAsync(conn, pingCancellationTokenSource.Token);
|
|
|
|
try
|
|
{
|
|
// Main message receive loop
|
|
while (conn.IsAlive)
|
|
{
|
|
using var idleTimeoutCancellationTokenSource = new CancellationTokenSource(_idleTimeout);
|
|
var data = await conn.ReceiveAsync(idleTimeoutCancellationTokenSource.Token);
|
|
|
|
if (data is null)
|
|
{
|
|
_log.LogDebug("Connection closed by client: ConnectionId={Id}", conn.Id);
|
|
break;
|
|
}
|
|
|
|
// Route message to appropriate handler
|
|
await _router.OnMessageAsync(conn, data.Value, CancellationToken.None);
|
|
}
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
_log.LogWarning("Connection idle timeout: ConnectionId={Id}", conn.Id);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.LogWarning(ex, "WebSocket loop error: ConnectionId={Id}", conn.Id);
|
|
}
|
|
finally
|
|
{
|
|
// Stop ping task
|
|
pingCancellationTokenSource.Cancel();
|
|
try { await pingTask; } catch { /* ignore cancellation */ }
|
|
|
|
// Clean up connection
|
|
await CleanupAsync(conn, "websocket closed");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sends periodic PING messages to keep connection alive and detect disconnections.
|
|
/// Client should respond with PONG to reset idle timeout.
|
|
/// </summary>
|
|
private async Task SendPeriodicPingsAsync(IConnection connection, CancellationToken cancellationToken)
|
|
{
|
|
try
|
|
{
|
|
// Wait before sending first ping to avoid immediate ping on connection
|
|
await Task.Delay(_pingInterval, cancellationToken);
|
|
|
|
while (!cancellationToken.IsCancellationRequested && connection.IsAlive)
|
|
{
|
|
try
|
|
{
|
|
// Send PING message (OpCode 2)
|
|
// WebSocketConnection.SendAsync will add the 4-byte length prefix automatically
|
|
// So we just send the 1-byte opcode
|
|
var emptyPayload = _serializer.Serialize(new { });
|
|
var pingMessage = new ServerMessage(2, emptyPayload);
|
|
var wireBytes = _serializer.Serialize(pingMessage);
|
|
await connection.SendAsync(wireBytes, cancellationToken);
|
|
|
|
_log.LogTrace("Sent PING to ConnectionId={Id}", connection.Id);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.LogDebug(ex, "Failed to send PING to ConnectionId={Id}", connection.Id);
|
|
break;
|
|
}
|
|
|
|
// Wait for next ping interval
|
|
await Task.Delay(_pingInterval, cancellationToken);
|
|
}
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
// Normal cancellation, connection is closing
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.LogError(ex, "Unexpected error in ping sender for ConnectionId={Id}", connection.Id);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Accept TCP connections in a loop (for legacy TCP client support if needed)
|
|
/// </summary>
|
|
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();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle an individual TCP client connection with ping/pong support
|
|
/// </summary>
|
|
private async Task HandleTcpClientAsync(TcpClient client, CancellationToken ct)
|
|
{
|
|
var conn = new TcpConnection(client);
|
|
_connections[conn.Id] = conn;
|
|
_log.LogInformation("TCP connected: ConnectionId={Id}, RemoteEndPoint={Remote}", conn.Id, conn.RemoteEndPoint);
|
|
|
|
// Start ping sender task
|
|
using var pingCancellationTokenSource = new CancellationTokenSource();
|
|
var pingTask = SendPeriodicPingsAsync(conn, pingCancellationTokenSource.Token);
|
|
|
|
try
|
|
{
|
|
while (conn.IsAlive && !ct.IsCancellationRequested)
|
|
{
|
|
using var idleTimeoutCancellationTokenSource = new CancellationTokenSource(_idleTimeout);
|
|
using var linkedCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(
|
|
idleTimeoutCancellationTokenSource.Token,
|
|
ct
|
|
);
|
|
|
|
var data = await conn.ReceiveAsync(linkedCancellationTokenSource.Token);
|
|
|
|
if (data is null)
|
|
break;
|
|
|
|
await _router.OnMessageAsync(conn, data.Value, ct);
|
|
}
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
_log.LogWarning("TCP connection idle timeout or shutdown: ConnectionId={Id}", conn.Id);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.LogWarning(ex, "TCP loop error: ConnectionId={Id}", conn.Id);
|
|
}
|
|
finally
|
|
{
|
|
// Stop ping task
|
|
pingCancellationTokenSource.Cancel();
|
|
try { await pingTask; } catch { /* ignore cancellation */ }
|
|
|
|
await CleanupAsync(conn, "tcp closed");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Main server tick loop - runs game simulation, broadcasts state, etc.
|
|
/// </summary>
|
|
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();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called every tick interval to update game state, prune idle connections, etc.
|
|
/// </summary>
|
|
private Task TickAsync(CancellationToken ct)
|
|
{
|
|
// Example tick operations:
|
|
// - Prune connections that haven't responded to pings
|
|
// - Broadcast heartbeat messages
|
|
// - Step game simulation
|
|
// - Clean up expired sessions
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clean up a connection and remove it from tracking
|
|
/// </summary>
|
|
private async Task CleanupAsync(IConnection conn, string reason)
|
|
{
|
|
if (_connections.TryRemove(conn.Id, out _))
|
|
{
|
|
// Notify router about disconnection for handler cleanup (e.g., DungeonHandler)
|
|
_router.OnDisconnect(conn.Id);
|
|
|
|
if (_sessions.TryGet(conn.Id, out var accountId, out var token)
|
|
&& accountId != 0 && !string.IsNullOrEmpty(token))
|
|
{
|
|
try
|
|
{
|
|
var onlineKey = $"online:acct:{accountId}";
|
|
var sessKey = $"sess:{token}";
|
|
|
|
const string lua = @"
|
|
if redis.call('GET', KEYS[1]) == ARGV[1] then
|
|
redis.call('DEL', KEYS[1])
|
|
end
|
|
redis.call('DEL', KEYS[2])
|
|
return 1";
|
|
|
|
await _redis.Db.ScriptEvaluateAsync(lua,
|
|
new StackExchange.Redis.RedisKey[] { onlineKey, sessKey },
|
|
new StackExchange.Redis.RedisValue[] { token });
|
|
|
|
// NEW: close the SQL session audit row
|
|
await _sessionAudit.EndAsync(accountId, token, reason);
|
|
|
|
_sessions.Unbind(conn.Id);
|
|
_log.LogInformation("Logged out account {AccountId} on disconnect", accountId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.LogWarning(ex, "Failed logout cleanup for account {AccountId}", accountId);
|
|
try { await _sessionAudit.EndAsync(accountId, token, reason); } catch { }
|
|
_sessions.Unbind(conn.Id);
|
|
}
|
|
}
|
|
|
|
_log.LogInformation("Disconnected {Id} ({Reason})", conn.Id, reason);
|
|
try { await conn.CloseAsync(reason); } catch { }
|
|
try { await conn.DisposeAsync(); } catch { }
|
|
}
|
|
}
|
|
//private async Task CleanupAsync(IConnection conn, string reason)
|
|
//{
|
|
// if (_connections.TryRemove(conn.Id, out _))
|
|
// {
|
|
// _log.LogInformation("Connection cleaned up: ConnectionId={Id}, Reason={Reason}", conn.Id, reason);
|
|
|
|
// // Notify router about disconnection for session cleanup
|
|
// _router.OnDisconnect(conn.Id);
|
|
|
|
// // Close the connection gracefully
|
|
// await conn.CloseAsync(reason, CancellationToken.None);
|
|
// }
|
|
//}
|
|
}
|
|
|
|
public class PingRequest
|
|
{
|
|
public int ping { get; set; } = 1;
|
|
}
|