调整生命周期的管理

Tun/Punchnet/Actors/SDLContextActor.swift

@@ -161,53 +161,48 @@ actor SDLContextActor {
     }
     
     private func startSuperClient() async throws {
-        SDLLogger.log("[SDLContext] try start quicClient", for: .debug)
-        
         // 启动monitor
         let quicClient = SDLQUICClient(host: self.config.serverHost, port: 1443)
         self.quicClient = quicClient
         await quicClient.start()
         
-        defer {
-            Task {
-                await self.quicClient?.stop()
-                self.quicClient = nil
-                SDLLogger.log("[SDLContext] quicClient: stop")
-            }
-        }
-        
         // 这里必须等待quic的协商完成
         try await Task.sleep(for: .seconds(0.5))
         SDLLogger.log("[SDLContext] start quic client: \(self.config.serverHost)")
         
-        try await withTaskCancellationHandler {
+        do {
-            try await withThrowingTaskGroup { group in
+            try await withTaskCancellationHandler {
-                defer {
+                try await withThrowingTaskGroup { group in
-                    group.cancelAll()
+                    defer {
-                }
+                        group.cancelAll()
-                
-                group.addTask {
-                    for try await message in await quicClient.messageStream {
-                        try Task.checkCancellation()
-                        await self.handleQUICMessage(message: message)
                     }
-                }
+                    
-                
+                    group.addTask {
-                group.addTask {
+                        for try await message in await quicClient.messageStream {
-                    while true {
+                            try Task.checkCancellation()
-                        try await Task.sleep(for: .seconds(5))
+                            await self.handleQUICMessage(message: message)
-                        try Task.checkCancellation()
+                        }
-                        await quicClient.send(type: .ping, data: Data())
                     }
-                    SDLLogger.log("[SDLQUICClient] udp pingTask cancel", for: .debug)
+                    
+                    group.addTask {
+                        while true {
+                            try await Task.sleep(for: .seconds(5))
+                            try Task.checkCancellation()
+                            await quicClient.send(type: .ping, data: Data())
+                        }
+                    }
+                    
+                    try await group.next()
+                }
+            } onCancel: {
+                SDLLogger.log("[SDLQUICClient] quicClient taskGroup cancel", for: .debug)
+                Task {
+                    await quicClient.stop()
                 }
-                
-                try await group.next()
-            }
-        } onCancel: {
-            Task {
-                await quicClient.stop()
             }
+        } catch let err {
+            await quicClient.stop()
+            throw err
         }
     }
     
@@ -289,21 +284,20 @@ actor SDLContextActor {
         let dnsClient = DNSCloudClient(host: self.config.serverHost, port: 15353)
         self.dnsClient = dnsClient
         dnsClient.start()
-        
+        do {
-        defer {
+            try await withTaskCancellationHandler {
-            self.dnsClient = nil
+                for try await packet in dnsClient.packetFlow {
-            dnsClient.stop()
+                    try Task.checkCancellation()
-        }
+                    
-        
+                    let nePacket = NEPacket(data: packet, protocolFamily: 2)
-        try await withTaskCancellationHandler {
+                    self.provider.packetFlow.writePacketObjects([nePacket])
-            for try await packet in dnsClient.packetFlow {
+                }
-                try Task.checkCancellation()
+            } onCancel: {
-                
+                dnsClient.stop()
-                let nePacket = NEPacket(data: packet, protocolFamily: 2)
-                self.provider.packetFlow.writePacketObjects([nePacket])
             }
-        } onCancel: {
+        } catch let err {
             dnsClient.stop()
+            throw err
         }
     }
     
@@ -325,25 +319,23 @@ actor SDLContextActor {
         SDLLogger.log("[SDLContext] dnsLocalClient started")
         self.dnsLocalClient = dnsLocalClient
         
-        defer {
+        do {
-            Task {
+            try await withTaskCancellationHandler {
-                self.dnsLocalClient = nil
+                // 处理事件流
-                await dnsLocalClient.stop()
+                for try await packet in dnsLocalClient.packetFlow {
-            }
+                    try Task.checkCancellation()
-        }
+                    // 要想办法构造一个完整的Ip包
-        
+                    let nePacket = NEPacket(data: packet, protocolFamily: 2)
-        try await withTaskCancellationHandler {
+                    self.provider.packetFlow.writePacketObjects([nePacket])
-            // 处理事件流
+                }
-            for try await packet in dnsLocalClient.packetFlow {
+            } onCancel: {
-                try Task.checkCancellation()
+                Task {
-                // 要想办法构造一个完整的Ip包
+                    await dnsLocalClient.stop()
-                let nePacket = NEPacket(data: packet, protocolFamily: 2)
+                }
-                self.provider.packetFlow.writePacketObjects([nePacket])
-            }
-        } onCancel: {
-            Task {
-                await dnsLocalClient.stop()
             }
+        } catch let err {
+            await dnsLocalClient.stop()
+            throw err
         }
     }