#![allow(dead_code)]
use std::net::SocketAddr;
use rustress::core::Config;
use rustress::core::constants::STATS_CHANNEL_CAPACITY;
use rustress::core::snapshot::StatsSnapshot;
use rustress::dummy::DummyServer;
use rustress::runner::LoadEngine;
use tokio::sync::mpsc;
use tokio_util::sync::CancellationToken;
pub async fn start_target() -> anyhow::Result<String> {
let listener = tokio::net::TcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).await?;
let addr = listener.local_addr()?;
let router = DummyServer::router();
tokio::spawn(async move {
let _ = axum::serve(listener, router).await;
});
Ok(format!("http://{addr}"))
}
pub async fn run_to_completion(cfg: Config) -> anyhow::Result<StatsSnapshot> {
let (tx, rx) = mpsc::channel(STATS_CHANNEL_CAPACITY);
let engine = LoadEngine::new(cfg, tx)?;
let stats = engine.stats().clone();
let mut rx = rx;
let drain = tokio::spawn(async move { while rx.recv().await.is_some() {} });
engine.run(CancellationToken::new()).await;
drain.abort();
Ok(stats.snapshot())
}
pub fn report(label: &str, snap: &StatsSnapshot) {
println!("\n{label}");
println!(" requests {}", snap.requests);
println!(" success {}", snap.success);
println!(" failed {}", snap.fail);
println!(" bytes {}", snap.bytes);
println!(
" latency p50 {:.2}ms p95 {:.2}ms p99 {:.2}ms max {:.2}ms",
snap.p50_service_ms, snap.p95_service_ms, snap.p99_service_ms, snap.max_service_ms
);
if snap.dropped_scheduled > 0 {
println!(
" NOTE: {} request(s) were shed because the generator saturated.",
snap.dropped_scheduled
);
println!(" Latency figures above do not describe the target.");
}
}