using System.Collections.Concurrent;
|
using System.Net;
|
using System.Net.Sockets;
|
using System.Text;
|
|
namespace WIDESEAWCS_S7Simulator.Server.Services;
|
|
public interface IRobotClientManager
|
{
|
Task<RobotServerCollectionStatusResponse> StartAsync(RobotServerStartRequest request, CancellationToken cancellationToken = default);
|
Task StopAsync(string? serverId = null);
|
Task<RobotServerCollectionStatusResponse> GetStatusAsync();
|
Task SendToClientAsync(string serverId, int clientId, string message);
|
Task SendToAllAsync(string serverId, string message);
|
Task ClearReceivedMessagesAsync(string serverId);
|
}
|
|
/// <summary>
|
/// 机械手 TCP 客户端多实例管理器。
|
/// 一个 ServerId 对应一个 TcpClient，主动连接目标服务端。
|
/// </summary>
|
public sealed class RobotClientManager : IRobotClientManager, IDisposable
|
{
|
private readonly ILogger<RobotClientManager> _logger;
|
private readonly ConcurrentDictionary<string, RobotClientRuntime> _clients = new(StringComparer.OrdinalIgnoreCase);
|
private bool _disposed;
|
|
public RobotClientManager(ILogger<RobotClientManager> logger)
|
{
|
_logger = logger;
|
}
|
|
public async Task<RobotServerCollectionStatusResponse> StartAsync(RobotServerStartRequest request, CancellationToken cancellationToken = default)
|
{
|
ValidateStartRequest(request);
|
EnsureLocalPortAvailable(request.LocalPort);
|
|
var key = request.ServerId.Trim();
|
if (_clients.ContainsKey(key))
|
{
|
throw new InvalidOperationException($"客户端实例 '{key}' 已存在");
|
}
|
|
var runtime = new RobotClientRuntime
|
{
|
ServerId = key,
|
RemoteIp = request.ListenIp,
|
RemotePort = request.ListenPort,
|
LocalPort = request.LocalPort,
|
Cancellation = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken),
|
Connected = false
|
};
|
|
runtime.ConnectionLoopTask = Task.Run(() => ConnectionLoopAsync(runtime), runtime.Cancellation.Token);
|
|
if (!_clients.TryAdd(key, runtime))
|
{
|
await StopRuntimeAsync(runtime);
|
throw new InvalidOperationException($"客户端实例 '{key}' 创建失败");
|
}
|
|
_logger.LogInformation("机械手客户端已启动: {ServerId} 本地:{LocalPort} -> 远端:{Ip}:{Port}",
|
key,
|
request.LocalPort,
|
request.ListenIp,
|
request.ListenPort);
|
|
return await GetStatusAsync();
|
}
|
|
public async Task StopAsync(string? serverId = null)
|
{
|
if (string.IsNullOrWhiteSpace(serverId))
|
{
|
var all = _clients.Values.ToArray();
|
_clients.Clear();
|
await Task.WhenAll(all.Select(StopRuntimeAsync));
|
return;
|
}
|
|
if (_clients.TryRemove(serverId.Trim(), out var runtime))
|
{
|
await StopRuntimeAsync(runtime);
|
}
|
}
|
|
public Task<RobotServerCollectionStatusResponse> GetStatusAsync()
|
{
|
var servers = _clients.Values
|
.OrderBy(x => x.ServerId, StringComparer.OrdinalIgnoreCase)
|
.Select(ToStatusItem)
|
.ToArray();
|
|
return Task.FromResult(new RobotServerCollectionStatusResponse
|
{
|
RunningServerCount = servers.Count(x => x.Running),
|
Servers = servers
|
});
|
}
|
|
public async Task SendToClientAsync(string serverId, int clientId, string message)
|
{
|
var runtime = GetClientOrThrow(serverId);
|
if (clientId != 1)
|
{
|
throw new InvalidOperationException($"客户端实例 '{runtime.ServerId}' 仅支持 ClientId=1");
|
}
|
|
await SendFrameAsync(runtime, message, CancellationToken.None);
|
}
|
|
public async Task SendToAllAsync(string serverId, string message)
|
{
|
var runtime = GetClientOrThrow(serverId);
|
await SendFrameAsync(runtime, message, CancellationToken.None);
|
}
|
|
/// <summary>
|
/// 清空指定客户端实例的收发消息日志。
|
/// </summary>
|
public Task ClearReceivedMessagesAsync(string serverId)
|
{
|
var runtime = GetClientOrThrow(serverId);
|
|
while (runtime.ReceivedMessages.TryDequeue(out _))
|
{
|
}
|
|
while (runtime.SentMessages.TryDequeue(out _))
|
{
|
}
|
|
return Task.CompletedTask;
|
}
|
|
private RobotClientRuntime GetClientOrThrow(string serverId)
|
{
|
if (string.IsNullOrWhiteSpace(serverId))
|
{
|
throw new ArgumentException("ServerId 不能为空");
|
}
|
|
if (!_clients.TryGetValue(serverId.Trim(), out var runtime))
|
{
|
throw new InvalidOperationException($"客户端实例 '{serverId}' 不存在");
|
}
|
|
return runtime;
|
}
|
|
/// <summary>
|
/// 客户端连接守护循环：断开后自动重连。
|
/// </summary>
|
private async Task ConnectionLoopAsync(RobotClientRuntime runtime)
|
{
|
var token = runtime.Cancellation.Token;
|
|
while (!token.IsCancellationRequested)
|
{
|
if (!runtime.Connected)
|
{
|
try
|
{
|
await ConnectOnceAsync(runtime, token);
|
}
|
catch (OperationCanceledException)
|
{
|
break;
|
}
|
catch (Exception ex)
|
{
|
runtime.LastError = ex.Message;
|
_logger.LogWarning(ex, "[{ServerId}] 连接失败，将在 2 秒后重试", runtime.ServerId);
|
await DelayForReconnect(token);
|
continue;
|
}
|
}
|
|
var tcpClient = runtime.TcpClient;
|
if (tcpClient == null)
|
{
|
await DelayForReconnect(token);
|
continue;
|
}
|
|
await ReceiveLoopAsync(runtime, tcpClient);
|
await DelayForReconnect(token);
|
}
|
}
|
|
/// <summary>
|
/// 单次连接动作。成功后更新运行时连接状态。
|
/// </summary>
|
private async Task ConnectOnceAsync(RobotClientRuntime runtime, CancellationToken token)
|
{
|
var tcpClient = new TcpClient(AddressFamily.InterNetwork);
|
try
|
{
|
// 每次重连都固定绑定同一本地端口。
|
tcpClient.Client.Bind(new IPEndPoint(IPAddress.Any, runtime.LocalPort));
|
await tcpClient.ConnectAsync(runtime.RemoteIp, runtime.RemotePort, token);
|
}
|
catch
|
{
|
tcpClient.Dispose();
|
throw;
|
}
|
|
runtime.TcpClient = tcpClient;
|
runtime.Connected = true;
|
runtime.ConnectedAt = DateTimeOffset.Now;
|
runtime.LastError = null;
|
|
_logger.LogInformation("[{ServerId}] 已连接 本地:{LocalPort} -> 远端:{Ip}:{Port}",
|
runtime.ServerId,
|
runtime.LocalPort,
|
runtime.RemoteIp,
|
runtime.RemotePort);
|
}
|
|
/// <summary>
|
/// 单个客户端收包循环，支持帧协议和普通文本两种输入。
|
/// </summary>
|
private async Task ReceiveLoopAsync(RobotClientRuntime runtime, TcpClient tcpClient)
|
{
|
var token = runtime.Cancellation.Token;
|
var buffer = new byte[2048];
|
var cache = new StringBuilder();
|
|
try
|
{
|
var stream = tcpClient.GetStream();
|
while (!token.IsCancellationRequested)
|
{
|
var length = await stream.ReadAsync(buffer, 0, buffer.Length, token);
|
if (length <= 0)
|
{
|
break;
|
}
|
|
runtime.LastReceivedAt = DateTimeOffset.Now;
|
cache.Append(Encoding.UTF8.GetString(buffer, 0, length));
|
TryReadMessages(runtime, cache);
|
}
|
}
|
catch (OperationCanceledException)
|
{
|
// 正常停止。
|
}
|
catch (Exception ex)
|
{
|
runtime.LastError = ex.Message;
|
_logger.LogWarning(ex, "[{ServerId}] 客户端收包异常", runtime.ServerId);
|
}
|
finally
|
{
|
runtime.Connected = false;
|
await CloseRuntimeSocketAsync(runtime);
|
_logger.LogWarning("[{ServerId}] 客户端连接已断开，准备自动重连", runtime.ServerId);
|
}
|
}
|
|
private void TryReadMessages(RobotClientRuntime runtime, StringBuilder cache)
|
{
|
const string start = "<START>";
|
const string end = "<END>";
|
|
while (true)
|
{
|
var text = cache.ToString();
|
var startIndex = text.IndexOf(start, StringComparison.Ordinal);
|
var endIndex = text.IndexOf(end, StringComparison.Ordinal);
|
|
// 未命中帧协议时，按整段文本记录，避免消息丢失。
|
if (startIndex < 0 || endIndex < 0 || endIndex <= startIndex)
|
{
|
if (cache.Length > 0 && cache.Length < 2048 && !text.Contains("<START>", StringComparison.Ordinal))
|
{
|
AppendReceived(runtime, text.Trim());
|
cache.Clear();
|
}
|
|
if (cache.Length > 10240)
|
{
|
cache.Clear();
|
}
|
|
return;
|
}
|
|
var contentStart = startIndex + start.Length;
|
var contentLength = endIndex - contentStart;
|
var content = text.Substring(contentStart, contentLength);
|
cache.Remove(0, endIndex + end.Length);
|
AppendReceived(runtime, content);
|
}
|
}
|
|
private void AppendReceived(RobotClientRuntime runtime, string message)
|
{
|
if (string.IsNullOrWhiteSpace(message))
|
{
|
return;
|
}
|
|
runtime.LastReceivedMessage = message;
|
runtime.ReceivedMessages.Enqueue(new RobotServerReceivedMessageItem
|
{
|
ReceivedAt = DateTimeOffset.Now,
|
ClientId = 1,
|
RemoteEndPoint = $"{runtime.RemoteIp}:{runtime.RemotePort}",
|
Message = message
|
});
|
|
while (runtime.ReceivedMessages.Count > 500)
|
{
|
runtime.ReceivedMessages.TryDequeue(out _);
|
}
|
|
_logger.LogInformation("[{ServerId}] 收到: {Message}", runtime.ServerId, message);
|
}
|
|
private async Task SendFrameAsync(RobotClientRuntime runtime, string message, CancellationToken token)
|
{
|
if (!runtime.Connected)
|
{
|
throw new InvalidOperationException($"客户端实例 '{runtime.ServerId}' 未连接");
|
}
|
|
var frame = $"<START>{message}<END>";
|
var bytes = Encoding.UTF8.GetBytes(frame);
|
|
await runtime.SendLock.WaitAsync(token);
|
try
|
{
|
if (runtime.TcpClient == null)
|
{
|
throw new InvalidOperationException($"客户端实例 '{runtime.ServerId}' 未连接");
|
}
|
|
var stream = runtime.TcpClient.GetStream();
|
await stream.WriteAsync(bytes, 0, bytes.Length, token);
|
await stream.FlushAsync(token);
|
runtime.LastSentAt = DateTimeOffset.Now;
|
|
runtime.SentMessages.Enqueue(new RobotServerSentMessageItem
|
{
|
SentAt = DateTimeOffset.Now,
|
ClientId = 1,
|
RemoteEndPoint = $"{runtime.RemoteIp}:{runtime.RemotePort}",
|
Message = message
|
});
|
|
while (runtime.SentMessages.Count > 500)
|
{
|
runtime.SentMessages.TryDequeue(out _);
|
}
|
|
_logger.LogInformation("[{ServerId}] 发送: {Frame}", runtime.ServerId, frame);
|
}
|
finally
|
{
|
runtime.SendLock.Release();
|
}
|
}
|
|
private static async Task CloseRuntimeSocketAsync(RobotClientRuntime runtime)
|
{
|
await runtime.SendLock.WaitAsync();
|
try
|
{
|
if (runtime.TcpClient != null)
|
{
|
try { runtime.TcpClient.Close(); } catch { }
|
runtime.TcpClient.Dispose();
|
runtime.TcpClient = null;
|
}
|
runtime.Connected = false;
|
}
|
finally
|
{
|
runtime.SendLock.Release();
|
}
|
}
|
|
private async Task StopRuntimeAsync(RobotClientRuntime runtime)
|
{
|
try { runtime.Cancellation.Cancel(); } catch { }
|
|
if (runtime.ConnectionLoopTask != null)
|
{
|
try { await runtime.ConnectionLoopTask; } catch { }
|
}
|
|
await CloseRuntimeSocketAsync(runtime);
|
runtime.Cancellation.Dispose();
|
_logger.LogInformation("机械手客户端已停止: {ServerId}", runtime.ServerId);
|
}
|
|
private static RobotServerStatusItem ToStatusItem(RobotClientRuntime runtime)
|
{
|
var clients = new[]
|
{
|
new RobotServerClientStatusItem
|
{
|
ClientId = 1,
|
RemoteEndPoint = $"{runtime.RemoteIp}:{runtime.RemotePort}",
|
Connected = runtime.Connected,
|
ConnectedAt = runtime.ConnectedAt,
|
LastReceivedAt = runtime.LastReceivedAt,
|
LastSentAt = runtime.LastSentAt,
|
LastReceivedMessage = runtime.LastReceivedMessage,
|
LastError = runtime.LastError
|
}
|
};
|
|
var receivedMessages = runtime.ReceivedMessages
|
.Reverse()
|
.Take(200)
|
.ToArray();
|
|
var sentMessages = runtime.SentMessages
|
.Reverse()
|
.Take(200)
|
.ToArray();
|
|
return new RobotServerStatusItem
|
{
|
ServerId = runtime.ServerId,
|
Running = !runtime.Cancellation.IsCancellationRequested,
|
ListenIp = runtime.RemoteIp,
|
ListenPort = runtime.RemotePort,
|
LocalPort = runtime.LocalPort,
|
ConnectedCount = runtime.Connected ? 1 : 0,
|
Clients = clients,
|
ReceivedMessages = receivedMessages,
|
SentMessages = sentMessages
|
};
|
}
|
|
private static void ValidateStartRequest(RobotServerStartRequest request)
|
{
|
if (string.IsNullOrWhiteSpace(request.ServerId))
|
{
|
throw new ArgumentException("ServerId 不能为空");
|
}
|
|
if (string.IsNullOrWhiteSpace(request.ListenIp))
|
{
|
throw new ArgumentException("目标服务端地址不能为空");
|
}
|
|
if (request.ListenPort <= 0 || request.ListenPort > 65535)
|
{
|
throw new ArgumentException("目标服务端端口必须在 1-65535 范围内");
|
}
|
|
if (request.LocalPort <= 0 || request.LocalPort > 65535)
|
{
|
throw new ArgumentException("客户端本地端口必须在 1-65535 范围内");
|
}
|
}
|
|
/// <summary>
|
/// 启动前检查本地端口是否可用，避免实例进入无效重连状态。
|
/// </summary>
|
private static void EnsureLocalPortAvailable(int localPort)
|
{
|
Socket? probe = null;
|
try
|
{
|
probe = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
probe.Bind(new IPEndPoint(IPAddress.Any, localPort));
|
}
|
catch (SocketException ex)
|
{
|
throw new InvalidOperationException($"本地端口 {localPort} 已被占用或不可用", ex);
|
}
|
finally
|
{
|
try { probe?.Dispose(); } catch { }
|
}
|
}
|
|
private static async Task DelayForReconnect(CancellationToken token)
|
{
|
try
|
{
|
await Task.Delay(TimeSpan.FromSeconds(2), token);
|
}
|
catch (OperationCanceledException)
|
{
|
}
|
}
|
|
public void Dispose()
|
{
|
if (_disposed)
|
{
|
return;
|
}
|
|
_disposed = true;
|
StopAsync().GetAwaiter().GetResult();
|
}
|
|
private sealed class RobotClientRuntime
|
{
|
public string ServerId { get; set; } = string.Empty;
|
public string RemoteIp { get; set; } = string.Empty;
|
public int RemotePort { get; set; }
|
public int LocalPort { get; set; }
|
public TcpClient? TcpClient { get; set; }
|
public CancellationTokenSource Cancellation { get; set; } = default!;
|
public Task? ConnectionLoopTask { get; set; }
|
public SemaphoreSlim SendLock { get; } = new(1, 1);
|
public bool Connected { get; set; }
|
public DateTimeOffset? ConnectedAt { get; set; }
|
public DateTimeOffset? LastReceivedAt { get; set; }
|
public DateTimeOffset? LastSentAt { get; set; }
|
public string? LastReceivedMessage { get; set; }
|
public string? LastError { get; set; }
|
public ConcurrentQueue<RobotServerReceivedMessageItem> ReceivedMessages { get; } = new();
|
public ConcurrentQueue<RobotServerSentMessageItem> SentMessages { get; } = new();
|
}
|
}
|
|
public sealed class RobotServerStartRequest
|
{
|
public string ServerId { get; set; } = "default";
|
public string ListenIp { get; set; } = "127.0.0.1";
|
public int ListenPort { get; set; } = 2000;
|
public int LocalPort { get; set; } = 2001;
|
}
|
|
public sealed class RobotServerSendRequest
|
{
|
public string ServerId { get; set; } = string.Empty;
|
public int? ClientId { get; set; }
|
public string Message { get; set; } = string.Empty;
|
}
|
|
public sealed class RobotServerCollectionStatusResponse
|
{
|
public int RunningServerCount { get; set; }
|
public IReadOnlyList<RobotServerStatusItem> Servers { get; set; } = Array.Empty<RobotServerStatusItem>();
|
}
|
|
public sealed class RobotServerStatusItem
|
{
|
public string ServerId { get; set; } = string.Empty;
|
public bool Running { get; set; }
|
public string ListenIp { get; set; } = string.Empty;
|
public int ListenPort { get; set; }
|
public int LocalPort { get; set; }
|
public int ConnectedCount { get; set; }
|
public IReadOnlyList<RobotServerClientStatusItem> Clients { get; set; } = Array.Empty<RobotServerClientStatusItem>();
|
public IReadOnlyList<RobotServerReceivedMessageItem> ReceivedMessages { get; set; } = Array.Empty<RobotServerReceivedMessageItem>();
|
public IReadOnlyList<RobotServerSentMessageItem> SentMessages { get; set; } = Array.Empty<RobotServerSentMessageItem>();
|
}
|
|
public sealed class RobotServerClientStatusItem
|
{
|
public int ClientId { get; set; }
|
public string? RemoteEndPoint { get; set; }
|
public bool Connected { get; set; }
|
public DateTimeOffset? ConnectedAt { get; set; }
|
public DateTimeOffset? LastReceivedAt { get; set; }
|
public DateTimeOffset? LastSentAt { get; set; }
|
public string? LastReceivedMessage { get; set; }
|
public string? LastError { get; set; }
|
}
|
|
public sealed class RobotServerReceivedMessageItem
|
{
|
public DateTimeOffset ReceivedAt { get; set; }
|
public int ClientId { get; set; }
|
public string? RemoteEndPoint { get; set; }
|
public string Message { get; set; } = string.Empty;
|
}
|
|
public sealed class RobotServerSentMessageItem
|
{
|
public DateTimeOffset SentAt { get; set; }
|
public int ClientId { get; set; }
|
public string? RemoteEndPoint { get; set; }
|
public string Message { get; set; } = string.Empty;
|
}
|
