fix(cli): drive single-target runs with ManagedClient

Replace the manual single-target ClientSession loops in the stream and TUI adapters with ManagedClient::start_with_subscription so the existing worker owns opening, deadline-aware pacing, receive handling, timeout polling, draining, and close.

Use bounded subscription waits for interruption and input polling, drain queued events before and after join, and report per-subscription drops without changing output, statistics, labels, summaries, warning, or peer-close policy. Add process and unit regressions for 10 ms cadence, interruption, final-event draining, TUI terminal state, and overflow visibility.

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

@@ -1,146 +1,11 @@
-use std::{
-    sync::atomic::{AtomicBool, Ordering},
-    thread,
-    time::{Duration, Instant},
-};
+use std::sync::atomic::{AtomicBool, Ordering};
 
-use irtt_client::{
-    Client, ClientConfig, ClientEvent, ManagedTargetEndReason, OpenOutcome, RecvBudget,
-};
-
-pub const RECV_BUDGET: RecvBudget = RecvBudget { max_packets: 16 };
-const MAX_FINAL_DRAIN: Duration = Duration::from_secs(30);
-const IDLE_SLEEP: Duration = Duration::from_millis(5);
-const MAX_SLEEP: Duration = Duration::from_millis(20);
-
-pub struct ClientSession {
-    client: Client,
-    continuous: bool,
-}
-
-impl ClientSession {
-    pub fn connect(
-        config: ClientConfig,
-        continuous: bool,
-    ) -> Result<Self, irtt_client::ClientError> {
-        Ok(Self {
-            client: Client::connect(config)?,
-            continuous,
-        })
-    }
-
-    pub fn open(&mut self) -> Result<Vec<ClientEvent>, irtt_client::ClientError> {
-        Ok(vec![open_event(&self.client.open()?).clone()])
-    }
-
-    pub fn step(
-        &mut self,
-        shutdown_requested: &AtomicBool,
-    ) -> Result<Vec<ClientEvent>, irtt_client::ClientError> {
-        let mut events = Vec::new();
-        if should_send_probe(self.client.next_send_deadline(), shutdown_requested) {
-            events.extend(self.client.send_probe()?);
-        }
-        events.extend(self.client.recv_available(RECV_BUDGET)?);
-        if self.client.is_peer_closed() {
-            return Ok(events);
-        }
-        events.extend(self.client.poll_timeouts()?);
-        Ok(events)
-    }
-
-    pub fn should_continue(&self, shutdown_requested: &AtomicBool) -> bool {
-        !is_shutdown_requested(shutdown_requested)
-            && !self.client.is_peer_closed()
-            && (self.continuous || self.client.next_send_deadline().is_some())
-    }
-
-    pub fn should_drain_final(&self, interrupted: bool) -> bool {
-        should_drain_final(self.continuous, interrupted)
-    }
-
-    pub fn drain_final<F>(&mut self, mut on_events: F) -> Result<(), irtt_client::ClientError>
-    where
-        F: FnMut(&[ClientEvent]),
-    {
-        let deadline = Instant::now() + final_drain_duration(self.client.probe_timeout());
-        loop {
-            if self.client.is_peer_closed() {
-                break;
-            }
-
-            let mut received = false;
-
-            let events = self.client.recv_available(RECV_BUDGET)?;
-            received |= !events.is_empty();
-            on_events(&events);
-
-            if self.client.is_peer_closed() {
-                break;
-            }
-
-            let events = self.client.poll_timeouts()?;
-            received |= !events.is_empty();
-            on_events(&events);
-
-            if self.client.is_run_complete() || Instant::now() >= deadline {
-                break;
-            }
-
-            if !received {
-                thread::sleep(IDLE_SLEEP);
-            }
-        }
-        Ok(())
-    }
-
-    pub fn poll_timeouts(&mut self) -> Result<Vec<ClientEvent>, irtt_client::ClientError> {
-        if self.client.is_peer_closed() {
-            return Ok(vec![]);
-        }
-        self.client.poll_timeouts()
-    }
-
-    pub fn close(&mut self) -> Result<Vec<ClientEvent>, irtt_client::ClientError> {
-        if self.client.is_peer_closed() {
-            return Ok(vec![]);
-        }
-        self.client.close()
-    }
-
-    pub fn is_peer_closed(&self) -> bool {
-        self.client.is_peer_closed()
-    }
-
-    pub fn next_send_deadline(&self) -> Option<Instant> {
-        self.client.next_send_deadline()
-    }
-
-    pub fn probe_timeout(&self) -> Duration {
-        self.client.probe_timeout()
-    }
-
-    pub fn sleep_until_next_send(&self) {
-        let sleep_for = match self.next_send_deadline() {
-            Some(deadline) => deadline
-                .saturating_duration_since(Instant::now())
-                .min(MAX_SLEEP),
-            None => Duration::from_millis(1),
-        };
-        if !sleep_for.is_zero() {
-            thread::sleep(sleep_for);
-        }
-    }
-}
+use irtt_client::ManagedTargetEndReason;
 
 pub fn is_shutdown_requested(shutdown_requested: &AtomicBool) -> bool {
     shutdown_requested.load(Ordering::Relaxed)
 }
 
-pub fn should_drain_final(continuous: bool, interrupted: bool) -> bool {
-    !continuous || interrupted
-}
-
 pub fn should_print_final_summary(continuous: bool, interrupted: bool) -> bool {
     !continuous || interrupted
 }
@@ -180,67 +45,9 @@ pub fn request_group_stop_once(stop_requested: &mut bool) -> bool {
     true
 }
 
-pub fn final_drain_duration(probe_timeout: Duration) -> Duration {
-    probe_timeout.min(MAX_FINAL_DRAIN)
-}
-
-fn should_send_probe(next_send_deadline: Option<Instant>, shutdown_requested: &AtomicBool) -> bool {
-    !is_shutdown_requested(shutdown_requested)
-        && next_send_deadline.is_some_and(|deadline| deadline <= Instant::now())
-}
-
-fn open_event(outcome: &OpenOutcome) -> &ClientEvent {
-    match outcome {
-        OpenOutcome::Started { event, .. } | OpenOutcome::NoTestCompleted { event, .. } => event,
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use irtt_proto::{
-        echo_packet_len,
-        flags::{self, FLAG_OPEN, FLAG_REPLY},
-        layout::PacketLayout,
-        Clock, Params, ReceivedStats, StampAt, TimestampFields, MAGIC, PROTOCOL_VERSION,
-    };
-    use std::{
-        net::{SocketAddr, UdpSocket},
-        thread::JoinHandle,
-    };
-
-    const TOKEN: u64 = 0x1234_5678_90ab_cdef;
-
-    struct FakeServer {
-        addr: SocketAddr,
-        done: JoinHandle<()>,
-    }
-
-    impl FakeServer {
-        fn join(self) {
-            self.done.join().unwrap();
-        }
-    }
-
-    #[test]
-    fn final_drain_uses_capped_probe_timeout() {
-        assert_eq!(
-            final_drain_duration(Duration::from_secs(4)),
-            Duration::from_secs(4)
-        );
-        assert_eq!(
-            final_drain_duration(Duration::from_secs(60)),
-            Duration::from_secs(30)
-        );
-    }
-
-    #[test]
-    fn should_drain_final_for_finite_or_interrupted_runs() {
-        assert!(should_drain_final(false, false));
-        assert!(should_drain_final(false, true));
-        assert!(should_drain_final(true, true));
-        assert!(!should_drain_final(true, false));
-    }
 
     #[test]
     fn peer_close_run_error_is_run_mode_and_interruption_aware() {
@@ -284,172 +91,4 @@ mod tests {
         assert!(request_group_stop_once(&mut stop_requested));
         assert!(!request_group_stop_once(&mut stop_requested));
     }
-
-    #[test]
-    fn peer_close_followed_by_session_cleanup_is_successful() {
-        let params = test_params(None, Duration::from_millis(10));
-        let server = start_peer_close_server(params);
-        let mut session = ClientSession::connect(config(server.addr, None), true).unwrap();
-        let shutdown_requested = AtomicBool::new(false);
-
-        assert!(matches!(
-            session.open().unwrap().as_slice(),
-            [ClientEvent::SessionStarted { .. }]
-        ));
-
-        let events = session.step(&shutdown_requested).unwrap();
-        assert!(events
-            .iter()
-            .any(|event| matches!(event, ClientEvent::EchoReply { .. })));
-        assert!(events
-            .iter()
-            .any(|event| matches!(event, ClientEvent::SessionClosed { .. })));
-        assert!(!session.should_continue(&shutdown_requested));
-        assert!(session.is_peer_closed());
-
-        session.drain_final(|_| {}).unwrap();
-        assert!(session.poll_timeouts().unwrap().is_empty());
-        assert!(session.close().unwrap().is_empty());
-        server.join();
-    }
-
-    fn config(addr: SocketAddr, duration: Option<Duration>) -> ClientConfig {
-        ClientConfig {
-            server_addr: addr.to_string(),
-            duration,
-            interval: Duration::from_millis(10),
-            open_timeouts: vec![Duration::from_millis(200)],
-            probe_timeout: Duration::from_millis(20),
-            socket_config: irtt_client::SocketConfig {
-                recv_timeout: Some(Duration::from_millis(200)),
-                ..Default::default()
-            },
-            ..ClientConfig::default()
-        }
-    }
-
-    fn test_params(duration: Option<Duration>, interval: Duration) -> Params {
-        Params {
-            protocol_version: PROTOCOL_VERSION,
-            duration_ns: duration.map_or(0, test_duration_ns_i64),
-            interval_ns: test_duration_ns_i64(interval),
-            length: 0,
-            received_stats: ReceivedStats::Both,
-            stamp_at: StampAt::Both,
-            clock: Clock::Both,
-            dscp: 0,
-            server_fill: None,
-        }
-    }
-
-    fn test_duration_ns_i64(duration: Duration) -> i64 {
-        i64::try_from(duration.as_nanos()).expect("test duration fits i64 nanoseconds")
-    }
-
-    fn start_peer_close_server(params: Params) -> FakeServer {
-        let socket = UdpSocket::bind("127.0.0.1:0").unwrap();
-        let addr = socket.local_addr().unwrap();
-        let done = thread::spawn(move || {
-            let (_, peer) = recv_request(&socket);
-            socket
-                .send_to(&open_reply(FLAG_OPEN | FLAG_REPLY, TOKEN, &params), peer)
-                .unwrap();
-
-            let (packet, peer) = recv_request(&socket);
-            let seq = u32::from_le_bytes(packet[12..16].try_into().unwrap());
-            socket
-                .send_to(
-                    &echo_reply_packet(
-                        TOKEN,
-                        seq,
-                        &params,
-                        &TimestampFields::default(),
-                        FLAG_REPLY | flags::FLAG_CLOSE,
-                    ),
-                    peer,
-                )
-                .unwrap();
-
-            socket
-                .set_read_timeout(Some(Duration::from_millis(250)))
-                .unwrap();
-            if let Some((packet, _)) = recv_request_timeout(&socket) {
-                panic!(
-                    "session cleanup must not send any packet after peer close; flags={:?} len={}",
-                    packet.get(3).copied(),
-                    packet.len()
-                );
-            }
-        });
-        FakeServer { addr, done }
-    }
-
-    fn recv_request(socket: &UdpSocket) -> (Vec<u8>, SocketAddr) {
-        let mut buf = [0_u8; 2048];
-        let (size, peer) = socket.recv_from(&mut buf).unwrap();
-        (buf[..size].to_vec(), peer)
-    }
-
-    fn recv_request_timeout(socket: &UdpSocket) -> Option<(Vec<u8>, SocketAddr)> {
-        let mut buf = [0_u8; 2048];
-        socket
-            .recv_from(&mut buf)
-            .ok()
-            .map(|(size, peer)| (buf[..size].to_vec(), peer))
-    }
-
-    fn open_reply(flags: u8, token: u64, params: &Params) -> Vec<u8> {
-        let mut packet = Vec::new();
-        packet.extend_from_slice(&MAGIC);
-        packet.push(flags);
-        packet.extend_from_slice(&token.to_le_bytes());
-        packet.extend_from_slice(&params.encode());
-        packet
-    }
-
-    fn echo_reply_packet(
-        token: u64,
-        seq: u32,
-        params: &Params,
-        timestamps: &TimestampFields,
-        flags: u8,
-    ) -> Vec<u8> {
-        let layout = PacketLayout::echo(false, params);
-        let packet_len = echo_packet_len(false, params)
-            .expect("session test params must have a non-negative packet length");
-        let mut packet = Vec::with_capacity(packet_len);
-
-        packet.extend_from_slice(&MAGIC);
-        packet.push(flags);
-        packet.extend_from_slice(&token.to_le_bytes());
-        packet.extend_from_slice(&seq.to_le_bytes());
-
-        if layout.recv_count {
-            packet.extend_from_slice(&42_u32.to_le_bytes());
-        }
-        if layout.recv_window {
-            packet.extend_from_slice(&0_u64.to_le_bytes());
-        }
-        if layout.recv_wall {
-            packet.extend_from_slice(&timestamps.recv_wall.unwrap_or(0).to_le_bytes());
-        }
-        if layout.recv_mono {
-            packet.extend_from_slice(&timestamps.recv_mono.unwrap_or(0).to_le_bytes());
-        }
-        if layout.midpoint_wall {
-            packet.extend_from_slice(&timestamps.midpoint_wall.unwrap_or(0).to_le_bytes());
-        }
-        if layout.midpoint_mono {
-            packet.extend_from_slice(&timestamps.midpoint_mono.unwrap_or(0).to_le_bytes());
-        }
-        if layout.send_wall {
-            packet.extend_from_slice(&timestamps.send_wall.unwrap_or(0).to_le_bytes());
-        }
-        if layout.send_mono {
-            packet.extend_from_slice(&timestamps.send_mono.unwrap_or(0).to_le_bytes());
-        }
-
-        packet.resize(packet_len, 0);
-        packet
-    }
 }