141 lines
4.1 KiB
Swift
141 lines
4.1 KiB
Swift
import Foundation
|
|
import NIOCore
|
|
|
|
actor SDLUDPHoleV6Service {
|
|
typealias EventHandler = SDLUDPHoleService.EventHandler
|
|
typealias DataHandler = SDLUDPHoleService.DataHandler
|
|
|
|
private var onEvent: EventHandler = { _ in }
|
|
private var onData: DataHandler = { _ in }
|
|
private var currentSession: SDLUDPHoleV6Session?
|
|
private var generation: UInt64 = 0
|
|
private var isRunning = false
|
|
private var isStopping = false
|
|
private var needsImmediateRestart = false
|
|
private let retryDelay: Duration
|
|
|
|
init(retryDelay: Duration = .seconds(5)) {
|
|
self.retryDelay = retryDelay
|
|
}
|
|
|
|
func updateHandlers(onEvent: @escaping EventHandler, onData: @escaping DataHandler) {
|
|
self.onEvent = onEvent
|
|
self.onData = onData
|
|
}
|
|
|
|
func run() async throws {
|
|
guard !self.isRunning else {
|
|
return
|
|
}
|
|
|
|
self.isRunning = true
|
|
self.isStopping = false
|
|
|
|
defer {
|
|
self.isRunning = false
|
|
self.currentSession = nil
|
|
}
|
|
|
|
while !Task.isCancelled, !self.isStopping {
|
|
let generation = self.nextGeneration()
|
|
let session = SDLUDPHoleV6Session(
|
|
onEvent: { [weak self] event in
|
|
await self?.handleEvent(event, generation: generation)
|
|
},
|
|
onData: self.onData
|
|
)
|
|
|
|
self.currentSession = session
|
|
|
|
do {
|
|
try await session.run()
|
|
self.clearCurrent(session, generation: generation)
|
|
await session.stop()
|
|
|
|
guard !self.isStopping else {
|
|
break
|
|
}
|
|
|
|
SDLLogger.log("[SDLUDPHoleV6Service] session ended, will restart", category: .udpHole)
|
|
} catch is CancellationError {
|
|
self.clearCurrent(session, generation: generation)
|
|
await session.stop()
|
|
throw CancellationError()
|
|
} catch {
|
|
self.clearCurrent(session, generation: generation)
|
|
await session.stop()
|
|
|
|
guard !self.isStopping else {
|
|
break
|
|
}
|
|
|
|
SDLLogger.log("[SDLUDPHoleV6Service] session failed: \(error.localizedDescription), will restart", category: .udpHole)
|
|
}
|
|
|
|
if self.consumeImmediateRestartRequest() {
|
|
SDLLogger.log("[SDLUDPHoleV6Service] session invalidated after wakeup, will restart immediately", category: .udpHole)
|
|
continue
|
|
}
|
|
|
|
try await Task.sleep(for: self.retryDelay)
|
|
}
|
|
}
|
|
|
|
func stop() async {
|
|
self.isStopping = true
|
|
self.needsImmediateRestart = false
|
|
await self.invalidateCurrentSession()
|
|
}
|
|
|
|
func recoverAfterWake() async {
|
|
guard !self.isStopping else {
|
|
return
|
|
}
|
|
|
|
self.needsImmediateRestart = self.currentSession != nil
|
|
await self.invalidateCurrentSession()
|
|
}
|
|
|
|
func send(type: SDLPacketType, data: Data, remoteAddress: SocketAddress) async {
|
|
await self.currentSession?.send(type: type, data: data, remoteAddress: remoteAddress)
|
|
}
|
|
|
|
private func nextGeneration() -> UInt64 {
|
|
self.generation &+= 1
|
|
return self.generation
|
|
}
|
|
|
|
private func invalidateCurrentSession() async {
|
|
self.generation &+= 1
|
|
|
|
let session = self.currentSession
|
|
self.currentSession = nil
|
|
|
|
await session?.stop()
|
|
}
|
|
|
|
private func consumeImmediateRestartRequest() -> Bool {
|
|
let needsImmediateRestart = self.needsImmediateRestart
|
|
self.needsImmediateRestart = false
|
|
return needsImmediateRestart
|
|
}
|
|
|
|
private func clearCurrent(_ session: SDLUDPHoleV6Session, generation: UInt64) {
|
|
guard self.generation == generation else {
|
|
return
|
|
}
|
|
|
|
if self.currentSession === session {
|
|
self.currentSession = nil
|
|
}
|
|
}
|
|
|
|
private func handleEvent(_ event: SDLUDPHoleService.Event, generation: UInt64) async {
|
|
guard self.generation == generation else {
|
|
return
|
|
}
|
|
|
|
await self.onEvent(event)
|
|
}
|
|
}
|