add fatal log

Tun/Context/SDLContextActor.swift

@@ -145,9 +145,11 @@ actor SDLContextActor {
                 try await self.runRootBody()
                 await self.cleanupRoot()
             } catch is CancellationError {
+                SDLLogger.fatal("[SDLContext] root task cancelled")
                 await self.cleanupRoot()
                 throw CancellationError()
             } catch {
+                SDLLogger.fatal("[SDLContext] root task failed: \(error)")
                 await self.readySignal.fail(error)
                 await self.cleanupRoot()
                 throw error
@@ -158,6 +160,7 @@ actor SDLContextActor {
         do {
             try await self.readySignal.wait(timeout: .seconds(30))
         } catch {
+            SDLLogger.fatal("[SDLContext] start failed while waiting ready signal: \(error)")
             rootTask.cancel()
             _ = try? await rootTask.value
             self.rootTask = nil
@@ -167,6 +170,7 @@ actor SDLContextActor {
 
     // 处理context的停止问题
     public func stop() async {
+        SDLLogger.fatal("[SDLContext] stop requested")
         let rootTask = self.rootTask
         self.rootTask = nil
 
@@ -434,6 +438,7 @@ extension SDLContextActor {
         case .requestExposedService:
             await self.requestExposedService()
         case .shutdown(let message):
+            SDLLogger.fatal("[SDLContext] Super shutdown received: \(message)")
             self.publishTunnelEvent(message: message)
             let error = NSError(domain: "com.jihe.punchnet.tun", code: -2)
             self.provider.cancelTunnelWithError(error)
@@ -456,12 +461,14 @@ extension SDLContextActor {
             SDLLogger.log("[SDLContext] setNetworkSettings successed")
             await self.readySignal.succeed(())
         } catch {
+            SDLLogger.fatal("[SDLContext] apply tunnel network settings failed: \(error)")
             SDLLogger.log("[SDLContext] setTunnelNetworkSettings get error: \(error)")
             await self.failTunnel(error)
         }
     }
 
     private func failTunnel(_ error: Error) async {
+        SDLLogger.fatal("[SDLContext] failTunnel: \(error)")
         await self.readySignal.fail(error)
         self.provider.cancelTunnelWithError(error)
     }

Tun/Context/SDLSuperControlPlane.swift

@@ -107,6 +107,7 @@ actor SDLSuperControlPlane {
 
     private func handleRegisterSuperAck(_ registerSuperAck: SDLRegisterSuperAck) async {
         guard let key = try? self.rsaCipher.decode(data: Data(registerSuperAck.key)) else {
+            SDLLogger.fatal("[SDLSuperControlPlane] registerSuperAck invalid key, will fail tunnel")
             SDLLogger.log("[SDLContext] registerSuperAck invalid key")
             await self.onDecision(.failTunnel(SDLError.invalidKey))
             return
@@ -123,6 +124,7 @@ actor SDLSuperControlPlane {
         case "chacha20":
             cipher = CCChaCha20Cipher(regionId: regionId, keyData: key)
         default:
+            SDLLogger.fatal("[SDLSuperControlPlane] unsupported cipher algorithm \(algorithm), will fail tunnel")
             SDLLogger.log("[SDLContext] registerSuperAck invalid algorithm \(algorithm)")
             await self.onDecision(.failTunnel(SDLError.unsupportedAlgorithm(algorithm: algorithm)))
             return
@@ -140,6 +142,7 @@ actor SDLSuperControlPlane {
 
         switch errorCode {
         case .invalidToken, .nodeDisabled:
+            SDLLogger.fatal("[SDLSuperControlPlane] SuperNak \(errorCode) will fail tunnel: \(errorMessage)")
             await self.onDecision(.publishTunnelEvent(code: Int(errorCode.rawValue), message: errorMessage))
             await self.onDecision(.failTunnel(NSError(domain: "com.jihe.punchnet.tun", code: -1)))
         case .noIpAddress, .networkFault, .internalFault:
@@ -161,6 +164,7 @@ actor SDLSuperControlPlane {
             SDLLogger.log("[SDLContext] exposedServiceChanged event")
             await self.onDecision(.requestExposedService)
         case .shutdown(let shutdownEvent):
+            SDLLogger.fatal("[SDLSuperControlPlane] shutdown event received: \(shutdownEvent.message)")
             await self.onDecision(.shutdown(message: shutdownEvent.message))
         case .none:
             ()

Tun/Diagnostics/SDLLogger.swift

@@ -36,6 +36,10 @@ public class SDLLogger: @unchecked Sendable {
     public func _log(_ message: String) {
         self.log.info("\(message, privacy: .public)")
     }
+
+    public func _fatal(_ message: String) {
+        self.log.fault("\(message, privacy: .public)")
+    }
     
     public static func log(_ message: @autoclosure () -> String, for system: Subsystem = .debug) {
         guard self.isEnabled(system), let logger = loggers[system] else {
@@ -45,6 +49,14 @@ public class SDLLogger: @unchecked Sendable {
         logger._log(message())
     }
 
+    public static func fatal(_ message: @autoclosure () -> String, for system: Subsystem = .debug) {
+        guard let logger = loggers[system] else {
+            return
+        }
+
+        logger._fatal(message())
+    }
+
     private static func isEnabled(_ system: Subsystem) -> Bool {
         switch system {
         case .debug:

Tun/PacketTunnelProvider.swift

@@ -30,6 +30,7 @@ class PacketTunnelProvider: NEPacketTunnelProvider {
     
     override func startTunnel(options: [String: NSObject]?, completionHandler: @escaping (Error?) -> Void) {
         guard let options, let config = SDLConfiguration.parse(options: options) else {
+            SDLLogger.fatal("[PacketTunnelProvider] startTunnel failed: invalid configuration")
             completionHandler(TunnelError.invalidConfiguration)
             return
         }
@@ -39,6 +40,7 @@ class PacketTunnelProvider: NEPacketTunnelProvider {
     }
 
     override func stopTunnel(with reason: NEProviderStopReason, completionHandler: @escaping () -> Void) {
+        SDLLogger.fatal("[PacketTunnelProvider] stopTunnel requested, reason: \(reason.rawValue)")
         self.stopContext(clearRuntimeConfiguration: true, completionHandler: completionHandler)
     }
 
@@ -61,6 +63,7 @@ class PacketTunnelProvider: NEPacketTunnelProvider {
     }
 
     override func sleep(completionHandler: @escaping () -> Void) {
+        SDLLogger.fatal("[PacketTunnelProvider] sleep requested, will stop current context")
         self.stopContext(clearRuntimeConfiguration: false) {
             SDLLogger.log("[PacketTunnelProvider] sleep")
             completionHandler()
@@ -71,6 +74,7 @@ class PacketTunnelProvider: NEPacketTunnelProvider {
         SDLLogger.log("[PacketTunnelProvider] wake up!!!!!!!")
         self.startCachedContext { err in
             if let err {
+                SDLLogger.fatal("[PacketTunnelProvider] wakeup start failed: \(err)")
                 SDLLogger.log("[PacketTunnelProvider] wakeup start failed: \(err.localizedDescription)")
             } else {
                 SDLLogger.log("[PacketTunnelProvider] wakeup and try start")
@@ -119,6 +123,7 @@ private extension PacketTunnelProvider {
         self.runtimeLock.unlock()
 
         guard let config, let rsaCipher else {
+            SDLLogger.fatal("[PacketTunnelProvider] startCachedContext failed: missing cached runtime configuration")
             completionHandler(TunnelError.invalidConfiguration)
             return
         }
@@ -150,11 +155,13 @@ private extension PacketTunnelProvider {
                     try await contextActor.start()
                     self.finishContextStart(contextActor, error: nil)
                 } catch {
+                    SDLLogger.fatal("[PacketTunnelProvider] context start failed: \(error)")
                     self.finishContextStart(contextActor, error: error)
                 }
             }
 
         case .starting, .running, .stopping:
+            SDLLogger.fatal("[PacketTunnelProvider] startContext rejected: invalid runtime state \(self.runtimeState)")
             self.runtimeLock.unlock()
             completionHandler(TunnelError.invalidContext)
         }
@@ -166,6 +173,7 @@ private extension PacketTunnelProvider {
         let startCompletionHandler = self.startCompletionHandler
 
         guard contextActor != nil else {
+            SDLLogger.fatal("[PacketTunnelProvider] stopContext requested while context is nil, clearRuntimeConfiguration: \(clearRuntimeConfiguration)")
             self.runtimeState = .idle
             self.startCompletionHandler = nil
             if clearRuntimeConfiguration {
@@ -187,6 +195,7 @@ private extension PacketTunnelProvider {
         }
         self.runtimeLock.unlock()
 
+        SDLLogger.fatal("[PacketTunnelProvider] stopContext will stop current context, clearRuntimeConfiguration: \(clearRuntimeConfiguration)")
         startCompletionHandler?(TunnelError.invalidContext)
 
         Task {