Fix the trivially fixed concurrency warnings and errors

Author: Frizlab

Package.resolved

@@ -18,23 +18,27 @@ let package = Package(
 	dependencies: [
 		.package(url: "https://github.com/apple/swift-argument-parser.git", from: "1.0.0"),
 		.package(url: "https://github.com/apple/swift-log.git",             from: "1.4.2"),
+		.package(url: "https://github.com/Frizlab/GlobalConfModule.git",    from: "0.4.0"),
 		.package(url: "https://github.com/xcode-actions/clt-logger.git",    from: "1.0.0-beta.4"),
 	],
 	targets: [
 		.target(name: "SignalHandling", dependencies: [
-			.product(name: "Logging", package: "swift-log"),
+			.product(name: "Logging",          package: "swift-log"),
+			.product(name: "GlobalConfModule", package: "GlobalConfModule"),
 		], swiftSettings: swiftSettings),
 
 		.executableTarget(name: "signal-handling-tests-helper", dependencies: [
-			.product(name: "ArgumentParser", package: "swift-argument-parser"),
-			.product(name: "CLTLogger",      package: "clt-logger"),
-			.product(name: "Logging",        package: "swift-log"),
+			.product(name: "ArgumentParser",   package: "swift-argument-parser"),
+			.product(name: "CLTLogger",        package: "clt-logger"),
+			.product(name: "GlobalConfModule", package: "GlobalConfModule"),
+			.product(name: "Logging",          package: "swift-log"),
 			.target(name: "SignalHandling"),
 		], swiftSettings: swiftSettings),
 		.testTarget(name: "SignalHandlingTests", dependencies: [
 			.target(name: "signal-handling-tests-helper"),
-			.product(name: "CLTLogger",     package: "clt-logger"),
-			.product(name: "Logging",       package: "swift-log"),
+			.product(name: "CLTLogger",        package: "clt-logger"),
+			.product(name: "GlobalConfModule", package: "GlobalConfModule"),
+			.product(name: "Logging",          package: "swift-log"),
 		], swiftSettings: swiftSettings),
 	]
 )

Package.swift

@@ -0,0 +1,26 @@
+import Foundation
+
+import GlobalConfModule
+import Logging
+
+
+
+public extension ConfKeys {
+	/* SignalHandling conf namespace declaration. */
+	struct SignalHandling {}
+	var signalHandling: SignalHandling {SignalHandling()}
+}
+
+
+extension ConfKeys.SignalHandling {
+	
+	#declareConfKey("logger", Logging.Logger?.self, defaultValue: .init(label: "com.xcode-actions.signal-handling"))
+	
+}
+
+
+extension Conf {
+	
+	#declareConfAccessor(\.signalHandling.logger, Logging.Logger?.self)
+	
+}

Sources/SignalHandling/ Config.swift

@@ -5,9 +5,11 @@ import SystemPackage
 import System
 #endif
 
+import GlobalConfModule
 
 
-public struct Sigaction : Equatable, RawRepresentable {
+
+public struct Sigaction : Equatable, RawRepresentable, Sendable {
 
 	public static let ignoreAction = Sigaction(handler: .ignoreHandler)
 	public static let defaultAction = Sigaction(handler: .defaultHandler)
@@ -66,7 +68,7 @@ public struct Sigaction : Equatable, RawRepresentable {
 #endif
 
 		if !isValid {
-			SignalHandlingConfig.logger?.warning("Initialized an invalid Sigaction.")
+			Conf.logger?.warning("Initialized an invalid Sigaction.")
 		}
 	}
 
@@ -80,7 +82,7 @@ public struct Sigaction : Equatable, RawRepresentable {
 
 	public var rawValue: sigaction {
 		if !isValid {
-			SignalHandlingConfig.logger?.warning("Getting sigaction from an invalid Sigaction.")
+			Conf.logger?.warning("Getting sigaction from an invalid Sigaction.")
 		}
 
 		var ret = sigaction()

Sources/SignalHandling/SignalHandlingError.swift renamed to Sources/SignalHandling/ Errors.swift

@@ -3,7 +3,7 @@ import Foundation
 
 
 /** Flag list is from `sigaction(2)` on macOS. */
-public struct SigactionFlags : OptionSet {
+public struct SigactionFlags : OptionSet, Sendable {
 
 	/**
 	 If this bit is set when installing a catching function for the `SIGCHLD` signal,

Sources/SignalHandling/CStructsInSwift/Sigaction.swift

@@ -6,7 +6,7 @@ import Foundation
  A `sigaction` handler.
 
  Two `SigactionHandler`s are equal iif their cases are equal and the handler they contain point to the same address (if applicable). */
-public enum SigactionHandler : Equatable {
+public enum SigactionHandler : Equatable, Sendable {
 
 	/* The ignore and default handlers are special cases represented respectively by the `SIG_IGN` and `SIG_DFL` values in C.
 	 * We choose the represent them using a special case in the enum.

Sources/SignalHandling/CStructsInSwift/SigactionFlag.swift

@@ -4,7 +4,7 @@ import Foundation
 
 /* Could be an enum?
  * I’d say no to be able to represent signals we don’t know are a part of the system. */
-public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
+public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible, Sendable {
 
 	/* Signal 0 is not considered.
 	 * Because it does not exist.

Sources/SignalHandling/CStructsInSwift/SigactionHandler.swift

@@ -5,6 +5,8 @@ import SystemPackage
 import System
 #endif
 
+import GlobalConfModule
+
 
 
 /**
@@ -121,7 +123,7 @@ public enum SigactionDelayer_Block {
 					for (signal, UnsigactionID) in ret {
 						do    {try unregisterDelayedSigactionOnQueue(UnsigactionID)}
 						catch {
-							SignalHandlingConfig.logger?.error(
+							Conf.logger?.error(
 								"Cannot unregister delayed sigaction for in recovery handler of registerDelayedSigactions. The signal will stay blocked, probably forever.",
 								metadata: ["signal": "\(signal)", "error": "\(error)"]
 							)
@@ -257,7 +259,7 @@ public enum SigactionDelayer_Block {
 			signalProcessingQueue.async{
 				do {try currentSigaction.install(on: signal)}
 				catch {
-					SignalHandlingConfig.logger?.error(
+					Conf.logger?.error(
 						"Cannot set original sigaction back for signal after signal source activation. You might never be called in the sigaction handler and get an infinite loop of signal calls once this signal has been sent once.",
 						metadata: ["signal": "\(signal)", "error": "\(error)"]
 					)
@@ -281,15 +283,15 @@ public enum SigactionDelayer_Block {
 		guard var blockedSignal = blockedSignals[signal] else {
 			/* We trust our source not to have an internal logic error.
 			 * If the delayed sigaction is not found, it is because the callee called unregister twice on the same delayed sigaction. */
-			SignalHandlingConfig.logger?.error("Delayed sigaction unregistered more than once.", metadata: ["signal": "\(signal)"])
+			Conf.logger?.error("Delayed sigaction unregistered more than once.", metadata: ["signal": "\(signal)"])
 			return
 		}
 		assert(!blockedSignal.handlers.isEmpty, "INTERNAL ERROR: handlers should never be empty because when it is, the whole delayed signal should be removed.")
 
 		guard blockedSignal.handlers.removeValue(forKey: delayedSigaction) != nil else {
 			/* Same here.
 			 * If the delayed sigaction was not in the handlers, it can only be because the callee called unregister twice with the object. */
-			SignalHandlingConfig.logger?.error("Delayed sigaction unregistered more than once.", metadata: ["signal": "\(signal)"])
+			Conf.logger?.error("Delayed sigaction unregistered more than once.", metadata: ["signal": "\(signal)"])
 			return
 		}
 
@@ -312,11 +314,11 @@ public enum SigactionDelayer_Block {
 
 	/** Must always be called on the `signalProcessingQueue`. */
 	private static func processSignalsOnQueue(signal: Signal, count: UInt) {
-		SignalHandlingConfig.logger?.debug("Processing signals, called from libdispatch.", metadata: ["signal": "\(signal)", "count": "\(count)"])
+		Conf.logger?.debug("Processing signals, called from libdispatch.", metadata: ["signal": "\(signal)", "count": "\(count)"])
 
 		/* Get the delayed signal for the given signal. */
 		guard let blockedSignal = blockedSignals[signal] else {
-			SignalHandlingConfig.logger?.error("INTERNAL ERROR: nil delayed signal.", metadata: ["signal": "\(signal)"])
+			Conf.logger?.error("INTERNAL ERROR: nil delayed signal.", metadata: ["signal": "\(signal)"])
 			return
 		}
 
@@ -335,7 +337,7 @@ public enum SigactionDelayer_Block {
 			/* All the handlers have responded, we now know whether to allow or drop the signal. */
 			do {try executeOnThread(runOriginalHandlerFinal ? .suspend(for: signal) : .drop(signal))}
 			catch {
-				SignalHandlingConfig.logger?.error(
+				Conf.logger?.error(
 					"Error while \(runOriginalHandlerFinal ? "suspending thread" : "dropping signal in thread").",
 					metadata: ["signal": "\(signal)", "error": "\(error)"]
 				)

Sources/SignalHandling/CStructsInSwift/Signal.swift

@@ -5,6 +5,7 @@ import SystemPackage
 import System
 #endif
 
+import GlobalConfModule
 import Logging
 
 
@@ -53,7 +54,7 @@ public enum SigactionDelayer_Unsig {
 				} catch {
 					for (signal, UnsigactionID) in ret {
 						do    {try unregisterDelayedSigactionOnQueue(UnsigactionID)}
-						catch {SignalHandlingConfig.logger?.error(
+						catch {Conf.logger?.error(
 							"Cannot unregister delayed sigaction for in recovery handler of registerDelayedSigactions. The signal will stay blocked, probably forever.",
 							metadata: ["signal": "\(signal)", "error": "\(error)"]
 						)}
@@ -120,7 +121,7 @@ public enum SigactionDelayer_Unsig {
 
 			func logLogsAndThrowError() throws {
 				for (log, metadata) in errorLogs {
-					SignalHandlingConfig.logger?.error(log, metadata: metadata)
+					Conf.logger?.error(log, metadata: metadata)
 				}
 				if let e = error {
 					throw e
@@ -204,7 +205,7 @@ public enum SigactionDelayer_Unsig {
 				 * We update our original sigaction to the new sigaction.
 				 * Clients should not do that though. */
 				unsigactionedSignal.originalSigaction = oldSigaction
-				SignalHandlingConfig.logger?.warning("sigaction handler modified for an unsigactioned signal; the sigaction has been reset to ignore.", metadata: ["signal": "\(signal)"])
+				Conf.logger?.warning("sigaction handler modified for an unsigactioned signal; the sigaction has been reset to ignore.", metadata: ["signal": "\(signal)"])
 			}
 		} else {
 			let dispatchSourceSignal = DispatchSource.makeSignalSource(signal: signal.rawValue, queue: signalProcessingQueue)
@@ -228,15 +229,15 @@ public enum SigactionDelayer_Unsig {
 		guard var unsigactionedSignal = unsigactionedSignals[id.signal] else {
 			/* We trust our source not to have an internal logic error.
 			 * If the unsigactioned signal is not found, it is because the callee called release twice on the same unsigaction ID. */
-			SignalHandlingConfig.logger?.error("Overrelease of unsigation.", metadata: ["signal": "\(id.signal)"])
+			Conf.logger?.error("Overrelease of unsigation.", metadata: ["signal": "\(id.signal)"])
 			return
 		}
 		assert(!unsigactionedSignal.handlers.isEmpty, "INTERNAL ERROR: unsigactionInfo should never be empty because when it is, the whole unsigactioned signal should be removed.")
 
 		guard unsigactionedSignal.handlers.removeValue(forKey: id) != nil else {
 			/* Same here.
 			 * If the unsigaction ID was not in the unsigactionInfo, it can only be because the callee called release twice on the same ID. */
-			SignalHandlingConfig.logger?.error("Overrelease of unsigation for signal", metadata: ["signal": "\(id.signal)"])
+			Conf.logger?.error("Overrelease of unsigation for signal.", metadata: ["signal": "\(id.signal)"])
 			return
 		}
 
@@ -259,14 +260,14 @@ public enum SigactionDelayer_Unsig {
 
 	/** Must always be called on the `signalProcessingQueue`. */
 	private static func processSignalsOnQueue(signal: Signal, count: UInt) {
-		SignalHandlingConfig.logger?.debug("Processing signals, called from libdispatch.", metadata: ["signal": "\(signal)", "count": "\(count)"])
+		Conf.logger?.debug("Processing signals, called from libdispatch.", metadata: ["signal": "\(signal)", "count": "\(count)"])
 
 		/* Get the original sigaction for the given signal. */
 		guard let unsigactionedSignal = unsigactionedSignals[signal] else {
-			SignalHandlingConfig.logger?.error("INTERNAL ERROR: nil unsigactioned signal.", metadata: ["signal": "\(signal)"])
+			Conf.logger?.error("INTERNAL ERROR: nil unsigactioned signal.", metadata: ["signal": "\(signal)"])
 			return
 		}
-		SignalHandlingConfig.logger?.trace("", metadata: ["signal": "\(signal)", "original-sigaction": "\(unsigactionedSignal.originalSigaction)"])
+		Conf.logger?.trace("", metadata: ["signal": "\(signal)", "original-sigaction": "\(unsigactionedSignal.originalSigaction)"])
 
 		for _ in 0..<count {
 			let group = DispatchGroup()
@@ -280,11 +281,11 @@ public enum SigactionDelayer_Unsig {
 			}
 			group.wait()
 			if runOriginalHandlerFinal {
-				SignalHandlingConfig.logger?.trace("Resending signal.", metadata: ["signal": "\(signal)"])
+				Conf.logger?.trace("Resending signal.", metadata: ["signal": "\(signal)"])
 				do    {try executeOnThread(.send(signal, with: unsigactionedSignal.originalSigaction))}
-				catch {SignalHandlingConfig.logger?.error("Error while resending signal in thread.", metadata: ["signal": "\(signal)", "error": "\(error)"])}
+				catch {Conf.logger?.error("Error while resending signal in thread.", metadata: ["signal": "\(signal)", "error": "\(error)"])}
 			} else {
-				SignalHandlingConfig.logger?.trace("Signal resend skipped.", metadata: ["signal": "\(signal)"])
+				Conf.logger?.trace("Signal resend skipped.", metadata: ["signal": "\(signal)"])
 			}
 		}
 	}