//! Disposable diagnosis: actual authenticated TLS/WS relay, controlled consumer delay; no GPU. use anyhow::Result; use notparsec_device_client::{initialize, remote::RemoteApi, request_registration}; use notparsec_session::remote::{self, DesktopSource}; use notparsec_wire::{remote::Input, video::{Codec, Event, Format, Packet}}; use std::{sync::{Arc,atomic::{AtomicUsize,Ordering}},time::{Duration,Instant}}; use tokio::sync::mpsc; use zeroize::Zeroizing; use axum::serve::ListenerExt; struct Source { format:Format, next:Instant, sequence:u64, payload:usize, idle:bool, input:Arc } impl DesktopSource for Source { fn format(&self)->Format { self.format.clone() } fn frame(&mut self)->Result> { if (self.idle && self.sequence>0) || Instant::now()Result<()> { if matches!(input,Input::ReleaseAll){self.input.fetch_add(1,Ordering::SeqCst);} Ok(()) } fn request_keyframe(&mut self)->Result<()> {Ok(())} fn set_bitrate(&mut self,bitrate:u32)->Result<()> {self.format.bitrate=bitrate;Ok(())} } async fn scenario(label:&str,idle:bool,consumer_delay_ms:u64)->Result<()> { let work=tempfile::tempdir()?; let db=notparsec_control_server::open_database(&work.path().join("control.db"))?; let listener=tokio::net::TcpListener::bind("127.0.0.1:0").await?; let origin=format!("http://{}",listener.local_addr()?); let router=notparsec_control_server::router(db.clone()); let server=tokio::spawn(async move { axum::serve(listener.tap_io(|s|{s.set_nodelay(true).unwrap();}),router).await.unwrap() }); let host=work.path().join("host");let client=work.path().join("client");let mut ids=Vec::new(); for (path,name) in [(&host,"diagnostic host"),(&client,"diagnostic viewer")] { initialize(path,&origin)?;let registration=request_registration(path,name).await?; notparsec_control_server::approve_enrollment(&db,®istration.device_id)?;ids.push(registration.device_id); } let password="disposable-diagnostic-password";notparsec_session::host::initialize(&host,password)?; let input=Arc::new(AtomicUsize::new(0));let host_input=input.clone(); let factory:remote::DesktopFactory=Arc::new(move |_|Ok(Box::new(Source{format:Format{codec:Codec::H264,width:1920,height:1080,fps:60,bitrate:10_000_000},next:Instant::now(),sequence:0,payload:16*1024,idle,input:host_input.clone()}))); let (stop,stopped)=tokio::sync::oneshot::channel();let(status,_)=std::sync::mpsc::channel(); let host_task=tokio::spawn(async move{remote::host(&host,factory,stopped,status).await}); let mut api=RemoteApi::connect(&client).await?; for _ in 0..80 {if !api.hosts().await?.is_empty(){break}tokio::time::sleep(Duration::from_millis(25)).await;} let connection=remote::connect(&mut api,&ids[0],Zeroizing::new(password.into())).await?; let session=connection.session; let (tx,rx)=mpsc::channel(128);let(frames,mut frame_rx)=mpsc::channel(2); let (metrics,mut metric_rx)=tokio::sync::watch::channel(remote::ClientMetrics::default()); let viewer=tokio::spawn(remote::receive_desktop_monitored(connection.stream,rx,frames,metrics)); let consumed=Arc::new(AtomicUsize::new(0));let c=consumed.clone(); let drain=tokio::spawn(async move{while let Some(event)=frame_rx.recv().await{if matches!(event,Event::Frame(_)){c.fetch_add(1,Ordering::SeqCst);if consumer_delay_ms>0{tokio::time::sleep(Duration::from_millis(consumer_delay_ms)).await;}}}}); let mut samples=Vec::new();let mut queues=Vec::new();let mut last=None;let end=tokio::time::sleep(Duration::from_secs(6));tokio::pin!(end); loop {tokio::select!{_=&mut end=>break,r=metric_rx.changed()=>{if r.is_err(){break}let s=metric_rx.borrow_and_update().clone();if let Some((rtt,at))=s.rtt{if Some(at)!=last{last=Some(at);samples.push(rtt.as_secs_f64()*1000.);}}if let Some((wait,_))=s.decoder_queue_wait{queues.push(wait.as_secs_f64()*1000.);}}}} let started=Instant::now();let before=input.load(Ordering::SeqCst);tx.send(Input::ReleaseAll).await?; let deadline=Instant::now()+Duration::from_secs(2);while input.load(Ordering::SeqCst)==before && Instant::now()before; println!("DIAGNOSTIC {{\"case\":\"{label}\",\"consumer_delay_ms\":{consumer_delay_ms},\"rtt_ms\":{samples:?},\"max_decoder_queue_ms\":{},\"consumed\":{},\"release_all_delivery_ms\":{},\"release_all_seen\":{input_seen}}}",queues.iter().copied().fold(0f64,f64::max),consumed.load(Ordering::SeqCst),started.elapsed().as_secs_f64()*1000.); assert!(!samples.is_empty(),"No RTT samples"); api.close(&session).await?;let _=stop.send(());viewer.abort();drain.abort();let _=tokio::time::timeout(Duration::from_secs(3),host_task).await;server.abort();Ok(()) } #[tokio::test(flavor="multi_thread",worker_threads=4)] async fn measure_actual_relay_with_controlled_decoder_backpressure()->Result<()> { scenario("idle",true,0).await?; scenario("60fps_16k_frames_fast_consumer",false,0).await?; scenario("60fps_16k_frames_50ms_consumer",false,50).await?;Ok(()) }