inspector: supported NodeRuntime domain in worker

NodeRuntime domain was introduced to give inspector client way to
fetch captured information before Node process is gone. We need
similar capability for work.
With current protocol inspector client can force worker to wait
on start by passing waitForDebuggerOnStart flag to NodeWorker.enable
method. So client has some time to setup environment, e.g. start
profiler. At the same time there is no way to prevent worker from
being terminated. So we can start capturing profile but we can not
reliably get captured data back.
This PR implemented NodeRuntime.notifyWhenWaitingForDisconnect
method for worker. When NodeRuntime.waitingForDisconnect notification
is enabled, worker will wait for explicit NodeWorker.detach call.
With this PR worker tooling story is nicely aligned with main thread
tooling story. The only difference is that main thread by default is
waiting for disconnect but worker thread is not waiting.
Issue: #27677
PR-URL: #27706
Reviewed-By: Eugene Ostroukhov <eostroukhov@google.com>

Author: alexkozy

src/inspector/node_protocol.pdl

@@ -71,6 +71,11 @@ experimental domain NodeWorker
  # Detaches from all running workers and disables attaching to new workers as they are started.
  command disable
 
+ # Detached from the worker with given sessionId.
+ command detach
+ parameters
+ SessionID sessionId
+
  # Issued when attached to a worker.
  event attachedToWorker
  parameters

src/inspector/runtime_agent.cc

@@ -16,10 +16,6 @@ void RuntimeAgent::Wire(UberDispatcher* dispatcher) {
 }
 
 DispatchResponse RuntimeAgent::notifyWhenWaitingForDisconnect(bool enabled) {
-if (!env_->owns_process_state()) {
-returnDispatchResponse::Error(
-"NodeRuntime domain can only be used through main thread sessions");
- }
  notify_when_waiting_for_disconnect_ = enabled;
 returnDispatchResponse::OK();
 }

src/inspector/worker_agent.cc

@@ -115,6 +115,11 @@ DispatchResponse WorkerAgent::disable() {
 returnDispatchResponse::OK();
 }
 
+DispatchResponse WorkerAgent::detach(const String& sessionId) {
+ workers_->Detached(sessionId);
+returnDispatchResponse::OK();
+}
+
 voidNodeWorkers::WorkerCreated(const std::string& title,
 const std::string& url,
 bool waiting,

src/inspector/worker_agent.h

@@ -25,6 +25,7 @@ class WorkerAgent : public NodeWorker::Backend {
 
  DispatchResponse enable(bool waitForDebuggerOnStart) override;
  DispatchResponse disable() override;
+ DispatchResponse detach(const String& sessionId) override;
 
 private:
  std::shared_ptr<NodeWorker::Frontend> frontend_;

src/inspector_agent.cc

@@ -472,8 +472,8 @@ class NodeInspectorClient : public V8InspectorClient {
 runMessageLoop();
  }
 
-voidwaitForIoShutdown() {
-waiting_for_io_shutdown_ = true;
+voidwaitForSessionsDisconnect() {
+waiting_for_sessions_disconnect_ = true;
 runMessageLoop();
  }
 
@@ -548,6 +548,8 @@ class NodeInspectorClient : public V8InspectorClient {
  }
 contextDestroyed(env_->context());
  }
+if (waiting_for_sessions_disconnect_ && !is_main_)
+ waiting_for_sessions_disconnect_ = false;
  }
 
 voiddispatchMessageFromFrontend(int session_id, const StringView& message) {
@@ -678,8 +680,9 @@ class NodeInspectorClient : public V8InspectorClient {
 boolshouldRunMessageLoop() {
 if (waiting_for_frontend_)
 returntrue;
-if (waiting_for_io_shutdown_ || waiting_for_resume_)
+if (waiting_for_sessions_disconnect_ || waiting_for_resume_) {
 returnhasConnectedSessions();
+ }
 returnfalse;
  }
 
@@ -723,7 +726,7 @@ class NodeInspectorClient : public V8InspectorClient {
 int next_session_id_ = 1;
 bool waiting_for_resume_ = false;
 bool waiting_for_frontend_ = false;
-boolwaiting_for_io_shutdown_ = false;
+boolwaiting_for_sessions_disconnect_ = false;
 // Allows accessing Inspector from non-main threads
  std::unique_ptr<MainThreadInterface> interface_;
  std::shared_ptr<WorkerManager> worker_manager_;
@@ -819,11 +822,14 @@ void Agent::WaitForDisconnect() {
 fprintf(stderr, "Waiting for the debugger to disconnect...\n");
 fflush(stderr);
  }
-if (!client_->notifyWaitingForDisconnect())
+if (!client_->notifyWaitingForDisconnect()) {
  client_->contextDestroyed(parent_env_->context());
+ } elseif (is_worker) {
+ client_->waitForSessionsDisconnect();
+ }
 if (io_ != nullptr) {
  io_->StopAcceptingNewConnections();
- client_->waitForIoShutdown();
+ client_->waitForSessionsDisconnect();
  }
 }
 

test/parallel/test-worker-debug.js

@@ -206,6 +206,52 @@ async function testTwoWorkers(session, post) {
 awaitPromise.all([worker1Exited,worker2Exited]);
 }
 
+asyncfunctiontestWaitForDisconnectInWorker(session,post){
+console.log('Test NodeRuntime.waitForDisconnect in worker');
+
+constsessionWithoutWaiting=newSession();
+sessionWithoutWaiting.connect();
+constsessionWithoutWaitingPost=doPost.bind(null,sessionWithoutWaiting);
+
+awaitsessionWithoutWaitingPost('NodeWorker.enable',{
+waitForDebuggerOnStart: true
+});
+awaitpost('NodeWorker.enable',{waitForDebuggerOnStart: true});
+
+constattached=[
+waitForWorkerAttach(session),
+waitForWorkerAttach(sessionWithoutWaiting)
+];
+
+letworker=null;
+constexitPromise=runWorker(2,(w)=>worker=w);
+
+const[{sessionId: sessionId1},{sessionId: sessionId2}]=
+awaitPromise.all(attached);
+
+constworkerSession1=newWorkerSession(session,sessionId1);
+constworkerSession2=newWorkerSession(sessionWithoutWaiting,sessionId2);
+
+awaitworkerSession2.post('Runtime.enable');
+awaitworkerSession1.post('Runtime.enable');
+awaitworkerSession1.post('NodeRuntime.notifyWhenWaitingForDisconnect',{
+enabled: true
+});
+awaitworkerSession1.post('Runtime.runIfWaitingForDebugger');
+
+worker.postMessage('resume');
+
+awaitwaitForEvent(workerSession1,'NodeRuntime.waitingForDisconnect');
+post('NodeWorker.detach',{sessionId: sessionId1});
+awaitwaitForEvent(workerSession2,'Runtime.executionContextDestroyed');
+
+awaitexitPromise;
+
+awaitpost('NodeWorker.disable');
+awaitsessionWithoutWaitingPost('NodeWorker.disable');
+sessionWithoutWaiting.disconnect();
+}
+
 asyncfunctiontest(){
 constsession=newSession();
 session.connect();
@@ -219,6 +265,7 @@ async function test() {
 
 awaittestNoWaitOnStart(session,post);
 awaittestTwoWorkers(session,post);
+awaittestWaitForDisconnectInWorker(session,post);
 
 session.disconnect();
 console.log('Test done');