nodejs · nodejs-github-bot · May 13, 2024 · Apr 14, 2024 · Apr 14, 2024 · Apr 15, 2024
diff --git a/src/env.cc b/src/env.cc
@@ -1092,6 +1092,13 @@ void Environment::InitializeLibuv() {
 void Environment::ExitEnv(StopFlags::Flags flags) {
   // Should not access non-thread-safe methods here.
   set_stopping(true);
+
+#if HAVE_INSPECTOR
+  if (inspector_agent_) {
+    inspector_agent_->StopIfWaitingForConnect();
+  }
+#endif
+
   if ((flags & StopFlags::kDoNotTerminateIsolate) == 0)
     isolate_->TerminateExecution();
   SetImmediateThreadsafe([](Environment* env) {

diff --git a/src/inspector/main_thread_interface.cc b/src/inspector/main_thread_interface.cc
@@ -225,11 +225,20 @@ bool MainThreadInterface::WaitForFrontendEvent() {
   dispatching_messages_ = false;
   if (dispatching_message_queue_.empty()) {
     Mutex::ScopedLock scoped_lock(requests_lock_);
-    while (requests_.empty()) incoming_message_cond_.Wait(scoped_lock);
+    while (!stop_waiting_for_frontend_event_requested_ && requests_.empty()) {
+      incoming_message_cond_.Wait(scoped_lock);
+    }
+    stop_waiting_for_frontend_event_requested_ = false;
   }
   return true;
 }
 
+void MainThreadInterface::StopWaitingForFrontendEvent() {
+  Mutex::ScopedLock scoped_lock(requests_lock_);
+  stop_waiting_for_frontend_event_requested_ = true;
+  incoming_message_cond_.Broadcast(scoped_lock);
+}
+
 void MainThreadInterface::DispatchMessages() {
   if (dispatching_messages_)
     return;

diff --git a/src/inspector/main_thread_interface.h b/src/inspector/main_thread_interface.h
@@ -78,6 +78,7 @@ class MainThreadInterface :
   void DispatchMessages();
   void Post(std::unique_ptr<Request> request);
   bool WaitForFrontendEvent();
+  void StopWaitingForFrontendEvent();
   std::shared_ptr<MainThreadHandle> GetHandle();
   Agent* inspector_agent() {
     return agent_;
@@ -94,6 +95,10 @@ class MainThreadInterface :
   // when we reenter the DispatchMessages function.
   MessageQueue dispatching_message_queue_;
   bool dispatching_messages_ = false;
+  // This flag indicates an internal request to exit the loop in
+  // WaitForFrontendEvent(). It's set to true by calling
+  // StopWaitingForFrontendEvent().
+  bool stop_waiting_for_frontend_event_requested_ = false;
   ConditionVariable incoming_message_cond_;
   // Used from any thread
   Agent* const agent_;

diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
@@ -477,6 +477,20 @@ class NodeInspectorClient : public V8InspectorClient {
     }
   }
 
+  void StopIfWaitingForFrontendEvent() {
+    if (!waiting_for_frontend_) {
+      return;
+    }
+    waiting_for_frontend_ = false;
+    for (const auto& id_channel : channels_) {
+      id_channel.second->unsetWaitingForDebugger();
+    }
+
+    if (interface_) {
+      interface_->StopWaitingForFrontendEvent();
+    }
+  }
+
   int connectFrontend(std::unique_ptr<InspectorSessionDelegate> delegate,
                       bool prevent_shutdown) {
     int session_id = next_session_id_++;
@@ -1017,6 +1031,13 @@ void Agent::WaitForConnect() {
   client_->waitForFrontend();
 }
 
+void Agent::StopIfWaitingForConnect() {
+  if (client_ == nullptr) {
+    return;
+  }
+  client_->StopIfWaitingForFrontendEvent();
+}
+
 std::shared_ptr<WorkerManager> Agent::GetWorkerManager() {
   THROW_IF_INSUFFICIENT_PERMISSIONS(parent_env_,
                                     permission::PermissionScope::kInspector,

diff --git a/src/inspector_agent.h b/src/inspector_agent.h
@@ -61,6 +61,8 @@ class Agent {
 
   // Blocks till frontend connects and sends "runIfWaitingForDebugger"
   void WaitForConnect();
+  void StopIfWaitingForConnect();
+
   // Blocks till all the sessions with "WaitForDisconnectOnShutdown" disconnect
   void WaitForDisconnect();
   void ReportUncaughtException(v8::Local<v8::Value> error,

diff --git a/test/parallel/test-inspector-exit-worker-in-wait-for-connection.mjs b/test/parallel/test-inspector-exit-worker-in-wait-for-connection.mjs
@@ -0,0 +1,21 @@
+// Flags: --inspect=0
+import * as common from '../common/index.mjs';
+common.skipIfInspectorDisabled();
+
+import { isMainThread, Worker } from 'node:worker_threads';
+import { fileURLToPath } from 'node:url';
+import inspector from 'node:inspector';
+
+// Ref: https://github.com/nodejs/node/issues/52467
+// - worker.terminate() should terminate the worker and the pending
+//   inspector.waitForDebugger().
+if (isMainThread) {
+  const worker = new Worker(fileURLToPath(import.meta.url));
+  await new Promise((r) => setTimeout(r, 2_000));
+
+  worker.on('exit', common.mustCall());
+  await worker.terminate();
+} else {
+  inspector.open();
+  inspector.waitForDebugger();
+}
diff --git a/test/parallel/test-inspector-exit-worker-in-wait-for-connection2.mjs b/test/parallel/test-inspector-exit-worker-in-wait-for-connection2.mjs
@@ -0,0 +1,21 @@
+// Flags: --inspect=0
+import * as common from '../common/index.mjs';
+common.skipIfInspectorDisabled();
+
+import { isMainThread, Worker } from 'node:worker_threads';
+import { fileURLToPath } from 'node:url';
+import inspector from 'node:inspector';
+import assert from 'node:assert';
+
+// Ref: https://github.com/nodejs/node/issues/52467
+// - process.exit() should kill the main thread's process.
+if (isMainThread) {
+  new Worker(fileURLToPath(import.meta.url));
+  await new Promise((r) => setTimeout(r, 2_000));
+
+  process.on('exit', (status) => assert.strictEqual(status, 0));
+  process.exit();
+} else {
+  inspector.open();
+  inspector.waitForDebugger();
+}