diff --git a/crates/ide-dap/src/lib.rs b/crates/ide-dap/src/lib.rs index 4593293ed..c436cb616 100644 --- a/crates/ide-dap/src/lib.rs +++ b/crates/ide-dap/src/lib.rs @@ -1244,11 +1244,18 @@ impl DebugManager { // rdbg's terminate exits the Ruby process without terminating its children. let graceful = terminate && s.request == "launch" && s.adapter != "rdbg" && s.supports("supportsTerminateRequest"); + // A program suspended in the debugger cannot act on SIGTERM, and on macOS not even die of + // SIGKILL while the debugger holds it: it is killed (with what it started) and the adapter + // is told to end it. A killed program has no shutdown output to wait for. + let killed = own_terminate && !graceful && s.suspended.get(); + if killed { + crate::session::signal_debuggee(s, true).await; + } if !s.conn.is_closed() { if graceful { let _ = s.conn.request_timeout("terminate", json!({ "restart": false }), SHUTDOWN_TIMEOUT).await; } - if !graceful && !own_terminate { + if !graceful && (!own_terminate || killed) { let _ = s .conn .request_timeout( @@ -1259,7 +1266,7 @@ impl DebugManager { .await; } } - if own_terminate && !graceful { + if own_terminate && !graceful && !killed { // Signal before anything else: waiting on a request the adapter may not answer // would delay the shutdown the console is supposed to show. crate::session::signal_debuggee(s, false).await; @@ -1278,7 +1285,7 @@ impl DebugManager { // lets Run start again into an occupied port, so wait for the program first — with the // connection still open, so a second Stop can find the session and kill it. crate::session::wait_for_debuggee(s, terminate).await; - if terminate && s.request == "launch" { + if terminate && s.request == "launch" && !killed { // The adapter reports `terminated` only after it has drained the program's console // (java-debug waits up to 5 s for the pump): closing before that drops the last // shutdown lines from the console. diff --git a/crates/ide-dap/src/tests.rs b/crates/ide-dap/src/tests.rs index c43ac5cab..ec578d4d5 100644 --- a/crates/ide-dap/src/tests.rs +++ b/crates/ide-dap/src/tests.rs @@ -527,6 +527,14 @@ async fn fake_adapter(stream } } "disconnect" => { + // Like Delve: the adapter ends the program it launched. + #[cfg(unix)] + if msg["arguments"]["terminateDebuggee"] == true + && let Some(pid) = script.debuggee_pid + { + // SAFETY: plain syscall on the test's own child process. + unsafe { libc::kill(pid as i32, libc::SIGKILL) }; + } ok!(msg, Value::Null); let _ = w.lock().await.shutdown().await; break; @@ -2319,6 +2327,44 @@ async fn stop_waits_for_the_launched_program_to_exit() { h.wait_event(|e| matches!(e, DebugEvent::Terminated)).await; } +/// Delve and other adapters without `terminate`: a program stopped at a breakpoint cannot +/// handle the SIGTERM Stop sends, so Stop has the adapter end it instead of waiting out the grace period. +#[cfg(unix)] +#[tokio::test] +async fn stop_kills_a_program_suspended_at_a_breakpoint_at_once() { + let mut child = std::process::Command::new("python3") + .args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(30)"]) + .spawn() + .unwrap(); + let pid = child.id(); + let exited = Arc::new(AtomicBool::new(false)); + { + let exited = exited.clone(); + std::thread::spawn(move || { + let _ = child.wait(); + exited.store(true, Ordering::Release); + }); + } + let h = harness(Script { debuggee_pid: Some(pid), supports_terminate: false, ..Default::default() }); + let id = h.start(config()).await.unwrap(); + h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await; + let session = h.manager.session(id).unwrap(); + while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid) { + tokio::time::sleep(Duration::from_millis(10)).await; + } + tokio::time::sleep(Duration::from_millis(200)).await; // let the program install its trap + let started = Instant::now(); + h.manager.stop(id).await.unwrap(); + let elapsed = started.elapsed(); + assert!(elapsed < Duration::from_secs(3), "stop waited {elapsed:?} for a suspended program"); + assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], true); + let deadline = Instant::now() + Duration::from_secs(2); + while !exited.load(Ordering::Acquire) { + assert!(Instant::now() < deadline, "the suspended program was left running"); + tokio::time::sleep(Duration::from_millis(10)).await; + } +} + #[cfg(unix)] #[tokio::test] async fn a_second_stop_kills_the_program_instead_of_waiting() {