using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Net;
|
using System.Net.Sockets;
|
using System.Threading;
|
using System.Threading.Tasks;
|
|
namespace WIDESEAWCS_Tasks.SocketServer
|
{
|
public partial class TcpSocketServer
|
{
|
public Task StartAsync(CancellationToken cancellationToken)
|
{
|
if (IsRunning || !_options.Enabled)
|
{
|
return Task.CompletedTask;
|
}
|
|
IPAddress ipAddress = IPAddress.Any;
|
if (IPAddress.TryParse(_options.IpAddress, out IPAddress? parsedAddress))
|
{
|
ipAddress = parsedAddress;
|
}
|
|
_listener = new TcpListener(ipAddress, _options.Port);
|
_listener.Start(_options.Backlog);
|
_cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
|
IsRunning = true;
|
|
_ = AcceptLoopAsync(_cts.Token);
|
_monitorTask = Task.Run(() => MonitorClientsAsync(_cts.Token));
|
|
return Task.CompletedTask;
|
}
|
|
public async Task StopAsync(CancellationToken cancellationToken)
|
{
|
if (!IsRunning)
|
{
|
return;
|
}
|
|
_cts?.Cancel();
|
_listener?.Stop();
|
|
Task[] tasks;
|
lock (_syncRoot)
|
{
|
tasks = _clientTasks.ToArray();
|
}
|
|
if (tasks.Length > 0)
|
{
|
await Task.WhenAll(tasks);
|
}
|
|
IsRunning = false;
|
}
|
|
private async Task AcceptLoopAsync(CancellationToken cancellationToken)
|
{
|
while (!cancellationToken.IsCancellationRequested)
|
{
|
TcpClient? client = null;
|
try
|
{
|
client = await _listener!.AcceptTcpClientAsync().WaitAsync(cancellationToken);
|
}
|
catch (OperationCanceledException)
|
{
|
break;
|
}
|
catch (ObjectDisposedException)
|
{
|
break;
|
}
|
catch
|
{
|
if (cancellationToken.IsCancellationRequested)
|
{
|
break;
|
}
|
}
|
|
if (client == null)
|
{
|
continue;
|
}
|
|
string clientId = GetClientId(client);
|
lock (_syncRoot)
|
{
|
_clients[clientId] = client;
|
_clientLocks[clientId] = new SemaphoreSlim(1, 1);
|
}
|
}
|
}
|
|
private void RemoveClient(string clientId)
|
{
|
lock (_syncRoot)
|
{
|
if (_clients.TryGetValue(clientId, out var client))
|
{
|
try { client.Close(); } catch { }
|
_clients.Remove(clientId);
|
}
|
|
if (_clientLocks.TryGetValue(clientId, out var sem))
|
{
|
_clientLocks.Remove(clientId);
|
sem.Dispose();
|
}
|
|
_clientLastActive.Remove(clientId);
|
_clientEncodings.Remove(clientId);
|
|
var deviceIds = _deviceBindings.Where(kv => kv.Value == clientId).Select(kv => kv.Key).ToList();
|
foreach (var deviceId in deviceIds)
|
{
|
_deviceBindings.Remove(deviceId);
|
}
|
}
|
}
|
|
private async Task MonitorClientsAsync(CancellationToken cancellationToken)
|
{
|
while (!cancellationToken.IsCancellationRequested)
|
{
|
try
|
{
|
List<string> toRemove = new();
|
lock (_syncRoot)
|
{
|
foreach (var kv in _clientLastActive)
|
{
|
if (_options.IdleTimeoutSeconds > 0 && DateTime.Now - kv.Value > TimeSpan.FromSeconds(_options.IdleTimeoutSeconds))
|
{
|
toRemove.Add(kv.Key);
|
}
|
}
|
}
|
|
foreach (var cid in toRemove)
|
{
|
RemoveClient(cid);
|
Log($"[{DateTime.Now}] TcpSocketServer disconnect idle client {cid}");
|
}
|
}
|
catch
|
{
|
}
|
|
try { await Task.Delay(1000, cancellationToken); } catch { }
|
}
|
}
|
|
public static string GetClientId(TcpClient client)
|
{
|
return client.Client.RemoteEndPoint?.ToString() ?? Guid.NewGuid().ToString();
|
}
|
}
|
}
|
