feat(tui): adopt an asynchronous Tokio runtime for the TUI frontend

Refactor TUI event handling and rendering to improve responsiveness and use a unified managed client worker.

crates/irtt-app/src/shared/client/mod.rs

@@ -3,6 +3,7 @@ pub mod config;
 pub mod prepare;
 pub mod session;
 pub mod targets;
+pub(crate) mod worker;
 
 pub use args::{
     parse_dscp, parse_duration, parse_length, parse_server_fill, parse_test_duration, parse_ttl,
@@ -13,7 +14,6 @@ pub use prepare::{
     prepare_managed_run, ManagedRunSetup, TargetSelection, MANAGED_EVENT_CAPACITY,
     STDIN_MAX_DESIRED_TARGETS, STDIN_MAX_LIVE_TARGET_GENERATIONS, STDIN_OUTCOME_HISTORY_LIMIT,
 };
-pub use session::is_shutdown_requested;
 pub use targets::{
     parse_stdin_target_set, parse_target, prepare_managed_targets, target_specs, GroupPacingArg,
     PreparedTarget, TargetArg, TargetSpec,

crates/irtt-app/src/shared/client/session.rs

@@ -1,42 +1,20 @@
-use std::sync::atomic::{AtomicBool, Ordering};
-
-#[cfg(feature = "tui")]
 use irtt_client::managed::{ManagedEvent, ManagedEventSubscription, ManagedEventTryRecvError};
 
-#[cfg(feature = "tui")]
-pub(crate) const MANAGED_EVENT_WORK_BUDGET: usize = 128;
-
-#[cfg(feature = "tui")]
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub(crate) enum ManagedDrainState {
-    Empty,
-    Closed,
-    BudgetExhausted,
-}
-
-/// Drain a bounded amount of lossy presentation work before returning to the
-/// frontend control loop.
-#[cfg(feature = "tui")]
-pub(crate) fn drain_managed_events<E>(
+pub(crate) fn drain_final_events<E>(
     events: &mut ManagedEventSubscription,
     dropped_events: &mut u64,
     mut process: impl FnMut(ManagedEvent) -> Result<(), E>,
-) -> Result<ManagedDrainState, E> {
-    for _ in 0..MANAGED_EVENT_WORK_BUDGET {
+) -> Result<(), E> {
+    loop {
         match events.try_recv() {
             Ok(event) => process(event)?,
+            Err(ManagedEventTryRecvError::Empty | ManagedEventTryRecvError::Closed) => break,
             Err(ManagedEventTryRecvError::Lagged(count)) => {
                 *dropped_events = dropped_events.saturating_add(count);
             }
-            Err(ManagedEventTryRecvError::Empty) => return Ok(ManagedDrainState::Empty),
-            Err(ManagedEventTryRecvError::Closed) => return Ok(ManagedDrainState::Closed),
         }
     }
-    Ok(ManagedDrainState::BudgetExhausted)
-}
-
-pub fn is_shutdown_requested(shutdown_requested: &AtomicBool) -> bool {
-    shutdown_requested.load(Ordering::Relaxed)
+    Ok(())
 }
 
 pub fn should_print_final_summary(continuous: bool, interrupted: bool) -> bool {

crates/irtt-app/src/shared/client/worker.rs

@@ -0,0 +1,133 @@
+use std::{io, thread, time::Duration};
+
+use irtt_client::managed::{ManagedClientHandle, ManagedClientTask, ManagedOutcome};
+use tokio::sync::oneshot;
+
+/// Keeps measurement scheduling separate from frontend output and statistics.
+/// Drop also stops and joins on frontend errors or cancellation.
+pub(crate) struct ManagedWorker {
+    handle: ManagedClientHandle,
+    thread: Option<thread::JoinHandle<()>>,
+    completion: oneshot::Receiver<io::Result<ManagedOutcome>>,
+}
+
+impl ManagedWorker {
+    pub(crate) fn start(task: ManagedClientTask, handle: ManagedClientHandle) -> io::Result<Self> {
+        let (completed, completion) = oneshot::channel();
+        let thread = thread::Builder::new()
+            .name("irtt-managed".to_owned())
+            .spawn(move || {
+                // Construct and destroy the runtime on its owning thread, including
+                // startup failures; never drop a runtime inside the frontend executor.
+                let outcome = (|| {
+                    let runtime = tokio::runtime::Builder::new_current_thread()
+                        .enable_all()
+                        .build()?;
+                    let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                        runtime.block_on(task)
+                    }));
+                    runtime.shutdown_timeout(Duration::from_millis(100));
+                    match outcome {
+                        Ok(outcome) => Ok(outcome),
+                        Err(panic) => std::panic::resume_unwind(panic),
+                    }
+                })();
+                let _ = completed.send(outcome);
+            })?;
+        Ok(Self {
+            handle,
+            thread: Some(thread),
+            completion,
+        })
+    }
+
+    pub(crate) async fn join(mut self) -> Result<ManagedOutcome, Box<dyn std::error::Error>> {
+        let outcome = (&mut self.completion).await;
+        self.join_thread()?;
+        Ok(outcome
+            .map_err(|_| io::Error::other("managed worker completed without an outcome"))??)
+    }
+
+    fn join_thread(&mut self) -> io::Result<()> {
+        self.thread
+            .take()
+            .expect("managed worker is joined once")
+            .join()
+            .map_err(|_| io::Error::other("managed worker thread panicked"))
+    }
+}
+
+impl Drop for ManagedWorker {
+    fn drop(&mut self) {
+        if self.thread.is_some() {
+            drop(self.handle.stop());
+            let _ = self.join_thread();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use irtt_client::managed::{
+        ManagedClient, ManagedClientConfig, ManagedCompletionPolicy, ManagedEndReason,
+    };
+
+    // The frontend executor must be able to stop a worker while awaiting its
+    // completion; a blocking join here would deadlock this current-thread runtime.
+    #[test]
+    fn completion_leaves_frontend_free_to_stop_and_preserves_outcome() {
+        let (task, handle) = ManagedClient::task(
+            ManagedClientConfig {
+                completion: ManagedCompletionPolicy::ExplicitStop,
+                ..Default::default()
+            },
+            vec![],
+        )
+        .unwrap();
+        let worker = ManagedWorker::start(task, handle.clone()).unwrap();
+        tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap()
+            .block_on(async {
+                let (outcome, ()) = tokio::time::timeout(Duration::from_secs(2), async {
+                    tokio::join!(worker.join(), handle.stop())
+                })
+                .await
+                .expect("worker completion must allow frontend stop");
+                let outcome = outcome.unwrap();
+                assert_eq!(outcome.end_reason, ManagedEndReason::StopRequested);
+                assert_eq!(handle.status().final_outcome.as_deref(), Some(&outcome));
+            });
+    }
+
+    // Cancelling the frontend's completion wait must stop and join the worker,
+    // rather than detaching an ongoing measurement task.
+    #[test]
+    fn cancelling_completion_stops_and_joins_worker() {
+        use std::{
+            future::Future,
+            task::{Context, Waker},
+        };
+        let (task, handle) = ManagedClient::task(
+            ManagedClientConfig {
+                completion: ManagedCompletionPolicy::ExplicitStop,
+                ..Default::default()
+            },
+            vec![],
+        )
+        .unwrap();
+        let worker = ManagedWorker::start(task, handle.clone()).unwrap();
+        let mut completion = Box::pin(worker.join());
+        assert!(completion
+            .as_mut()
+            .poll(&mut Context::from_waker(Waker::noop()))
+            .is_pending());
+        drop(completion);
+        assert_eq!(
+            handle.status().final_outcome.as_ref().unwrap().end_reason,
+            ManagedEndReason::StopRequested
+        );
+    }
+}