[Distributed] Don't hang, but throw when target accessor not found

Author: ktoso

stdlib/public/Distributed/DistributedActor.cpp

@@ -109,6 +109,11 @@ static void swift_distributed_execute_target_resume(
   return resumeInParent(parentCtx, error);
 }
 
+SWIFT_CC(swift)
+SWIFT_EXPORT_FROM(swiftDistributed)
+SwiftError* swift_distributed_makeDistributedTargetAccessorNotFoundError(
+    const char *targetNameStart, size_t targetNameLength);
+
 SWIFT_CC(swiftasync)
 void swift_distributed_execute_target(
     SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
@@ -124,8 +129,12 @@ void swift_distributed_execute_target(
     void **decoderWitnessTable) {
   auto *accessor = findDistributedAccessor(targetNameStart, targetNameLength);
   if (!accessor) {
-    assert(false && "no distributed accessor");
-    return; // FIXME(distributed): return -1 here so the lib can fail the call
+    SwiftError *error =
+        swift_distributed_makeDistributedTargetAccessorNotFoundError(targetNameStart, targetNameLength);
+    auto resumeInParent =
+        reinterpret_cast<TargetExecutorSignature::ContinuationType *>(
+            callerContext->ResumeParent);
+    return resumeInParent(callerContext, error);
   }
 
   auto *asyncFnPtr = reinterpret_cast<

stdlib/public/Distributed/DistributedMetadata.swift

@@ -108,3 +108,14 @@ func _getWitnessTablesFor(
   environment: UnsafeRawPointer,
   genericArguments: UnsafeRawPointer
 ) -> (UnsafeRawPointer, Int)
+
+@available(SwiftStdlib 5.7, *)
+@_silgen_name("swift_distributed_makeDistributedTargetAccessorNotFoundError")
+public // SPI Distributed
+func _makeDistributedTargetAccessorNotFoundError(
+  _ targetNameStart: UnsafePointer<UInt8>,
+  _ targetNameLength: UInt
+) -> Error {
+  let name = String(decodingCString: targetNameStart, as: Unicode.UTF8.self)
+  return ExecuteDistributedTargetError(message: "Could not find distributed accessor for target \(name)")
+}

test/Distributed/Runtime/distributed_actor_func_calls_remoteCall_bad_targets.swift

@@ -0,0 +1,71 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend-emit-module -emit-module-path %t/FakeDistributedActorSystems.swiftmodule -module-name FakeDistributedActorSystems -disable-availability-checking %S/../Inputs/FakeDistributedActorSystems.swift
+// RUN: %target-build-swift -module-name main -Xfrontend -disable-availability-checking -j2 -parse-as-library -I %t %s %S/../Inputs/FakeDistributedActorSystems.swift -o %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s --color
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: distributed
+
+// rdar://76038845
+// UNSUPPORTED: use_os_stdlib
+// UNSUPPORTED: back_deployment_runtime
+
+// FIXME(distributed): Distributed actors currently have some issues on windows, isRemote always returns false. rdar://82593574
+// UNSUPPORTED: OS=windows-msvc
+
+import Distributed
+import FakeDistributedActorSystems
+
+typealias DefaultDistributedActorSystem = FakeRoundtripActorSystem
+
+distributed actor Greeter {
+  distributed func greet(name: String) -> String {
+      "Hello, \(name)!"
+  }
+}
+
+func test() async throws {
+  let system = DefaultDistributedActorSystem()
+  let local = Greeter(actorSystem: system)
+  let ref = try Greeter.resolve(id: local.id, using: system)
+
+  // Make sure normal call works ok:
+  let greeting = try await ref.greet(name: "Caplin")
+  print("\(greeting)")
+  // CHECK: Hello, Caplin!
+
+  let correctTargetIdentifier = "$s4main7GreeterC5greet4nameS2S_tYaKFTE"
+  _ = correctTargetIdentifier
+  let badModuleTargetIdentifier = "$s9BADMODULE7GreeterC5greet4nameS2S_tYaKFTE"
+  // the BADMODULE is a bad module, and we won't be able to find the distributed accessor
+  // this should result in a failed call, but not hang the call.
+
+  var invocation = Greeter.ActorSystem.InvocationEncoder()
+  invocation.arguments = ["BadCall"]
+  invocation.returnType = String.self
+
+  let badTarget = RemoteCallTarget(badModuleTargetIdentifier)
+
+  do {
+    // CHECK: >> remoteCall: on:main.Greeter, target:BADMODULE.Greeter.greet(name:)
+    let call = try await system.remoteCall(
+      on: local,
+      target: badTarget,
+      invocation: &invocation,
+      throwing: Never.self,
+      returning: String.self
+    )
+  } catch {
+    // CHECK: << onThrow: ExecuteDistributedTargetError(message: "Could not find distributed accessor for target $s9BADMODULE7GreeterC5greet4nameS2S_tYaKFTE")
+    // CHECK: << remoteCall throw: ExecuteDistributedTargetError(message: "Could not find distributed accessor for target $s9BADMODULE7GreeterC5greet4nameS2S_tYaKFTE")
+    print("caught error: \(error)")
+    // CHECK: caught error: ExecuteDistributedTargetError(message: "Could not find distributed accessor for target $s9BADMODULE7GreeterC5greet4nameS2S_tYaKFTE")
+  }
+}
+
+@main struct Main {
+  static func main() async {
+    try! await test()
+  }
+}