Improve IPC client disconnected exceptions

Improve clientInvoke exceptions so IPC clients can more reliably detect when
they are calling a remote method after the connection is closed. Before this
change different exceptions were thrown, which made this condition difficult to
detect and handle.

Author: ryanofsky

include/mp/proxy-types.h

@@ -582,9 +582,6 @@ void serverDestroy(Server& server)
 template <typename ProxyClient, typename GetRequest, typename... FieldObjs>
 void clientInvoke(ProxyClient& proxy_client, const GetRequest& get_request, FieldObjs&&... fields)
 {
-    if (!proxy_client.m_context.connection) {
-        throw std::logic_error("clientInvoke call made after disconnect");
-    }
     if (!g_thread_context.waiter) {
         assert(g_thread_context.thread_name.empty());
         g_thread_context.thread_name = ThreadName(proxy_client.m_context.loop->m_exe_name);
@@ -606,7 +603,16 @@ void clientInvoke(ProxyClient& proxy_client, const GetRequest& get_request, Fiel
     std::exception_ptr exception;
     std::string kj_exception;
     bool done = false;
+    const char* disconnected = nullptr;
     proxy_client.m_context.loop->sync([&]() {
+        if (!proxy_client.m_context.connection) {
+            const std::unique_lock<std::mutex> lock(invoke_context.thread_context.waiter->m_mutex);
+            done = true;
+            disconnected = "IPC client method called after disconnect.";
+            invoke_context.thread_context.waiter->m_cv.notify_all();
+            return;
+        }
+
         auto request = (proxy_client.m_client.*get_request)(nullptr);
         using Request = CapRequestTraits<decltype(request)>;
         using FieldList = typename ProxyClientMethodTraits<typename Request::Params>::Fields;
@@ -631,9 +637,13 @@ void clientInvoke(ProxyClient& proxy_client, const GetRequest& get_request, Fiel
                 invoke_context.thread_context.waiter->m_cv.notify_all();
             },
             [&](const ::kj::Exception& e) {
-                kj_exception = kj::str("kj::Exception: ", e).cStr();
-                proxy_client.m_context.loop->logPlain()
-                    << "{" << invoke_context.thread_context.thread_name << "} IPC client exception " << kj_exception;
+                if (e.getType() == ::kj::Exception::Type::DISCONNECTED) {
+                    disconnected = "IPC client method call interrupted by disconnect.";
+                } else {
+                    kj_exception = kj::str("kj::Exception: ", e).cStr();
+                    proxy_client.m_context.loop->logPlain()
+                        << "{" << invoke_context.thread_context.thread_name << "} IPC client exception " << kj_exception;
+                }
                 const std::unique_lock<std::mutex> lock(invoke_context.thread_context.waiter->m_mutex);
                 done = true;
                 invoke_context.thread_context.waiter->m_cv.notify_all();
@@ -644,6 +654,7 @@ void clientInvoke(ProxyClient& proxy_client, const GetRequest& get_request, Fiel
     invoke_context.thread_context.waiter->wait(lock, [&done]() { return done; });
     if (exception) std::rethrow_exception(exception);
     if (!kj_exception.empty()) proxy_client.m_context.loop->raise() << kj_exception;
+    if (disconnected) proxy_client.m_context.loop->raise() << disconnected;
 }
 
 //! Invoke callable `fn()` that may return void. If it does return void, replace

test/mp/test/test.cpp

@@ -35,7 +35,7 @@ namespace test {
  * object destroys the client Connection object. Normally it makes sense for
  * this to be true to simplify shutdown and avoid needing to call
  * client_disconnect manually, but false allows testing more ProxyClient
- * behavior and the "clientInvoke call made after disconnect" code path.
+ * behavior and the "IPC client method called after disconnect" code path.
  */
 class TestSetup
 {
@@ -189,8 +189,8 @@ KJ_TEST("Call IPC method after client connection is closed")
     bool disconnected{false};
     try {
         foo->add(1, 2);
-    } catch (const std::logic_error& e) {
-        KJ_EXPECT(std::string_view{e.what()} == "clientInvoke call made after disconnect");
+    } catch (const std::runtime_error& e) {
+        KJ_EXPECT(std::string_view{e.what()} == "IPC client method called after disconnect.");
         disconnected = true;
     }
     KJ_EXPECT(disconnected);
@@ -207,9 +207,7 @@ KJ_TEST("Calling IPC method after server connection is closed")
     try {
         foo->add(1, 2);
     } catch (const std::runtime_error& e) {
-        std::string_view error{e.what()};
-        KJ_EXPECT(error.starts_with("kj::Exception: "));
-        KJ_EXPECT(error.find("disconnected: Peer disconnected.") != std::string_view::npos);
+        KJ_EXPECT(std::string_view{e.what()} == "IPC client method call interrupted by disconnect.");
         disconnected = true;
     }
     KJ_EXPECT(disconnected);