//! 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<AtomicUsize> }
impl DesktopSource for Source {
fn format(&self)->Format { self.format.clone() }
fn frame(&mut self)->Result<Option<Packet>> {
if (self.idle && self.sequence>0) || Instant::now()<self.next { return Ok(None) }
self.next=Instant::now()+Duration::from_micros(16_667);
let sequence=self.sequence;self.sequence+=1;
Ok(Some(Packet{timing:None,sequence,time_100ns:(sequence*166667) as i64,keyframe:sequence==0,data:vec![0x65;self.payload]}))
}
fn input(&mut self,input:Input)->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()<deadline{tokio::time::sleep(Duration::from_millis(1)).await;}
let input_seen=input.load(Ordering::SeqCst)>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(())
}
데이터·검증 자료
evidence/network-latency/relay_latency_diagnostic.rs
design/evidence/network-latency/relay_latency_diagnostic.rs