update usages

Author: branchseer

crates/fspy/examples/cli.rs

@@ -1,6 +1,6 @@
 use std::{env::args_os, ffi::OsStr, path::PathBuf, pin::Pin};
 
-use fspy::{AccessMode, TrackedChild};
+use fspy::AccessMode;
 use tokio::{
     fs::File,
     io::{AsyncWrite, stdout},
@@ -21,19 +21,16 @@ async fn main() -> anyhow::Result<()> {
     let mut command = spy.new_command(program);
     command.envs(std::env::vars_os()).args(args);
 
-    let TrackedChild { mut tokio_child, accesses_future } = command.spawn().await?;
-
-    let output = tokio_child.wait().await?;
-
-    let accesses = accesses_future.await?;
+    let child = command.spawn().await?;
+    let termination = child.wait_handle.await?;
 
     let mut path_count = 0usize;
     let out_file: Pin<Box<dyn AsyncWrite>> =
         if out_path == "-" { Box::pin(stdout()) } else { Box::pin(File::create(out_path).await?) };
 
     let mut csv_writer = csv_async::AsyncWriter::from_writer(out_file);
 
-    for acc in accesses.iter() {
+    for acc in termination.path_accesses.iter() {
         path_count += 1;
         csv_writer
             .write_record(&[
@@ -49,6 +46,6 @@ async fn main() -> anyhow::Result<()> {
     }
     csv_writer.flush().await?;
 
-    eprintln!("\nfspy: {path_count} paths accessed. {output}");
+    eprintln!("\nfspy: {path_count} paths accessed. status: {}", termination.status);
     Ok(())
 }

crates/fspy/src/unix/mod.rs

@@ -140,6 +140,8 @@ pub(crate) async fn spawn_impl(mut command: Command) -> Result<TrackedChild, Spa
         stdin: child.stdin.take(),
         stdout: child.stdout.take(),
         stderr: child.stderr.take(),
+        // Keep polling for the child to exit in the background even if `wait_handle` is not awaited,
+        // because we need to stop the supervisor and lock the channel as soon as the child exits.
         wait_handle: tokio::spawn(async move {
             let status = child.wait().await?;
 

crates/fspy/tests/node_fs.rs

@@ -2,7 +2,7 @@ mod test_utils;
 
 use std::env::{current_dir, vars_os};
 
-use fspy::{AccessMode, PathAccessIterable, TrackedChild};
+use fspy::{AccessMode, PathAccessIterable};
 use test_utils::assert_contains;
 
 async fn track_node_script(script: &str) -> anyhow::Result<PathAccessIterable> {
@@ -11,11 +11,10 @@ async fn track_node_script(script: &str) -> anyhow::Result<PathAccessIterable> {
         .arg("-e")
         .envs(vars_os()) // https://github.com/jdx/mise/discussions/5968
         .arg(script);
-    let TrackedChild { mut tokio_child, accesses_future } = command.spawn().await?;
-    let status = tokio_child.wait().await?;
-    let accesses = accesses_future.await?;
-    assert!(status.success());
-    Ok(accesses)
+    let child = command.spawn().await?;
+    let termination = child.wait_handle.await?;
+    assert!(termination.status.success());
+    Ok(termination.path_accesses)
 }
 
 #[tokio::test]

crates/fspy/tests/test_utils.rs

@@ -1,6 +1,6 @@
 use std::path::{Path, PathBuf, StripPrefixError};
 
-use fspy::{AccessMode, PathAccessIterable, TrackedChild};
+use fspy::{AccessMode, PathAccessIterable};
 
 #[track_caller]
 pub fn assert_contains(
@@ -55,10 +55,7 @@ macro_rules! track_child {
 pub async fn _spawn_with_id(id: &str) -> anyhow::Result<PathAccessIterable> {
     let mut command = fspy::Spy::global()?.new_command(::std::env::current_exe()?);
     command.arg(id);
-    let TrackedChild { mut tokio_child, accesses_future } = command.spawn().await?;
-
-    let status = tokio_child.wait().await?;
-    let accesses = accesses_future.await?;
-    assert!(status.success());
-    Ok(accesses)
+    let termination = command.spawn().await?.wait_handle.await?;
+    assert!(termination.status.success());
+    Ok(termination.path_accesses)
 }

crates/fspy_e2e/src/main.rs

@@ -9,6 +9,7 @@ use std::{
 
 use fspy::{AccessMode, PathAccess};
 use serde::{Deserialize, Serialize};
+use tokio::io::AsyncReadExt;
 
 #[derive(Serialize, Deserialize)]
 struct Config {
@@ -86,25 +87,30 @@ async fn main() {
             .stderr(Stdio::piped())
             .current_dir(&dir);
 
-        let tracked_child = cmd.spawn().await.unwrap();
+        let mut tracked_child = cmd.spawn().await.unwrap();
 
-        let output = tracked_child.tokio_child.wait_with_output().await.unwrap();
-        let accesses = tracked_child.accesses_future.await.unwrap();
+        let mut stdout_bytes = Vec::<u8>::new();
+        tracked_child.stdout.take().unwrap().read_to_end(&mut stdout_bytes).await.unwrap();
 
-        if !output.status.success() {
+        let mut stderr_bytes = Vec::<u8>::new();
+        tracked_child.stderr.take().unwrap().read_to_end(&mut stderr_bytes).await.unwrap();
+
+        let termination = tracked_child.wait_handle.await.unwrap();
+
+        if !termination.status.success() {
             eprintln!("----- stdout begin -----");
-            stderr().write_all(&output.stdout).unwrap();
+            stderr().write_all(&stdout_bytes).unwrap();
             eprintln!("----- stdout end -----");
             eprintln!("----- stderr begin-----");
-            stderr().write_all(&output.stderr).unwrap();
+            stderr().write_all(&stderr_bytes).unwrap();
             eprintln!("----- stderr end -----");
 
-            eprintln!("Case `{}` failed with status: {}", name, output.status);
+            eprintln!("Case `{}` failed with status: {}", name, termination.status);
             process::exit(1);
         }
 
         let mut collector = AccessCollector::new(dir);
-        for access in accesses.iter() {
+        for access in termination.path_accesses.iter() {
             collector.add(access);
         }
         let snap_file = File::create(manifest_dir.join(format!("snaps/{name}.txt"))).unwrap();

crates/vite_task/src/execute.rs

@@ -9,7 +9,7 @@ use std::{
 };
 
 use bincode::{Decode, Encode};
-use fspy::{AccessMode, Spy, TrackedChild};
+use fspy::{AccessMode, Spy};
 use futures_util::future::try_join3;
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
@@ -402,87 +402,87 @@ pub async fn execute_task(
     cmd.current_dir(base_dir.join(&resolved_command.fingerprint.cwd))
         .stdout(Stdio::piped())
         .stderr(Stdio::piped());
-    let TrackedChild { tokio_child: mut child, accesses_future } = cmd.spawn().await?;
+    let mut child = cmd.spawn().await?;
 
     let child_stdout = child.stdout.take().unwrap();
     let child_stderr = child.stderr.take().unwrap();
 
     let outputs = Mutex::new(Vec::<StdOutput>::new());
 
-    let path_accesses_fut = async move {
-        let path_accesses = accesses_future.await?;
-        let mut path_reads = HashMap::<RelativePathBuf, PathRead>::new();
-        let mut path_writes = HashMap::<RelativePathBuf, PathWrite>::new();
-        for access in path_accesses.iter() {
-            let relative_path = access
-                .path
-                .strip_path_prefix(base_dir, |strip_result| {
-                    let Ok(stripped_path) = strip_result else {
-                        return None;
-                    };
-                    Some(RelativePathBuf::new(stripped_path).map_err(|err| {
-                        Error::InvalidRelativePath { path: stripped_path.into(), reason: err }
-                    }))
-                })
-                .transpose()?;
-
-            let Some(relative_path) = relative_path else {
-                // ignore accesses outside the workspace
-                continue;
-            };
-            if relative_path.as_path().strip_prefix(".git").is_ok() {
-                // temp workaround for oxlint reading inside .git
-                continue;
-            }
-            match access.mode {
-                AccessMode::Read => {
-                    path_reads.entry(relative_path).or_insert(PathRead { read_dir_entries: false });
-                }
-                AccessMode::Write => {
-                    path_writes.insert(relative_path, PathWrite);
-                }
-                AccessMode::ReadWrite => {
-                    path_reads
-                        .entry(relative_path.clone())
-                        .or_insert(PathRead { read_dir_entries: false });
-                    path_writes.insert(relative_path, PathWrite);
-                }
-                AccessMode::ReadDir => match path_reads.entry(relative_path) {
-                    Entry::Occupied(mut occupied) => occupied.get_mut().read_dir_entries = true,
-                    Entry::Vacant(vacant) => {
-                        vacant.insert(PathRead { read_dir_entries: true });
-                    }
-                },
-            }
-        }
-        Ok::<_, Error>((path_reads, path_writes))
-    };
-
-    let ((), (), (exit_status, duration)) = try_join3(
+    let ((), (), (termination, duration)) = try_join3(
         collect_std_outputs(&outputs, child_stdout, OutputKind::StdOut),
         collect_std_outputs(&outputs, child_stderr, OutputKind::StdErr),
         async move {
             let start = Instant::now();
-            let exit_status = child.wait().await?;
+            let exit_status = child.wait_handle.await?;
             Ok((exit_status, start.elapsed()))
         },
     )
     .await?;
 
-    let (path_reads, path_writes) = path_accesses_fut.await?;
+    let mut path_reads = HashMap::<RelativePathBuf, PathRead>::new();
+    let mut path_writes = HashMap::<RelativePathBuf, PathWrite>::new();
+    for access in termination.path_accesses.iter() {
+        let relative_path = access
+            .path
+            .strip_path_prefix(base_dir, |strip_result| {
+                let Ok(stripped_path) = strip_result else {
+                    return None;
+                };
+                Some(RelativePathBuf::new(stripped_path).map_err(|err| {
+                    Error::InvalidRelativePath { path: stripped_path.into(), reason: err }
+                }))
+            })
+            .transpose()?;
+
+        let Some(relative_path) = relative_path else {
+            // ignore accesses outside the workspace
+            continue;
+        };
+        if relative_path.as_path().strip_prefix(".git").is_ok() {
+            // temp workaround for oxlint reading inside .git
+            continue;
+        }
+        match access.mode {
+            AccessMode::Read => {
+                path_reads.entry(relative_path).or_insert(PathRead { read_dir_entries: false });
+            }
+            AccessMode::Write => {
+                path_writes.insert(relative_path, PathWrite);
+            }
+            AccessMode::ReadWrite => {
+                path_reads
+                    .entry(relative_path.clone())
+                    .or_insert(PathRead { read_dir_entries: false });
+                path_writes.insert(relative_path, PathWrite);
+            }
+            AccessMode::ReadDir => match path_reads.entry(relative_path) {
+                Entry::Occupied(mut occupied) => occupied.get_mut().read_dir_entries = true,
+                Entry::Vacant(vacant) => {
+                    vacant.insert(PathRead { read_dir_entries: true });
+                }
+            },
+        }
+    }
 
     let outputs = outputs.into_inner().unwrap();
     tracing::debug!(
         "executed task finished, path_reads: {}, path_writes: {}, outputs: {}, exit_status: {}",
         path_reads.len(),
         path_writes.len(),
         outputs.len(),
-        exit_status
+        termination.status,
     );
 
     // let input_paths = gather_inputs(task, base_dir)?;
 
-    Ok(ExecutedTask { std_outputs: outputs.into(), exit_status, path_reads, path_writes, duration })
+    Ok(ExecutedTask {
+        std_outputs: outputs.into(),
+        exit_status: termination.status,
+        path_reads,
+        path_writes,
+        duration,
+    })
 }
 
 #[expect(dead_code)]