use ctrl-break for process groups

Author: adamspofford-dfinity

Cargo.lock

@@ -65,14 +65,17 @@ assert_cmd = "2"
 camino-tempfile = "1"
 indoc.workspace = true
 icp = { workspace = true }
-nix = { version = "0.30.1", features = ["process", "signal"] }
 predicates = "3"
 rand.workspace = true
+send_ctrlc = "0.6"
 serde_yaml.workspace = true
 serial_test = { version = "3.2.0", features = ["file_locks"] }
 test-tag = "0.1"
 uuid.workspace = true
 
+[target.'cfg(unix)'.dev-dependencies]
+nix = { version = "0.30.1", features = ["process", "signal"] }
+
 [lints]
 workspace = true
 

crates/icp-cli/Cargo.toml

@@ -255,7 +255,8 @@ impl TestContext {
         }
         let watcher =
             wait_for_launcher_status(&launcher_dir).expect("Failed to watch launcher status");
-        let child = cmd.spawn().expect("failed to spawn launcher");
+        let guard = ChildGuard::spawn(&mut cmd).expect("Failed to spawn network launcher");
+        let child = &guard.child;
         let launcher_pid = child.id();
 
         // Wait for port file using the function from icp-network
@@ -315,8 +316,7 @@ impl TestContext {
                     .unwrap(),
             )
             .expect("Gateway URL should not be already initialized");
-        // Wrap child in ChildGuard
-        ChildGuard { child }
+        guard
     }
 
     pub(crate) fn ping_until_healthy(&self, project_dir: &Path, name: &str) {

crates/icp-cli/tests/common/context.rs

@@ -1,13 +1,14 @@
 #![allow(dead_code)]
 
-use std::process::{Child, Command};
+use std::process::Command;
 
 use httptest::{Expectation, Server, matchers::*, responders::*};
 
 pub(crate) mod clients;
 mod context;
 
 pub(crate) use context::TestContext;
+use send_ctrlc::{InterruptibleChild, InterruptibleCommand};
 
 #[cfg(unix)]
 pub(crate) const PATH_SEPARATOR: &str = ":";
@@ -79,7 +80,7 @@ pub(crate) struct TestNetwork {
 }
 
 pub(crate) struct ChildGuard {
-    child: Child,
+    child: InterruptibleChild,
 }
 
 impl ChildGuard {
@@ -89,7 +90,12 @@ impl ChildGuard {
             use std::os::unix::process::CommandExt;
             cmd.process_group(0);
         }
-        let child = cmd.spawn()?;
+        #[cfg(windows)]
+        {
+            use std::os::windows::process::CommandExt;
+            cmd.creation_flags(0x00000200); // CREATE_NEW_PROCESS_GROUP
+        }
+        let child = cmd.spawn_interruptible()?;
         Ok(Self { child })
     }
 
@@ -105,6 +111,13 @@ impl ChildGuard {
             // Give the process some time to shut down gracefully
             std::thread::sleep(std::time::Duration::from_secs(2));
         }
+        #[cfg(windows)]
+        {
+            use send_ctrlc::Interruptible;
+            _ = self.child.terminate(); // CTRL_BREAK_EVENT, required to target process group
+            // Give the process some time to shut down gracefully
+            std::thread::sleep(std::time::Duration::from_secs(2));
+        }
     }
 }
 

crates/icp-cli/tests/common/mod.rs

@@ -345,13 +345,13 @@ fn safe_eprintln(msg: &str) {
 async fn wait_for_shutdown(guard: &mut ShutdownGuard) -> ShutdownReason {
     match guard {
         ShutdownGuard::Container(_) => {
-            _ = ctrl_c().await;
+            stop_signal().await;
             safe_eprintln("Received Ctrl-C, shutting down PocketIC...");
             ShutdownReason::CtrlC
         }
         ShutdownGuard::Process(child) => {
             select!(
-                _ = ctrl_c() => {
+                _ = stop_signal() => {
                     safe_eprintln("Received Ctrl-C, shutting down PocketIC...");
                     ShutdownReason::CtrlC
                 }
@@ -364,6 +364,28 @@ async fn wait_for_shutdown(guard: &mut ShutdownGuard) -> ShutdownReason {
     }
 }
 
+#[cfg(unix)]
+async fn stop_signal() {
+    use tokio::signal::unix::{SignalKind, signal};
+    let mut sigterm = signal(SignalKind::terminate()).unwrap();
+    select! {
+        _ = ctrl_c() => {},
+        _ = sigterm.recv() => {},
+    }
+}
+
+#[cfg(windows)]
+async fn stop_signal() {
+    use tokio::signal::windows::{ctrl_break, ctrl_close};
+    let mut ctrl_break = ctrl_break().unwrap();
+    let mut ctrl_close = ctrl_close().unwrap();
+    select! {
+        _ = ctrl_c() => {},
+        _ = ctrl_break.recv() => {},
+        _ = ctrl_close.recv() => {},
+    }
+}
+
 /// Yields immediately if the child exits.
 pub async fn notice_child_exit(child: &mut Child) -> ChildExitError {
     loop {