feat: 初始功能

2026-05-23 18:16:50 +08:00
parent a5bfd8792e
commit 9a51259e9e
63 changed files with 5377 additions and 1 deletions
--- a/Services/WebSocketService.cs
+++ b/Services/WebSocketService.cs
@@ -0,0 +1,182 @@
+using CloudPrint.Client.Models;
+using CloudPrint.Client.Services.Abstractions;
+using System.IO;
+using System.Net.Http;
+using System.Net.WebSockets;
+using System.Text;
+
+namespace CloudPrint.Client.Services;
+
+/// <summary>
+/// WebSocket 备用通信通道。
+/// 当前后端主链路仍使用 gRPC 订阅；当后端提供 /ws/print 时，本服务可保持备用长连接并记录推送消息。
+/// </summary>
+public sealed class WebSocketService : IWebSocketService
+{
+    private const int ReceiveBufferSize = 8 * 1024;
+    private readonly SemaphoreSlim _connectionLock = new(1, 1);
+    private ClientWebSocket? _socket;
+    private CancellationTokenSource? _receiveCts;
+
+    public event EventHandler<AppLogEntry>? LogReceived;
+
+    public bool IsConnected { get; private set; }
+
+    public Uri? Endpoint { get; private set; }
+
+    public async Task ConnectAsync(Uri endpoint, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(endpoint);
+        if (endpoint.Scheme is not "ws" and not "wss")
+        {
+            throw new ArgumentException("WebSocket 地址必须以 ws:// 或 wss:// 开头", nameof(endpoint));
+        }
+
+        await _connectionLock.WaitAsync(cancellationToken).ConfigureAwait(false);
+        try
+        {
+            await DisconnectCoreAsync(CancellationToken.None).ConfigureAwait(false);
+            Endpoint = endpoint;
+
+            var socket = new ClientWebSocket();
+            _receiveCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+
+            try
+            {
+                await socket.ConnectAsync(endpoint, cancellationToken).ConfigureAwait(false);
+            }
+            catch (Exception ex) when (ex is WebSocketException or HttpRequestException or IOException)
+            {
+                socket.Dispose();
+                _receiveCts.Dispose();
+                _receiveCts = null;
+                IsConnected = false;
+                Log(AppLogLevel.Warning, $"WebSocket 备用通道不可用：{ex.Message}");
+                return;
+            }
+
+            _socket = socket;
+            IsConnected = true;
+            Log(AppLogLevel.Success, $"WebSocket 备用通道已连接：{endpoint}");
+            _ = Task.Run(() => ReceiveLoopAsync(socket, _receiveCts.Token), CancellationToken.None);
+        }
+        finally
+        {
+            _connectionLock.Release();
+        }
+    }
+
+    public async Task DisconnectAsync(CancellationToken cancellationToken = default)
+    {
+        await _connectionLock.WaitAsync(cancellationToken).ConfigureAwait(false);
+        try
+        {
+            await DisconnectCoreAsync(cancellationToken).ConfigureAwait(false);
+        }
+        finally
+        {
+            _connectionLock.Release();
+        }
+    }
+
+    private async Task ReceiveLoopAsync(ClientWebSocket socket, CancellationToken cancellationToken)
+    {
+        var buffer = new byte[ReceiveBufferSize];
+
+        try
+        {
+            while (!cancellationToken.IsCancellationRequested && socket.State == WebSocketState.Open)
+            {
+                using var message = new MemoryStream();
+                WebSocketReceiveResult result;
+                do
+                {
+                    result = await socket.ReceiveAsync(buffer, cancellationToken).ConfigureAwait(false);
+                    if (result.MessageType == WebSocketMessageType.Close)
+                    {
+                        await CloseSocketAsync(socket, cancellationToken).ConfigureAwait(false);
+                        MarkDisconnected(socket, "WebSocket 备用通道被服务端关闭");
+                        return;
+                    }
+
+                    message.Write(buffer, 0, result.Count);
+                }
+                while (!result.EndOfMessage);
+
+                if (result.MessageType == WebSocketMessageType.Text)
+                {
+                    var payload = Encoding.UTF8.GetString(message.ToArray());
+                    Log(AppLogLevel.Info, $"WebSocket 推送：{TrimPayload(payload)}");
+                }
+                else if (result.MessageType == WebSocketMessageType.Binary)
+                {
+                    Log(AppLogLevel.Info, $"WebSocket 收到二进制消息：{message.Length} 字节");
+                }
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // Normal shutdown path.
+        }
+        catch (Exception ex) when (ex is WebSocketException or IOException)
+        {
+            MarkDisconnected(socket, $"WebSocket 备用通道中断：{ex.Message}");
+        }
+    }
+
+    private async Task DisconnectCoreAsync(CancellationToken cancellationToken)
+    {
+        _receiveCts?.Cancel();
+
+        var socket = _socket;
+        _socket = null;
+        IsConnected = false;
+
+        if (socket is not null)
+        {
+            await CloseSocketAsync(socket, cancellationToken).ConfigureAwait(false);
+            socket.Dispose();
+            Log(AppLogLevel.Warning, "WebSocket 备用通道已断开");
+        }
+
+        _receiveCts?.Dispose();
+        _receiveCts = null;
+    }
+
+    private static async Task CloseSocketAsync(ClientWebSocket socket, CancellationToken cancellationToken)
+    {
+        if (socket.State is WebSocketState.Open or WebSocketState.CloseReceived)
+        {
+            await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "client closing", cancellationToken).ConfigureAwait(false);
+        }
+    }
+
+    private void MarkDisconnected(ClientWebSocket socket, string message)
+    {
+        if (ReferenceEquals(_socket, socket))
+        {
+            _socket = null;
+            IsConnected = false;
+            _receiveCts?.Dispose();
+            _receiveCts = null;
+        }
+
+        socket.Dispose();
+        Log(AppLogLevel.Warning, message);
+    }
+
+    private void Log(AppLogLevel level, string message)
+    {
+        LogReceived?.Invoke(this, new AppLogEntry
+        {
+            Level = level,
+            Message = message
+        });
+    }
+
+    private static string TrimPayload(string payload)
+    {
+        const int maxLength = 500;
+        return payload.Length <= maxLength ? payload : payload[..maxLength] + "...";
+    }
+}