Hide enum, use OID

Author: yim-lee

Sources/DistributedActors/ClusterSystem.swift

@@ -1491,28 +1491,24 @@ public struct ClusterInvocationResultHandler: DistributedTargetInvocationResultH
 
         case .remoteCall(let system, let callID, let channel, let recipient):
             system.log.debug("Result handler, onThrow: \(error)", metadata: ["call/id": "\(callID)"])
+
+            let errorType = type(of: error as Any)
             let reply: RemoteCallReply<_Done>
+
             if let codableError = error as? (Error & Codable) {
-                switch system.settings.remoteCall.codableErrorAllowance {
-                case .custom(let allowedTypes) where errorTypeAllowed(error: error, allowedTypes: allowedTypes):
+                switch system.settings.remoteCall.codableErrorAllowance.underlying {
+                case .custom(let allowedTypeOIDs) where allowedTypeOIDs.contains(ObjectIdentifier(errorType)):
                     reply = .init(callID: callID, error: codableError)
                 case .all: // compiler gets confused if this is grouped together with above
                     reply = .init(callID: callID, error: codableError)
                 default:
-                    reply = .init(callID: callID, error: GenericRemoteCallError(message: "Remote call error of [\(type(of: error as Any))] type occurred"))
+                    reply = .init(callID: callID, error: GenericRemoteCallError(message: "Remote call error of [\(errorType)] type occurred"))
                 }
             } else {
-                reply = .init(callID: callID, error: GenericRemoteCallError(message: "Remote call error of [\(type(of: error as Any))] type occurred"))
+                reply = .init(callID: callID, error: GenericRemoteCallError(message: "Remote call error of [\(errorType)] type occurred"))
             }
             try await channel.writeAndFlush(TransportEnvelope(envelope: Payload(payload: .message(reply)), recipient: recipient))
         }
-
-        func errorTypeAllowed<Err>(error: Err, allowedTypes: [(Error & Codable).Type]) -> Bool {
-            func isErrorOfType<Err, T: Error & Codable>(_ error: Err, _: T.Type) -> Bool {
-                error is T // `is` and `as` don't work with stored type
-            }
-            return allowedTypes.contains { type in isErrorOfType(error, type) }
-        }
     }
 }
 

Sources/DistributedActors/ClusterSystemSettings.swift

@@ -461,17 +461,33 @@ extension ClusterSystemSettings {
         /// Set to `.effectivelyInfinite` to avoid setting a timeout, although this is not recommended.
         public var defaultTimeout: Duration = .seconds(5)
 
-        public var codableErrorAllowance: CodableErrorAllowance = .all
+        public var codableErrorAllowance: CodableErrorAllowanceSettings = .all
+
+        public struct CodableErrorAllowanceSettings {
+            internal enum CodableErrorAllowance {
+                case none
+                case all
+                // OIDs of allowed types
+                case custom(Set<ObjectIdentifier>)
+            }
+
+            internal let underlying: CodableErrorAllowance
+
+            internal init(allowance: CodableErrorAllowance) {
+                self.underlying = allowance
+            }
 
-        public enum CodableErrorAllowance {
             /// All ``Codable`` errors will be converted to ``GenericRemoteCallError``.
-            case none
+            public static let none: CodableErrorAllowanceSettings = .init(allowance: .none)
 
             /// All ``Codable`` errors will be returned as-is.
-            case all
+            public static let all: CodableErrorAllowanceSettings = .init(allowance: .all)
 
             /// Only the indicated ``Codable`` errors are allowed. Others are converted to ``GenericRemoteCallError``.
-            case custom([(Error & Codable).Type])
+            public static func custom(allowedTypes: [(Error & Codable).Type]) -> CodableErrorAllowanceSettings {
+                let oids = allowedTypes.map { ObjectIdentifier($0) }
+                return .init(allowance: .custom(Set(oids)))
+            }
         }
     }
 }

Sources/DistributedActors/Plugins/ClusterSingleton/ClusterSingletonSettings.swift

@@ -41,11 +41,10 @@ public struct ClusterSingletonSettings {
 /// Singleton node allocation strategies.
 public struct AllocationStrategySettings {
     private enum AllocationStrategy {
-        /// Singletons will run on the cluster leader. *All* nodes are potential candidates.
         case byLeadership
     }
 
-    private var allocationStrategy: AllocationStrategy
+    private let allocationStrategy: AllocationStrategy
 
     private init(allocationStrategy: AllocationStrategy) {
         self.allocationStrategy = allocationStrategy
@@ -58,5 +57,6 @@ public struct AllocationStrategySettings {
         }
     }
 
+    /// Singletons will run on the cluster leader. *All* nodes are potential candidates.
     public static let byLeadership: AllocationStrategySettings = .init(allocationStrategy: .byLeadership)
 }

Tests/DistributedActorsTests/RemoteCallTests.swift

@@ -238,12 +238,12 @@ final class RemoteCallTests: ClusteredActorSystemsXCTestCase {
 
     func test_remoteCall_customCodableErrorAllowList_errorInList() async throws {
         let local = await setUpNode("local") { settings in
-            settings.remoteCall.codableErrorAllowance = .custom([GreeterCodableError.self, AnotherGreeterCodableError.self])
+            settings.remoteCall.codableErrorAllowance = .custom(allowedTypes: [GreeterCodableError.self, AnotherGreeterCodableError.self])
             settings.serialization.registerInbound(GreeterCodableError.self)
             settings.serialization.registerInbound(AnotherGreeterCodableError.self)
         }
         let remote = await setUpNode("remote") { settings in
-            settings.remoteCall.codableErrorAllowance = .custom([GreeterCodableError.self, AnotherGreeterCodableError.self])
+            settings.remoteCall.codableErrorAllowance = .custom(allowedTypes: [GreeterCodableError.self, AnotherGreeterCodableError.self])
             settings.serialization.registerInbound(GreeterCodableError.self)
             settings.serialization.registerInbound(AnotherGreeterCodableError.self)
         }
@@ -262,12 +262,12 @@ final class RemoteCallTests: ClusteredActorSystemsXCTestCase {
 
     func test_remoteCall_customCodableErrorAllowList_errorNotInList() async throws {
         let local = await setUpNode("local") { settings in
-            settings.remoteCall.codableErrorAllowance = .custom([AnotherGreeterCodableError.self])
+            settings.remoteCall.codableErrorAllowance = .custom(allowedTypes: [AnotherGreeterCodableError.self])
             settings.serialization.registerInbound(GreeterCodableError.self)
             settings.serialization.registerInbound(AnotherGreeterCodableError.self)
         }
         let remote = await setUpNode("remote") { settings in
-            settings.remoteCall.codableErrorAllowance = .custom([AnotherGreeterCodableError.self])
+            settings.remoteCall.codableErrorAllowance = .custom(allowedTypes: [AnotherGreeterCodableError.self])
             settings.serialization.registerInbound(GreeterCodableError.self)
             settings.serialization.registerInbound(AnotherGreeterCodableError.self)
         }