feat(robot): 完善机械手任务处理逻辑与状态管理

wanshenmean

8 天以前 adb4016b5eb5b119a899480c321be996d9bf10bd

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/SocketServer/TcpSocketServer.Server.cs

@@ -1,55 +1,63 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using WIDESEAWCS_Core.Helper;
using System.IO;
using WIDESEAWCS_Core.LogHelper;

namespace WIDESEAWCS_Tasks.SocketServer
{
    public partial class TcpSocketServer
    {
        /// <summary>
        /// 异步启动TCP服务器，使其开始接受传入的客户端连接。
        /// 异步启动 TCP Socket 服务器
        /// </summary>
        /// <remarks>如果服务器已在运行或通过配置禁用，此方法将立即返回而不启动服务器。
        /// 后续的客户端监控和接受操作在后台任务中运行。此方法不会阻塞调用线程。</remarks>
        /// <param name="cancellationToken">可用于请求取消服务器启动及后续后台操作的取消令牌。</param>
        /// <returns>表示异步启动操作的任务。当服务器开始监听连接时任务完成。</returns>
        public Task StartAsync(CancellationToken cancellationToken)
        /// <remarks>
        /// 创建 TCP 监听器并开始接受客户端连接。
        /// 如果服务器已在运行或被禁用，直接返回。
        /// 启动后启动接受循环和客户端监控任务。
        /// </remarks>
        /// <param name="cancellationToken">取消令牌</param>
        /// <returns>启动任务</returns>
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            if (IsRunning || !_options.Enabled)
            {
                return Task.CompletedTask;
                return;
            }

            // 解析监听地址
            IPAddress ipAddress = IPAddress.Any;
            if (IPAddress.TryParse(_options.IpAddress, out IPAddress? parsedAddress))
            {
                ipAddress = parsedAddress;
            }

            await Task.Delay(5000);

            // 创建监听器
            _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;
            return;
        }

        //// <summary>
        /// 异步停止服务器并等待所有活动客户端连接完成。
        /// <summary>
        /// 异步停止 TCP Socket 服务器
        /// </summary>
        /// <remarks>如果服务器未运行，此方法将立即返回而不执行任何操作。
        /// 此方法确保所有客户端任务完成后才将服务器标记为已停止。</remarks>
        /// <param name="cancellationToken">可用于在完成前取消停止操作的取消令牌。</param>
        /// <returns>表示异步停止操作的任务。</returns>
        /// <remarks>
        /// 停止接受新连接，等待所有客户端任务完成。
        /// </remarks>
        /// <param name="cancellationToken">取消令牌</param>
        /// <returns>停止任务</returns>
        public async Task StopAsync(CancellationToken cancellationToken)
        {
            if (!IsRunning)
@@ -57,9 +65,13 @@
                return;
            }

            // 发送取消信号
            _cts?.Cancel();

            // 停止监听
            _listener?.Stop();

            // 等待所有客户端任务完成
            Task[] tasks;
            lock (_syncRoot)
            {
@@ -75,12 +87,16 @@
        }

        /// <summary>
        /// 持续接受传入的TCP客户端连接，直到请求取消。
        /// 异步接受客户端连接的主循环
        /// </summary>
        /// <remarks>此方法旨在后台运行以处理新的客户端连接。
        /// 如果监听器被释放或通过提供的令牌请求取消，循环将退出。</remarks>
        /// <param name="cancellationToken">可用于请求取消接受循环的令牌。当请求取消时，循环将立即终止。</param>
        /// <returns>表示异步接受循环操作的任务。</returns>
        /// <summary>
        /// 异步接受客户端连接的主循环
        /// </summary>
        /// <remarks>
        /// 在后台线程中持续接受新的客户端连接。
        /// 当有新连接时，将其添加到客户端字典并启动消息处理任务。
        /// </remarks>
        /// <param name="cancellationToken">取消令牌</param>
        private async Task AcceptLoopAsync(CancellationToken cancellationToken)
        {
            while (!cancellationToken.IsCancellationRequested)
@@ -88,31 +104,23 @@
                TcpClient? client = null;
                try
                {
                    // 等待客户端连接
                    client = await _listener!.AcceptTcpClientAsync().WaitAsync(cancellationToken);
                    ConsoleHelper.WriteSuccessLine($"客户端上线:{client.Client.RemoteEndPoint.ToString()}");
                    QuartzLogger.Info($"客户端连接:{client.Client.RemoteEndPoint.ToString()}");
                }
                catch (OperationCanceledException)
                {
                    break;
                }
                catch (ObjectDisposedException)
                {
                    break;
                }
                catch (OperationCanceledException) { break; }
                catch (ObjectDisposedException) { break; }
                catch
                {
                    if (cancellationToken.IsCancellationRequested)
                    {
                        break;
                    }
                    if (cancellationToken.IsCancellationRequested) break;
                }

                if (client == null)
                {
                    continue;
                }
                if (client == null) continue;

                // 生成客户端 ID（使用远程端点地址）
                string clientId = GetClientId(client);

                // 添加到客户端字典
                lock (_syncRoot)
                {
                    _clients[clientId] = client;
@@ -122,30 +130,41 @@
        }

        /// <summary>
        /// 从内部集合中移除指定标识符的客户端，并释放相关资源。
        /// 移除客户端连接
        /// </summary>
        /// <remarks>此方法关闭客户端连接，释放任何关联的锁，并移除对客户端的所有引用，
        /// 包括设备绑定和编码信息。通过对内部同步对象加锁确保线程安全。</remarks>
        /// <param name="clientId">要移除的客户端的唯一标识符。不能为null或空。</param>
        /// <remarks>
        /// 关闭客户端连接并清理相关资源：
        /// - 关闭 TcpClient
        /// - 释放信号量
        /// - 移除活跃时间和编码记录
        /// - 移除设备绑定
        /// </remarks>
        /// <param name="clientId">要移除的客户端唯一标识</param>
        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)
                {
@@ -155,12 +174,13 @@
        }

        /// <summary>
        /// 异步监控已连接的客户端，并断开超过配置超时时间闲置的客户端连接。
        /// 异步监控客户端空闲超时
        /// </summary>
        /// <remarks>此方法持续检查闲置客户端，如果其不活动时间超过指定的空闲超时，则断开连接。
        /// 监控循环将持续运行，直到通过提供的令牌请求取消。</remarks>
        /// <param name="cancellationToken">可用于请求终止监控循环的取消令牌。</param>
        /// <returns>表示异步监控操作的任务。</returns>
        /// <remarks>
        /// 定期检查所有客户端的最后活跃时间，
        /// 如果超过空闲超时时间，断开该客户端连接。
        /// </remarks>
        /// <param name="cancellationToken">取消令牌</param>
        private async Task MonitorClientsAsync(CancellationToken cancellationToken)
        {
            while (!cancellationToken.IsCancellationRequested)
@@ -172,6 +192,7 @@
                    {
                        foreach (var kv in _clientLastActive)
                        {
                            // 检查是否超过空闲超时
                            if (_options.IdleTimeoutSeconds > 0 && DateTime.Now - kv.Value > TimeSpan.FromSeconds(_options.IdleTimeoutSeconds))
                            {
                                toRemove.Add(kv.Key);
@@ -179,27 +200,29 @@
                        }
                    }

                    // 断开超时的客户端
                    foreach (var cid in toRemove)
                    {
                        RemoveClient(cid);
                        Log($"[{DateTime.Now}] TcpSocketServer disconnect idle client {cid}");
                    }
                }
                catch
                {
                }
                catch { }

                // 每秒检查一次
                try { await Task.Delay(1000, cancellationToken); } catch { }
            }
        }

        /// <summary>
        /// 基于远程终端点获取指定TCP客户端的唯一标识符字符串。
        /// 获取客户端唯一标识
        /// </summary>
        /// <remarks>返回的标识符适用于在日志记录或跟踪场景中区分客户端。
        /// 如果客户端的远程终端点不可用，将生成GUID以确保唯一性。</remarks>
        /// <param name="client">要获取标识符的TCP客户端。不能为null。</param>
        /// <returns>表示客户端远程终端点的字符串（如果可用）；否则为生成的新GUID字符串。</returns>
        /// <remarks>
        /// 使用客户端的远程端点地址作为标识。
        /// 如果远程端点不可用，生成随机 GUID。
        /// </remarks>
        /// <param name="client">TCP 客户端</param>
        /// <returns>客户端标识字符串</returns>
        public static string GetClientId(TcpClient client)
        {
            return client.Client.RemoteEndPoint?.ToString() ?? Guid.NewGuid().ToString();