debugger: fix stuck debugger when debuggee exits

lib/_debug_agent.js

@@ -36,6 +36,10 @@ exports.start = function start() {
       process.removeListener('SIGWINCH', fn);
     });
 
+    // Disconnect all currently connected clients.
+    // Without this, the debugger agent loop will not unblock
+    // and the debuggee will get stuck.
+    agent.destroyAllClients();
     agent.close();
   };
 
@@ -81,6 +85,12 @@ Agent.prototype.notifyWait = function notifyWait() {
   this.first = false;
 };
 
+Agent.prototype.destroyAllClients = function destroyAllClients() {
+  this.clients.forEach(function(client) {
+    client.destroy();
+  });
+};
+
 function Client(agent, socket) {
   Transform.call(this, {
     readableObjectMode: true

src/debug-agent.cc

@@ -128,6 +128,11 @@ void Agent::Enable() {
   parent_env()->AssignToContext(debug_context);
 }
 
+static void close_handle(uv_handle_t* handle, void* data) {
+  if (!uv_is_closing(handle)) {
+    uv_close(handle, nullptr);
+  }
+}
 
 void Agent::Stop() {
   int err;
@@ -149,6 +154,9 @@ void Agent::Stop() {
   CHECK_EQ(err, 0);
 
   uv_close(reinterpret_cast<uv_handle_t*>(&child_signal_), nullptr);
+  // Close all remaining handles:
+  // uv_loop_close will return UV_EBUSY for handles which are not closed.
+  uv_walk(&child_loop_, close_handle, nullptr);
   uv_run(&child_loop_, UV_RUN_NOWAIT);
 
   err = uv_loop_close(&child_loop_);

test/fixtures/debugger-stuck-regression-fixture.js

@@ -0,0 +1,2 @@
+'use strict';
+console.log('debug');

test/parallel/test-debugger-stuck-regression.js

@@ -0,0 +1,93 @@
+'use strict';
+const path = require('path');
+const spawn = require('child_process').spawn;
+const assert = require('assert');
+
+const common = require('../common');
+
+const fixture = path.join(
+  common.fixturesDir,
+  'debugger-stuck-regression-fixture.js'
+);
+
+const args = [
+  'debug',
+  `--port=${common.PORT}`,
+  fixture
+];
+
+const TEST_TIMEOUT_MS = common.platformTimeout(4000);
+
+function onTestTimeout() {
+  common.fail('The debuggee did not terminate.');
+}
+
+const testTimeout = setTimeout(onTestTimeout, TEST_TIMEOUT_MS);
+
+const proc = spawn(process.execPath, args, { stdio: 'pipe' });
+proc.stdout.setEncoding('utf8');
+proc.stderr.setEncoding('utf8');
+
+const STATE_WAIT_BREAK = 0;
+const STATE_WAIT_PROC_TERMINATED = 1;
+const STATE_EXIT = 2;
+
+let stdout = '';
+let stderr = '';
+let state = 0;
+let cycles = 2;
+
+proc.stdout.on('data', (data) => {
+  stdout += data;
+
+  switch (state) {
+    case STATE_WAIT_BREAK:
+      // check if the debugger stopped at line 1
+      if (stdout.includes('> 1')) {
+        stdout = '';
+
+        // send continue to the debugger
+        proc.stdin.write('c\n');
+        state = STATE_WAIT_PROC_TERMINATED;
+      }
+      break;
+    case STATE_WAIT_PROC_TERMINATED:
+      // check if the debuggee has terminated
+      if (stdout.includes('program terminated')) {
+        stdout = '';
+
+        // If cycles is greater than 0,
+        // we re-run the debuggee.
+        // Otherwise exit the debugger.
+        if (cycles > 0) {
+          --cycles;
+          state = STATE_WAIT_BREAK;
+          proc.stdin.write('run\n');
+        } else {
+          // cancel the test timeout
+          clearTimeout(testTimeout);
+          state = STATE_EXIT;
+          proc.stdin.write('.exit\n');
+        }
+
+      }
+      break;
+    case STATE_EXIT:
+      // fall through
+    default:
+      break;
+  }
+});
+
+proc.stderr.on('data', (data) => {
+  stderr += data;
+});
+
+proc.stdin.on('error', (err) => {
+  console.error(err);
+});
+
+process.on('exit', (code) => {
+  assert.equal(code, 0, 'the program should exit cleanly');
+  assert.equal(stderr, '', 'stderr should be empty');
+});