running-process 3.4.0__tar.gz → 3.4.1__tar.gz

{running_process-3.4.0 → running_process-3.4.1}/Cargo.lock

@@ -210,7 +210,7 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "daemon-trampoline"
-version = "3.4.0"
+version = "3.4.1"
 dependencies = [
  "libc",
  "serde",
@@ -1036,7 +1036,7 @@ checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
 
 [[package]]
 name = "running-process-client"
-version = "3.4.0"
+version = "3.4.1"
 dependencies = [
  "dirs",
  "interprocess",
@@ -1047,7 +1047,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-core"
-version = "3.4.0"
+version = "3.4.1"
 dependencies = [
  "libc",
  "portable-pty",
@@ -1061,7 +1061,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-daemon"
-version = "3.4.0"
+version = "3.4.1"
 dependencies = [
  "bytes",
  "clap",
@@ -1088,7 +1088,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-proto"
-version = "3.4.0"
+version = "3.4.1"
 dependencies = [
  "prost",
  "prost-build",
@@ -1098,7 +1098,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-py"
-version = "3.4.0"
+version = "3.4.1"
 dependencies = [
  "interprocess",
  "libc",
@@ -1114,7 +1114,7 @@ dependencies = [
 
 [[package]]
 name = "runpm-cli"
-version = "3.4.0"
+version = "3.4.1"
 dependencies = [
  "anyhow",
  "clap",

{running_process-3.4.0 → running_process-3.4.1}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/running-process-core", "crates/running-process-proto", "crates/running-process-client", "crates/running-process-py", "crates/test-watchdog"]
 
 [workspace.package]
-version = "3.4.0"
+version = "3.4.1"
 edition = "2021"
 rust-version = "1.85"
 license = "BSD-3-Clause"

{running_process-3.4.0 → running_process-3.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: running_process
-Version: 3.4.0
+Version: 3.4.1
 License-File: LICENSE
 Summary: A Rust-backed subprocess wrapper with split stdout/stderr streaming
 Home-Page: https://github.com/zackees/running-process

{running_process-3.4.0 → running_process-3.4.1}/crates/running-process-client/Cargo.toml

@@ -9,7 +9,7 @@ homepage.workspace = true
 description = "Lightweight synchronous IPC client for the running-process daemon"
 
 [dependencies]
-running-process-proto = { path = "../running-process-proto", version = "3.4.0" }
+running-process-proto = { path = "../running-process-proto", version = "3.4.1" }
 prost = "0.14"
 interprocess = "2"
 dirs = "6"

{running_process-3.4.0 → running_process-3.4.1}/crates/running-process-core/Cargo.toml

@@ -17,7 +17,7 @@ libc = "0.2"
 portable-pty = "0.9"
 sysinfo = "0.30"
 thiserror = { workspace = true }
-winapi = { version = "0.3", features = ["errhandlingapi", "fileapi", "handleapi", "jobapi2", "namedpipeapi", "processthreadsapi", "winnt", "minwindef", "windef", "winuser", "consoleapi", "processenv", "synchapi", "winbase", "wincon", "tlhelp32"] }
+winapi = { version = "0.3", features = ["errhandlingapi", "fileapi", "handleapi", "ioapiset", "jobapi2", "namedpipeapi", "processthreadsapi", "winnt", "minwindef", "windef", "winuser", "consoleapi", "processenv", "synchapi", "winbase", "wincon", "tlhelp32"] }
 
 [dev-dependencies]
 serde_json = "1"

{running_process-3.4.0 → running_process-3.4.1}/crates/running-process-core/src/lib.rs

@@ -40,6 +40,25 @@ macro_rules! rp_rust_debug_scope {
 
 const CHILD_PID_LOG_PATH_ENV: &str = "RUNNING_PROCESS_CHILD_PID_LOG_PATH";
 
+/// Hard cap on how long `kill_impl()` will block on
+/// `wait_for_capture_completion` after the direct child has been
+/// reaped. Override via the `RUNNING_PROCESS_KILL_DRAIN_TIMEOUT_MS`
+/// env var (milliseconds). The default of 2 s gives normal children
+/// time to flush their pipe buffers while preventing indefinite hangs
+/// when a grandchild inherits the pipe and outlives the parent (FastLED
+/// Bug B).
+const DEFAULT_KILL_DRAIN_TIMEOUT: Duration = Duration::from_secs(2);
+const KILL_DRAIN_TIMEOUT_ENV: &str = "RUNNING_PROCESS_KILL_DRAIN_TIMEOUT_MS";
+
+fn kill_drain_deadline() -> Instant {
+    let timeout = std::env::var(KILL_DRAIN_TIMEOUT_ENV)
+        .ok()
+        .and_then(|raw| raw.trim().parse::<u64>().ok())
+        .map(Duration::from_millis)
+        .unwrap_or(DEFAULT_KILL_DRAIN_TIMEOUT);
+    Instant::now() + timeout
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum StreamKind {
     Stdout,
@@ -168,6 +187,21 @@ struct ChildState {
     _job: WindowsJobHandle,
 }
 
+/// Parent-side handles for the captured stdout/stderr pipes, kept so
+/// that `kill_impl` can call `CancelIoEx` to interrupt a reader thread
+/// blocked in `read()`. Stored as `usize` because `RawHandle` (a raw
+/// pointer) is not `Send` and we share this via `Arc<Mutex<...>>`.
+///
+/// The reader thread clears its slot (under the mutex) immediately
+/// before dropping its `ChildStd*`, so `kill_impl` never calls
+/// `CancelIoEx` on a closed (and potentially reused) handle.
+#[cfg(windows)]
+#[derive(Default)]
+struct CapturePipeHandles {
+    stdout: Option<usize>,
+    stderr: Option<usize>,
+}
+
 impl SharedState {
     fn new(capture: bool) -> Self {
         let queues = QueueState {
@@ -187,6 +221,8 @@ pub struct NativeProcess {
     config: ProcessConfig,
     child: Arc<Mutex<Option<ChildState>>>,
     shared: Arc<SharedState>,
+    #[cfg(windows)]
+    capture_pipe_handles: Arc<Mutex<CapturePipeHandles>>,
 }
 
 impl NativeProcess {
@@ -195,6 +231,8 @@ impl NativeProcess {
             shared: Arc::new(SharedState::new(config.capture)),
             child: Arc::new(Mutex::new(None)),
             config,
+            #[cfg(windows)]
+            capture_pipe_handles: Arc::new(Mutex::new(CapturePipeHandles::default())),
         }
     }
 
@@ -234,7 +272,22 @@ impl NativeProcess {
         if self.config.capture {
             let stdout = child.stdout.take().expect("stdout pipe missing");
             let stderr = child.stderr.take().expect("stderr pipe missing");
-            self.spawn_reader(stdout, StreamKind::Stdout, StreamKind::Stdout);
+            #[cfg(windows)]
+            {
+                use std::os::windows::io::AsRawHandle;
+                let mut handles = self
+                    .capture_pipe_handles
+                    .lock()
+                    .expect("capture pipe handles mutex poisoned");
+                handles.stdout = Some(stdout.as_raw_handle() as usize);
+                handles.stderr = Some(stderr.as_raw_handle() as usize);
+            }
+            self.spawn_reader(
+                stdout,
+                StreamKind::Stdout,
+                StreamKind::Stdout,
+                self.pipe_done_callback(StreamKind::Stdout),
+            );
             self.spawn_reader(
                 stderr,
                 StreamKind::Stderr,
@@ -242,6 +295,7 @@ impl NativeProcess {
                     StderrMode::Stdout => StreamKind::Stdout,
                     StderrMode::Pipe => StreamKind::Stderr,
                 },
+                self.pipe_done_callback(StreamKind::Stderr),
             );
         }
         *guard = Some(ChildState {
@@ -405,6 +459,15 @@ impl NativeProcess {
             let status = child.wait().map_err(ProcessError::Io)?;
             self.set_returncode(exit_code(status));
         }
+        // On Windows, interrupt any pending blocking `read()` in the
+        // per-stream reader threads so they fall out of their loops
+        // immediately. This is what makes the grandchild-pipe-orphan
+        // case (FastLED Bug B: uv.exe spawns a python.exe grandchild
+        // that inherits the pipe and outlives uv) wake up in
+        // microseconds instead of waiting for the bounded-drain
+        // safety-net deadline below.
+        #[cfg(windows)]
+        self.cancel_capture_io();
         // Synchronize with the per-stream reader threads so that by the
         // time kill() returns, the capture queues have flipped from
         // "blocked on read" to "closed" and downstream pollers (e.g.
@@ -412,7 +475,15 @@ impl NativeProcess {
         // this, callers that hit a wait()-timeout path see Python code
         // raise TimeoutError, kill the child, then race the reader
         // threads — a 10ms poll loop can miss the EOS flip entirely.
-        public_symbols::rp_native_process_wait_for_capture_completion_public(self);
+        //
+        // The deadline is the safety-net: on Windows `CancelIoEx`
+        // above almost always wakes the readers first; on POSIX, and
+        // in any pathological Windows case where `CancelIoEx` doesn't
+        // fire, the deadline guarantees `kill()` still returns.
+        public_symbols::rp_native_process_wait_for_capture_completion_with_deadline_public(
+            self,
+            kill_drain_deadline(),
+        );
         Ok(())
     }
 
@@ -785,8 +856,9 @@ impl NativeProcess {
             } else {
                 0
             };
-            let flags =
-                self.config.creationflags.unwrap_or(0) | extra | windows_priority_flags(self.config.nice);
+            let flags = self.config.creationflags.unwrap_or(0)
+                | extra
+                | windows_priority_flags(self.config.nice);
             if flags != 0 {
                 command.creation_flags(flags);
             }
@@ -818,8 +890,13 @@ impl NativeProcess {
         command
     }
 
-    fn spawn_reader<R>(&self, pipe: R, source_stream: StreamKind, visible_stream: StreamKind)
-    where
+    fn spawn_reader<R>(
+        &self,
+        pipe: R,
+        source_stream: StreamKind,
+        visible_stream: StreamKind,
+        on_pipe_done: Box<dyn FnOnce() + Send>,
+    ) where
         R: Read + Send + 'static,
     {
         let shared = Arc::clone(&self.shared);
@@ -843,6 +920,13 @@ impl NativeProcess {
                 emit_lines(&shared, visible_stream, vec![std::mem::take(&mut pending)]);
             }
 
+            // Clear the parent-side pipe-handle slot under its mutex
+            // before dropping the reader. After this returns,
+            // `kill_impl` can no longer try to `CancelIoEx` on us, so
+            // it's safe for `reader`'s drop to close the HANDLE.
+            on_pipe_done();
+            drop(reader);
+
             let mut guard = shared.queues.lock().expect("queue mutex poisoned");
             match source_stream {
                 StreamKind::Stdout => guard.stdout_closed = true,
@@ -852,6 +936,57 @@ impl NativeProcess {
         });
     }
 
+    #[cfg(windows)]
+    fn pipe_done_callback(&self, stream: StreamKind) -> Box<dyn FnOnce() + Send> {
+        let handles = Arc::clone(&self.capture_pipe_handles);
+        Box::new(move || {
+            let mut guard = handles
+                .lock()
+                .expect("capture pipe handles mutex poisoned");
+            match stream {
+                StreamKind::Stdout => guard.stdout = None,
+                StreamKind::Stderr => guard.stderr = None,
+            }
+        })
+    }
+
+    #[cfg(not(windows))]
+    fn pipe_done_callback(&self, _stream: StreamKind) -> Box<dyn FnOnce() + Send> {
+        Box::new(|| {})
+    }
+
+    /// Cancel any pending blocking `read()` on the parent-side capture
+    /// pipes so the reader threads' `read()` calls return
+    /// `ERROR_OPERATION_ABORTED` immediately. Used by `kill_impl` to
+    /// break the grandchild-orphan deadlock without waiting on
+    /// `wait_for_capture_completion_with_deadline`'s safety-net.
+    #[cfg(windows)]
+    fn cancel_capture_io(&self) {
+        crate::rp_rust_debug_scope!("running_process_core::NativeProcess::cancel_capture_io");
+        use winapi::shared::ntdef::HANDLE;
+        use winapi::um::ioapiset::CancelIoEx;
+        let guard = self
+            .capture_pipe_handles
+            .lock()
+            .expect("capture pipe handles mutex poisoned");
+        if let Some(h) = guard.stdout {
+            // SAFETY: the slot is `Some` only while the owning reader
+            // thread still holds the `ChildStdout`, so the HANDLE is
+            // valid for the duration of this call. The reader is
+            // blocked in `lock()` on the same mutex if it's racing us
+            // toward exit, so it cannot drop the pipe and close the
+            // HANDLE until we return.
+            unsafe {
+                CancelIoEx(h as HANDLE, std::ptr::null_mut());
+            }
+        }
+        if let Some(h) = guard.stderr {
+            unsafe {
+                CancelIoEx(h as HANDLE, std::ptr::null_mut());
+            }
+        }
+    }
+
     fn set_returncode(&self, code: i32) {
         self.shared.returncode.store(code as i64, Ordering::Release);
         self.shared.condvar.notify_all();
@@ -874,6 +1009,46 @@ impl NativeProcess {
                 .expect("queue mutex poisoned");
         }
     }
+
+    /// Like `wait_for_capture_completion_impl` but bounded by `deadline`.
+    /// Returns `true` if the reader threads flipped both closed flags on
+    /// their own, `false` if the deadline elapsed first. On timeout the
+    /// closed flags are force-set (and waiters notified) so downstream
+    /// pollers stop seeing `Timeout` and start seeing `Eof`. A reader
+    /// thread that eventually unblocks after the OS releases the pipe
+    /// will assign `closed = true` again, which is a harmless no-op.
+    fn wait_for_capture_completion_with_deadline_impl(&self, deadline: Instant) -> bool {
+        crate::rp_rust_debug_scope!(
+            "running_process_core::NativeProcess::wait_for_capture_completion_with_deadline"
+        );
+        if !self.config.capture {
+            return true;
+        }
+
+        let mut guard = self.shared.queues.lock().expect("queue mutex poisoned");
+        while !(guard.stdout_closed && guard.stderr_closed) {
+            let now = Instant::now();
+            if now >= deadline {
+                guard.stdout_closed = true;
+                guard.stderr_closed = true;
+                self.shared.condvar.notify_all();
+                return false;
+            }
+            let (next_guard, result) = self
+                .shared
+                .condvar
+                .wait_timeout(guard, deadline - now)
+                .expect("queue mutex poisoned");
+            guard = next_guard;
+            if result.timed_out() && !(guard.stdout_closed && guard.stderr_closed) {
+                guard.stdout_closed = true;
+                guard.stderr_closed = true;
+                self.shared.condvar.notify_all();
+                return false;
+            }
+        }
+        true
+    }
 }
 
 #[cfg(unix)]

{running_process-3.4.0 → running_process-3.4.1}/crates/running-process-core/src/public_symbols.rs

@@ -1,5 +1,7 @@
 #![allow(improper_ctypes_definitions)]
 
+use std::time::Instant;
+
 use super::*;
 
 #[unsafe(no_mangle)]
@@ -50,6 +52,15 @@ pub extern "C" fn rp_native_process_wait_for_capture_completion_public(process:
     process.wait_for_capture_completion_impl();
 }
 
+#[unsafe(no_mangle)]
+#[inline(never)]
+pub extern "C" fn rp_native_process_wait_for_capture_completion_with_deadline_public(
+    process: &NativeProcess,
+    deadline: Instant,
+) -> bool {
+    process.wait_for_capture_completion_with_deadline_impl(deadline)
+}
+
 #[cfg(windows)]
 #[unsafe(no_mangle)]
 #[inline(never)]

{running_process-3.4.0 → running_process-3.4.1}/crates/running-process-core/tests/process_core_test.rs

@@ -648,6 +648,149 @@ fn terminate_kills_running_process() {
     process.terminate().unwrap();
 }
 
+/// FastLED Bug B follow-up: on Windows, `kill()` must wake the
+/// reader threads via `CancelIoEx` *immediately* even when a
+/// grandchild keeps the captured pipe open. This is what the
+/// `cancel_capture_io()` call in `kill_impl` provides — without it,
+/// kill() would wait for the full `RUNNING_PROCESS_KILL_DRAIN_TIMEOUT_MS`
+/// safety-net deadline before returning. The test sets that deadline
+/// to 5000 ms and asserts kill() returns in under 1 s, proving the
+/// CancelIoEx fast path is wired up.
+#[cfg(windows)]
+#[test]
+fn kill_cancels_capture_io_when_grandchild_orphans_pipe() {
+    let script = "\
+import os, subprocess, sys, time;\
+print('PARENT_PID=' + str(os.getpid()), flush=True);\
+gc = subprocess.Popen([sys.executable, '-c', 'import time; time.sleep(60)']);\
+print('GRANDCHILD_PID=' + str(gc.pid), flush=True);\
+time.sleep(60)";
+
+    let process = NativeProcess::new(config(
+        CommandSpec::Argv(vec!["python".into(), "-c".into(), script.into()]),
+        true,
+        StdinMode::Inherit,
+        None,
+    ));
+
+    process.start().unwrap();
+
+    let mut grandchild_pid: Option<u32> = None;
+    let deadline = Instant::now() + Duration::from_secs(10);
+    while Instant::now() < deadline {
+        match process.read_combined(Some(Duration::from_millis(200))) {
+            ReadStatus::Line(event) => {
+                let line = String::from_utf8_lossy(&event.line).into_owned();
+                if let Some(rest) = line.strip_prefix("GRANDCHILD_PID=") {
+                    grandchild_pid = rest.trim().parse::<u32>().ok();
+                    break;
+                }
+            }
+            ReadStatus::Timeout => continue,
+            ReadStatus::Eof => panic!("parent exited before announcing grandchild"),
+        }
+    }
+    let grandchild_pid = grandchild_pid.expect("did not observe GRANDCHILD_PID line");
+
+    // Crank the safety-net drain deadline way up so the only way
+    // kill() can return fast is via the CancelIoEx fast path.
+    let prior = env::var_os("RUNNING_PROCESS_KILL_DRAIN_TIMEOUT_MS");
+    env::set_var("RUNNING_PROCESS_KILL_DRAIN_TIMEOUT_MS", "5000");
+
+    let kill_start = Instant::now();
+    let kill_result = process.kill();
+    let kill_elapsed = kill_start.elapsed();
+
+    match prior {
+        Some(v) => env::set_var("RUNNING_PROCESS_KILL_DRAIN_TIMEOUT_MS", v),
+        None => env::remove_var("RUNNING_PROCESS_KILL_DRAIN_TIMEOUT_MS"),
+    }
+
+    kill_result.expect("kill() returned an error");
+    assert!(
+        kill_elapsed < Duration::from_secs(1),
+        "kill() took {kill_elapsed:?} with 5 s safety-net deadline; \
+         CancelIoEx fast path is not interrupting the reader thread",
+    );
+
+    let _ = Command::new("taskkill")
+        .args(["/F", "/T", "/PID", &grandchild_pid.to_string()])
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status();
+}
+
+/// FastLED Bug B regression: when a grandchild inherits the captured
+/// stdout pipe and outlives the direct child, `kill()` must still
+/// return promptly instead of blocking forever in
+/// `wait_for_capture_completion`. Mirrors the `uv run python ...`
+/// shape, where uv exits while a python grandchild keeps the pipe open.
+#[test]
+fn kill_returns_when_grandchild_inherits_stdout_pipe() {
+    // Parent: print its own PID, spawn a grandchild python that sleeps
+    // 60 s with inherited stdout, then itself sleep 60 s. We kill the
+    // parent before either sleep elapses; the grandchild stays alive
+    // (and thus the pipe stays open) for the duration of the test.
+    let script = "\
+import os, subprocess, sys, time;\
+print('PARENT_PID=' + str(os.getpid()), flush=True);\
+gc = subprocess.Popen([sys.executable, '-c', 'import time; time.sleep(60)']);\
+print('GRANDCHILD_PID=' + str(gc.pid), flush=True);\
+time.sleep(60)";
+
+    let process = NativeProcess::new(config(
+        CommandSpec::Argv(vec!["python".into(), "-c".into(), script.into()]),
+        true,
+        StdinMode::Inherit,
+        None,
+    ));
+
+    process.start().unwrap();
+
+    // Wait for the parent to spawn the grandchild and announce both PIDs.
+    let mut grandchild_pid: Option<u32> = None;
+    let deadline = Instant::now() + Duration::from_secs(10);
+    while Instant::now() < deadline {
+        match process.read_combined(Some(Duration::from_millis(200))) {
+            ReadStatus::Line(event) => {
+                let line = String::from_utf8_lossy(&event.line).into_owned();
+                if let Some(rest) = line.strip_prefix("GRANDCHILD_PID=") {
+                    grandchild_pid = rest.trim().parse::<u32>().ok();
+                    break;
+                }
+            }
+            ReadStatus::Timeout => continue,
+            ReadStatus::Eof => panic!("parent exited before announcing grandchild"),
+        }
+    }
+    let grandchild_pid = grandchild_pid.expect("did not observe GRANDCHILD_PID line");
+
+    // The grandchild now holds the stdout pipe open. kill() on the
+    // parent reaps the parent but the reader thread is still blocked
+    // on read(); without the bounded wait this hangs forever.
+    let kill_start = Instant::now();
+    process.kill().expect("kill() returned an error");
+    let kill_elapsed = kill_start.elapsed();
+    assert!(
+        kill_elapsed < Duration::from_secs(5),
+        "kill() blocked for {kill_elapsed:?}; expected bounded return after grandchild orphan",
+    );
+
+    // Cleanup: terminate the lingering grandchild so it doesn't leak.
+    #[cfg(windows)]
+    {
+        let _ = Command::new("taskkill")
+            .args(["/F", "/T", "/PID", &grandchild_pid.to_string()])
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status();
+    }
+    #[cfg(not(windows))]
+    unsafe {
+        libc::kill(grandchild_pid as i32, libc::SIGKILL);
+    }
+}
+
 // ── pid() ──
 
 #[test]

{running_process-3.4.0 → running_process-3.4.1}/crates/running-process-py/Cargo.toml

@@ -16,10 +16,10 @@ crate-type = ["cdylib", "lib"]
 libc = "0.2"
 pyo3 = { workspace = true }
 regex = "1"
-running-process-core = { path = "../running-process-core", version = "3.4.0", features = ["originator-scan"] }
+running-process-core = { path = "../running-process-core", version = "3.4.1", features = ["originator-scan"] }
 sysinfo = "0.30"
 winapi = { version = "0.3", features = ["consoleapi", "handleapi", "jobapi2", "processenv", "processthreadsapi", "synchapi", "winbase", "wincon", "winnt", "winuser"] }
-running-process-proto = { path = "../running-process-proto", version = "3.4.0" }
-running-process-client = { path = "../running-process-client", version = "3.4.0" }
+running-process-proto = { path = "../running-process-proto", version = "3.4.1" }
+running-process-client = { path = "../running-process-client", version = "3.4.1" }
 prost = "0.14"
 interprocess = "2"

{running_process-3.4.0 → running_process-3.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "running_process"
-version = "3.4.0"
+version = "3.4.1"
 description = "A Rust-backed subprocess wrapper with split stdout/stderr streaming"
 readme = "README.md"
 requires-python = ">=3.10"

{running_process-3.4.0 → running_process-3.4.1}/src/running_process/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = "3.4.0"
+__version__ = "3.4.1"
 
 from running_process._native import (
     ContainedProcessGroup,