Basics: allow reusing cancellator handlers from SwiftTool (#6396)

These signal handlers are useful to other tools that don't have access to `SwiftTool`. For example, `DestinationCommand` would benefit from this as it needs to set up its own cancellator for handling archiver processes.

Moved signal handler setup to a new `installSignalHandlers` function on `Cancellator`. Made captures of `Cancellator` in handler closures weak so that it's not referenced indefinitely and is released when no longer needed.

Author: MaxDesiatov

Sources/Basics/Cancellator.swift

@@ -14,20 +14,94 @@ import Dispatch
 import Foundation
 import TSCBasic
 
+#if canImport(WinSDK)
+import WinSDK
+#endif
+
 public typealias CancellationHandler = (DispatchTime) throws -> Void
 
-public class Cancellator: Cancellable {
+public final class Cancellator: Cancellable {
     public typealias RegistrationKey = String
 
     private let observabilityScope: ObservabilityScope?
     private let registry = ThreadSafeKeyValueStore<String, (name: String, handler: CancellationHandler)>()
     private let cancelationQueue = DispatchQueue(label: "org.swift.swiftpm.cancellator", qos: .userInteractive, attributes: .concurrent)
     private let cancelling = ThreadSafeBox<Bool>(false)
 
+    private static let signalHandlerLock = NSLock()
+    private static var isSignalHandlerInstalled = false
+
     public init(observabilityScope: ObservabilityScope?) {
         self.observabilityScope = observabilityScope
     }
 
+    #if os(Windows)
+    // unfortunately this is needed for C callback handlers used by Windows shutdown handler
+    static var shared: Cancellator?
+    #endif
+
+    /// Installs signal handlers to terminate sub-processes on cancellation.
+    public func installSignalHandlers() {
+        Self.signalHandlerLock.withLock {
+            precondition(!Self.isSignalHandlerInstalled)
+            
+#if os(Windows)
+            // Closures passed to `SetConsoleCtrlHandler` can't capture context, working around that with a global.
+            Self.shared = self
+            
+            // set shutdown handler to terminate sub-processes, etc
+            _ = SetConsoleCtrlHandler({ _ in
+                // Terminate all processes on receiving an interrupt signal.
+                try? Cancellator.shared?.cancel(deadline: .now() + .seconds(30))
+                
+                // Reset the handler.
+                _ = SetConsoleCtrlHandler(nil, false)
+                
+                // Exit as if by signal()
+                TerminateProcess(GetCurrentProcess(), 3)
+                
+                return true
+            }, true)
+#else
+            // trap SIGINT to terminate sub-processes, etc
+            signal(SIGINT, SIG_IGN)
+            let interruptSignalSource = DispatchSource.makeSignalSource(signal: SIGINT)
+            interruptSignalSource.setEventHandler { [weak self] in
+                // cancel the trap?
+                interruptSignalSource.cancel()
+                
+                // Terminate all processes on receiving an interrupt signal.
+                try? self?.cancel(deadline: .now() + .seconds(30))
+                
+#if os(macOS) || os(OpenBSD)
+                // Install the default signal handler.
+                var action = sigaction()
+                action.__sigaction_u.__sa_handler = SIG_DFL
+                sigaction(SIGINT, &action, nil)
+                kill(getpid(), SIGINT)
+#elseif os(Android)
+                // Install the default signal handler.
+                var action = sigaction()
+                action.sa_handler = SIG_DFL
+                sigaction(SIGINT, &action, nil)
+                kill(getpid(), SIGINT)
+#else
+                var action = sigaction()
+                action.__sigaction_handler = unsafeBitCast(
+                    SIG_DFL,
+                    to: sigaction.__Unnamed_union___sigaction_handler.self
+                )
+                sigaction(SIGINT, &action, nil)
+                kill(getpid(), SIGINT)
+#endif
+            }
+            interruptSignalSource.resume()
+#endif
+            
+            Self.isSignalHandlerInstalled = true
+        }
+    }
+
     @discardableResult
     public func register(name: String, handler: @escaping CancellationHandler) -> RegistrationKey? {
         if self.cancelling.get(default: false) {

Sources/CoreCommands/SwiftTool.swift

@@ -50,13 +50,16 @@ import var TSCUtility.verbosity
 typealias Diagnostic = Basics.Diagnostic
 
 public struct ToolWorkspaceConfiguration {
+    let shouldInstallSignalHandlers: Bool
     let wantsMultipleTestProducts: Bool
     let wantsREPLProduct: Bool
 
     public init(
+        shouldInstallSignalHandlers: Bool = true,
         wantsMultipleTestProducts: Bool = false,
         wantsREPLProduct: Bool = false
     ) {
+        self.shouldInstallSignalHandlers = shouldInstallSignalHandlers
         self.wantsMultipleTestProducts = wantsMultipleTestProducts
         self.wantsREPLProduct = wantsREPLProduct
     }
@@ -308,57 +311,9 @@ public final class SwiftTool {
                 try ProcessEnv.chdir(packagePath)
             }
 
-            #if os(Windows)
-            // set shutdown handler to terminate sub-processes, etc
-            SwiftTool.cancellator = cancellator
-            _ = SetConsoleCtrlHandler({ _ in
-                // Terminate all processes on receiving an interrupt signal.
-                try? SwiftTool.cancellator?.cancel(deadline: .now() + .seconds(30))
-
-                // Reset the handler.
-                _ = SetConsoleCtrlHandler(nil, false)
-
-                // Exit as if by signal()
-                TerminateProcess(GetCurrentProcess(), 3)
-
-                return true
-            }, true)
-            #else
-            // trap SIGINT to terminate sub-processes, etc
-            signal(SIGINT, SIG_IGN)
-            let interruptSignalSource = DispatchSource.makeSignalSource(signal: SIGINT)
-            interruptSignalSource.setEventHandler {
-                // cancel the trap?
-                interruptSignalSource.cancel()
-
-                // Terminate all processes on receiving an interrupt signal.
-                try? cancellator.cancel(deadline: .now() + .seconds(30))
-
-                #if os(macOS) || os(OpenBSD)
-                // Install the default signal handler.
-                var action = sigaction()
-                action.__sigaction_u.__sa_handler = SIG_DFL
-                sigaction(SIGINT, &action, nil)
-                kill(getpid(), SIGINT)
-                #elseif os(Android)
-                // Install the default signal handler.
-                var action = sigaction()
-                action.sa_handler = SIG_DFL
-                sigaction(SIGINT, &action, nil)
-                kill(getpid(), SIGINT)
-                #else
-                var action = sigaction()
-                action.__sigaction_handler = unsafeBitCast(
-                    SIG_DFL,
-                    to: sigaction.__Unnamed_union___sigaction_handler.self
-                )
-                sigaction(SIGINT, &action, nil)
-                kill(getpid(), SIGINT)
-                #endif
+            if toolWorkspaceConfiguration.shouldInstallSignalHandlers {
+                cancellator.installSignalHandlers()
             }
-            interruptSignalSource.resume()
-            #endif
-
             self.cancellator = cancellator
         } catch {
             self.observabilityScope.emit(error)

Tests/CommandsTests/SwiftToolTests.swift

@@ -237,7 +237,7 @@ extension SwiftTool {
         return try SwiftTool(
             outputStream: outputStream,
             options: options,
-            toolWorkspaceConfiguration: .init(),
+            toolWorkspaceConfiguration: .init(shouldInstallSignalHandlers: false),
             workspaceDelegateProvider: {
                 ToolWorkspaceDelegate(
                     observabilityScope: $0,