refactor: use Arc<Mutex<...>> for SectionCapture

Author: tonyfettes

crates/moon/src/cli/run.rs

@@ -738,7 +738,7 @@ fn rr_run_from_plan(
 
     let res = default_rt()
         .context("Failed to create runtime")?
-        .block_on(crate::run::run(&mut [], false, run_cmd.command))
+        .block_on(crate::run::run(&[], false, run_cmd.command))
         .context("failed to run command")?;
 
     if let Some(code) = res.code() {

crates/moon/src/run/child.rs

@@ -18,12 +18,15 @@
 
 //! Handles spawning of a child process under the govern of `moon run`
 
-use std::process::{ExitStatus, Stdio};
+use std::{
+    process::{ExitStatus, Stdio},
+    sync::Arc,
+};
 
 use anyhow::Context;
 use moonbuild::section_capture::{SectionCapture, handle_stdout_async};
 use moonutil::platform::macos_with_sigchild_blocked;
-use tokio::process::Command;
+use tokio::{process::Command, sync::Mutex};
 
 /// Run a command under the governing of `moon run`.
 ///
@@ -39,7 +42,7 @@ use tokio::process::Command;
 /// output since the running process might not have any other method to interact
 /// with the host `moon` process.
 pub async fn run<'a>(
-    captures: &mut [&mut SectionCapture<'a>],
+    captures: &[Arc<Mutex<SectionCapture<'a>>>],
     capture: bool,
     mut cmd: Command,
 ) -> anyhow::Result<ExitStatus> {

crates/moon/src/run/runtest.rs

@@ -79,7 +79,7 @@ use moonutil::common::{
     MOON_COVERAGE_DELIMITER_BEGIN, MOON_COVERAGE_DELIMITER_END, MOON_TEST_DELIMITER_BEGIN,
     MOON_TEST_DELIMITER_END, MbtTestInfo, MooncGenTestInfo,
 };
-use tokio::runtime::Runtime;
+use tokio::{runtime::Runtime, sync::Mutex};
 use tracing::{debug, info, instrument, trace, warn};
 
 use crate::{rr_build::BuildMeta, run::default_rt};
@@ -402,20 +402,18 @@ fn run_one_test_executable(
         test.executable,
         Some(&test_args),
     )?;
-    let mut cov_cap = mk_coverage_capture();
-    let mut test_cap = make_test_capture();
+    let cov_cap = Arc::new(Mutex::new(mk_coverage_capture()));
+    let test_cap = Arc::new(Mutex::new(make_test_capture()));
     if ctx.verbose {
         crate::rr_build::dry_print_command(cmd.command.as_std(), ctx.source_dir, true);
     }
     info!(package = %test_args.package, executable = %test.executable.display(), "launching test executable");
 
+    let captures = [Arc::clone(&cov_cap), Arc::clone(&test_cap)];
+
     let exit_status = ctx
         .rt
-        .block_on(crate::run::run(
-            &mut [&mut cov_cap, &mut test_cap],
-            true,
-            cmd.command,
-        ))
+        .block_on(crate::run::run(&captures, true, cmd.command))
         .with_context(|| format!("Failed to run test for {fqn} {:?}", test.target.kind))?;
     debug!(?exit_status, "test process finished");
 
@@ -427,9 +425,17 @@ fn run_one_test_executable(
         );
     }
 
-    handle_finished_coverage(ctx.target_dir, cov_cap)?;
-
-    parse_test_results(meta, test_cap).with_context(|| {
+    let cov_result = Arc::try_unwrap(cov_cap)
+        .ok()
+        .expect("cov_cap should have no other references")
+        .into_inner();
+    handle_finished_coverage(ctx.target_dir, cov_result)?;
+
+    let test_result = Arc::try_unwrap(test_cap)
+        .ok()
+        .expect("test_cap should have no other references")
+        .into_inner();
+    parse_test_results(meta, test_result).with_context(|| {
         format!(
             "Failed to parse test results for {fqn} {:?}",
             test.target.kind

crates/moonbuild/src/section_capture.rs

@@ -16,9 +16,12 @@
 //
 // For inquiries, you can contact us via e-mail at jichuruanjian@idea.edu.cn.
 
-use std::io::BufRead;
+use std::{io::BufRead, sync::Arc};
 
-use tokio::io::{AsyncBufRead, AsyncWriteExt};
+use tokio::{
+    io::{AsyncBufRead, AsyncWriteExt},
+    sync::Mutex,
+};
 
 pub struct SectionCapture<'a> {
     begin_delimiter: &'a str,
@@ -121,7 +124,7 @@ pub fn handle_stdout<P: FnMut(&str)>(
 /// Async version of [`handle_stdout`].
 pub async fn handle_stdout_async<'a>(
     proc: impl AsyncBufRead,
-    captures: &mut [&mut SectionCapture<'a>],
+    captures: &[Arc<Mutex<SectionCapture<'a>>>],
 ) -> anyhow::Result<()> {
     use tokio::io::AsyncBufReadExt;
     let mut buf = String::new();
@@ -136,8 +139,8 @@ pub async fn handle_stdout_async<'a>(
             break;
         }
         let capture_status = captures
-            .iter_mut()
-            .find_map(|capture| capture.feed_line(&buf));
+            .iter()
+            .find_map(|capture| capture.blocking_lock().feed_line(&buf));
         match capture_status {
             None => {
                 stdout.write_all(buf.as_bytes()).await?;