The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
//! Stopping a run on Windows ends the whole launched tree: the kernel job over the
//! launch reaches what a launcher started even when the launcher exited first (where a
//! `taskkill /T /F` from the tracked pid no longer finds the orphan), and the run only
//! reports its exit once the port the tree held is free again.
#![cfg(windows)]
use ide_core::{IdeEvent, RunId, SharedSink};
use ide_run::{OutputChunk, ProcessManager, RunConfig, StartOptions};
use parking_lot::Mutex;
use std::collections::BTreeMap;
use std::net::TcpListener;
use std::sync::Arc;
use std::sync::mpsc::{self, Receiver};
use std::time::{Duration, Instant};
static CONSOLE: Mutex<Vec<String>> = Mutex::new(Vec::new());
fn channel_sink() -> (SharedSink, Receiver<IdeEvent>) {
let (tx, events) = mpsc::channel();
let tx = Mutex::new(tx);
let sink: SharedSink = Arc::new(move |e: IdeEvent| {
let _ = tx.lock().send(e);
});
(sink, events)
}
fn capture_output() -> Box<dyn Fn(OutputChunk) + Send + Sync> {
Box::new(move |chunk: OutputChunk| {
let text = match &chunk {
OutputChunk::Stdout { text } | OutputChunk::Stderr { text } | OutputChunk::System { text } => text,
};
CONSOLE.lock().push(text.clone());
})
}
fn console_log() -> String {
CONSOLE.lock().join("")
}
fn wait_for(what: &str, mut ready: impl FnMut() -> bool) {
let deadline = Instant::now() + Duration::from_secs(60);
while !ready() {
assert!(Instant::now() < deadline, "timed out waiting for {what}; console:\n{}", console_log());
std::thread::sleep(Duration::from_millis(50));
}
}
fn wait_exit(events: &Receiver<IdeEvent>, id: RunId, timeout: Duration) -> Option<i32> {
let deadline = Instant::now() + timeout;
loop {
let left = deadline.saturating_duration_since(Instant::now());
match events.recv_timeout(left).expect("RunExited event") {
IdeEvent::RunExited { run, code } if run == id => return code,
_ => {}
}
}
}
/// A program that binds a port and holds it, like a Spring Boot JVM: the `mvn`-starts-a-JVM
/// shape. PowerShell is the one interpreter every Windows runner has.
fn port_holder(dir: &std::path::Path) -> String {
let script = dir.join("hold-port.ps1");
std::fs::write(
&script,
"$l = [System.Net.Sockets.TcpListener]::new([System.Net.IPAddress]::Loopback, 0)\n\
$l.Start()\n\
Set-Content -Path $args[0] -Value $l.LocalEndpoint.Port\n\
Start-Sleep -Seconds 300\n",
)
.unwrap();
let port_file = dir.join("port");
// Unquoted exe: under `start /B` a quoted first token would be the window title, and
// the path has no spaces anyway.
format!(
"%SystemRoot%\\System32\\WindowsPowerShell\\v1.0\\powershell.exe -NoProfile -ExecutionPolicy \
Bypass -File \"{}\" \"{}\"",
script.display(),
port_file.display()
)
}
fn config(line: &str) -> RunConfig {
RunConfig {
id: "boot".into(),
name: "boot".into(),
kind: "shell".into(),
// A shell line, as a run configuration holds one: it runs through `cmd /D /S /C`,
// which parses the line itself (the CRT quoting of separate args would mangle it).
command: line.to_owned(),
args: Vec::new(),
cwd: None,
env: BTreeMap::new(),
detected: false,
is_test: false,
debug_adapter: None,
allow_parallel: false,
extras: Default::default(),
}
}
fn holder_port(dir: &std::path::Path) -> u16 {
wait_for("the holder's port", || std::fs::metadata(dir.join("port")).is_ok());
std::fs::read_to_string(dir.join("port")).unwrap().trim().parse().unwrap()
}
#[test]
fn a_stop_reaches_the_tree_a_dead_launcher_left_behind() {
let tmp = tempfile::tempdir().unwrap();
let (sink, events) = channel_sink();
let pm = ProcessManager::new();
let holder = port_holder(tmp.path());
// `start /B` detaches the holder from cmd's lifetime: cmd exits at once, the holder
// keeps its port, and the run reports its exit while the port is still taken.
let line = format!("start /B {}", holder);
let info = pm.start(tmp.path(), &config(&line), &StartOptions::default(), sink, capture_output()).expect("start");
let port = holder_port(tmp.path());
// The launcher exited on its own; the run is over, but the holder it started lives.
let code = wait_exit(&events, info.id, Duration::from_secs(30));
assert_eq!(code, Some(0), "cmd exited by itself; console:\n{}", console_log());
// Stop must still reach what it started: this is the reported bug, a port the next
// start cannot bind because the launcher's orphan holds it.
pm.stop(info.id).unwrap();
wait_for("the holder's port to be free", || TcpListener::bind(("127.0.0.1", port)).is_ok());
}
#[test]
fn a_stop_kills_a_launch_whose_launcher_is_still_up() {
let tmp = tempfile::tempdir().unwrap();
let (sink, events) = channel_sink();
let pm = ProcessManager::new();
let holder = port_holder(tmp.path());
let info = pm.start(tmp.path(), &config(&holder), &StartOptions::default(), sink, capture_output()).expect("start");
let port = holder_port(tmp.path());
pm.stop(info.id).unwrap();
// The run is only finished once the tree is gone, so the port is free by the time the
// console reports the exit and the next start can bind it.
let code = wait_exit(&events, info.id, Duration::from_secs(30));
assert_eq!(code, Some(1), "the job's termination exit code; console:\n{}", console_log());
wait_for("the holder's port to be free", || TcpListener::bind(("127.0.0.1", port)).is_ok());
}
/// The reported shape itself: `cmd` starting a JVM that holds its port (a Spring Boot run
/// or debug launch). Runs where a JDK is installed (CI's Windows runners have one).
#[test]
fn a_stop_kills_the_jvm_a_launcher_started() {
let Some(javac) = which_javac() else {
eprintln!("skipped: no javac on this machine");
return;
};
let tmp = tempfile::tempdir().unwrap();
std::fs::write(
tmp.path().join("HoldPort.java"),
"import java.net.ServerSocket;\n\
public class HoldPort {\n\
public static void main(String[] args) throws Exception {\n\
ServerSocket server = new ServerSocket(Integer.parseInt(args[0]), 1, java.net.InetAddress.getByName(\"127.0.0.1\"));\n\
System.out.println(\"listening\");\n\
System.out.flush();\n\
Thread.sleep(Long.MAX_VALUE);\n\
}\n\
}\n",
)
.unwrap();
let status = std::process::Command::new(javac)
.args(["-d", &tmp.path().display().to_string(), &tmp.path().join("HoldPort.java").display().to_string()])
.stdout(std::process::Stdio::null())
.status()
.expect("javac runs");
assert!(status.success(), "the holder compiles; console:\n{}", console_log());
// A free port chosen by this process, handed to the JVM.
let port = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap().local_addr().unwrap().port();
let (sink, events) = channel_sink();
let pm = ProcessManager::new();
let line = format!("java -cp \"{}\" HoldPort {port}", tmp.path().display());
let info = pm.start(tmp.path(), &config(&line), &StartOptions::default(), sink, capture_output()).expect("start");
// The JVM is cmd's child and announces itself on the run's console.
wait_for("the JVM to listen", || std::net::TcpStream::connect(("127.0.0.1", port)).is_ok());
pm.stop(info.id).unwrap();
wait_exit(&events, info.id, Duration::from_secs(30));
wait_for("the JVM's port to be free", || TcpListener::bind(("127.0.0.1", port)).is_ok());
}
/// `javac` as the run would resolve it: on the process's PATH.
fn which_javac() -> Option<std::path::PathBuf> {
let path = std::env::var_os("PATH")?;
ide_run::which::find_executable("javac", &path)
}