fix quicClient

Tun/Punchnet/Actors/SDLQuicClient.swift

@@ -18,6 +18,7 @@ enum SDLQUICError: Error {
     case timeout
     case decodeError(String)
     case packetTooLarge
+    case waitReadyAlreadyInProgress
 }
 
 enum SDLQUICEvent: Error {
@@ -56,7 +57,17 @@ actor SDLQUICClient {
     // 最大缓冲区区为2M
     private let maxBufferSize: Int
 
-    private let readyState = SDLQUICReadyState()
+    private enum ReadyStatus {
+        case idle
+        case connecting
+        case ready
+        case failed(Error)
+        case cancelled
+    }
+
+    private var readyStatus: ReadyStatus = .idle
+    private var readyContinuation: CheckedContinuation<Void, Error>?
+    private var readyTimeoutTask: Task<Void, Never>?
 
     // 消息流
     public var messageStream: AsyncStream<SDLQUICInboundMessage>
@@ -106,22 +117,22 @@ actor SDLQUICClient {
         SDLLogger.log("[SDLQUICClient] new state: \(state)", for: .debug)
         switch state {
         case .ready:
-            await self.readyState.markReady()
+            self.markReady()
         case .failed(let error):
-            await self.readyState.markFailed(error)
+            self.markFailed(error)
             self.emitEvent(.failed(error))
         case .cancelled:
-            await self.readyState.markCancelled()
+            self.markCancelled()
             self.emitEvent(.cancelled)
         case .setup, .preparing:
-            await self.readyState.markConnecting()
+            self.markConnecting()
         default:
             ()
         }
     }
 
     func waitReady(timeout: Duration = .seconds(5)) async throws {
-        try await self.readyState.waitReady(timeout: timeout)
+        try await self.waitReadyUntilStateChanged(timeout: timeout)
     }
 
     func run() async -> SDLQUICClientExit {
@@ -183,7 +194,7 @@ actor SDLQUICClient {
 
     func stop() async {
         self.connection.cancel()
-        await self.readyState.markCancelled()
+        self.markCancelled()
         self.finishStreams()
     }
 
@@ -210,109 +221,99 @@ actor SDLQUICClient {
 // --MARK: Ready状态机
 extension SDLQUICClient {
 
-    actor SDLQUICReadyState {
+    private func waitReadyUntilStateChanged(timeout: Duration) async throws {
-        enum State {
+        try Task.checkCancellation()
-            case idle
-            case connecting
-            case ready
-            case failed(Error)
-            case cancelled
-        }
 
-        private var state: State = .idle
+        try await withTaskCancellationHandler {
-        private var continuations: [UUID: CheckedContinuation<Void, Error>] = [:]
+            try await withCheckedThrowingContinuation { continuation in
-
+                switch self.readyStatus {
-        func waitReady(timeout: Duration) async throws {
+                case .ready:
-            let id = UUID()
+                    continuation.resume()
-            let timeoutTask = Task {
+                case .failed(let error):
-                try? await Task.sleep(for: timeout)
+                    continuation.resume(throwing: error)
-                if Task.isCancelled {
+                case .cancelled:
-                    return
+                    continuation.resume(throwing: SDLQUICError.connectionCancelled)
-                }
+                case .idle, .connecting:
-                self.cancelWaiter(id: id, throwing: SDLQUICError.timeout)
+                    guard self.readyContinuation == nil else {
-            }
+                        continuation.resume(throwing: SDLQUICError.waitReadyAlreadyInProgress)
-
+                        return
-            defer {
+                    }
-                timeoutTask.cancel()
+                    self.readyContinuation = continuation
-            }
+                    self.readyTimeoutTask?.cancel()
-
+                    self.readyTimeoutTask = Task {
-            try await withTaskCancellationHandler {
+                        do {
-                try await withCheckedThrowingContinuation { continuation in
+                            try await Task.sleep(for: timeout)
-                    self.addWaiter(id: id, continuation: continuation)
+                            if !Task.isCancelled {
-                }
+                                await self.cancelReadyWaiter(throwing: SDLQUICError.timeout)
-            } onCancel: {
+                            }
-                timeoutTask.cancel()
+                        } catch {
-                Task {
+                            return
-                    await self.cancelWaiter(id: id, throwing: CancellationError())
+                        }
+                    }
                 }
             }
-        }
+        } onCancel: {
-
+            Task {
-        private func addWaiter(id: UUID, continuation: CheckedContinuation<Void, Error>) {
+                await self.cancelReadyWaiter(throwing: CancellationError())
-            switch state {
-            case .ready:
-                continuation.resume()
-
-            case .failed(let error):
-                continuation.resume(throwing: error)
-
-            case .cancelled:
-                continuation.resume(throwing: CancellationError())
-
-            case .idle, .connecting:
-                continuations[id] = continuation
             }
         }
+    }
 
-        private func cancelWaiter(id: UUID, throwing error: Error) {
+    private func cancelReadyWaiter(throwing error: Error) {
-            guard let continuation = continuations.removeValue(forKey: id) else {
+        guard let continuation = self.readyContinuation else {
-                return
+            return
-            }
-
-            continuation.resume(throwing: error)
         }
 
-        func markConnecting() {
+        self.readyContinuation = nil
-            switch state {
+        self.readyTimeoutTask?.cancel()
-            case .idle:
+        self.readyTimeoutTask = nil
-                state = .connecting
+        continuation.resume(throwing: error)
-            default:
+    }
-                break
+
-            }
+    private func markConnecting() {
+        switch self.readyStatus {
+        case .idle:
+            self.readyStatus = .connecting
+        default:
+            break
+        }
+    }
+
+    private func markReady() {
+        self.readyStatus = .ready
+        self.resumeReadyWaiter()
+    }
+
+    private func markFailed(_ error: Error) {
+        self.readyStatus = .failed(error)
+        self.resumeReadyWaiter(throwing: error)
+    }
+
+    private func markCancelled() {
+        self.readyStatus = .cancelled
+        self.resumeReadyWaiter(throwing: SDLQUICError.connectionCancelled)
+    }
+
+    private func resumeReadyWaiter() {
+        guard let continuation = self.readyContinuation else {
+            return
         }
 
-        func markReady() {
+        self.readyContinuation = nil
-            state = .ready
+        self.readyTimeoutTask?.cancel()
+        self.readyTimeoutTask = nil
+        continuation.resume()
+    }
 
-            let list = continuations
+    private func resumeReadyWaiter(throwing error: Error) {
-            continuations.removeAll()
+        guard let continuation = self.readyContinuation else {
-
+            return
-            for continuation in list.values {
-                continuation.resume()
-            }
         }
 
-        func markFailed(_ error: Error) {
+        self.readyContinuation = nil
-            state = .failed(error)
+        self.readyTimeoutTask?.cancel()
-
+        self.readyTimeoutTask = nil
-            let list = continuations
+        continuation.resume(throwing: error)
-            continuations.removeAll()
-
-            for continuation in list.values {
-                continuation.resume(throwing: error)
-            }
-        }
-
-        func markCancelled() {
-            state = .cancelled
-
-            let list = continuations
-            continuations.removeAll()
-
-            for continuation in list.values {
-                continuation.resume(throwing: CancellationError())
-            }
-        }
     }
 }