use std::sync::Arc;
use tokio::sync::mpsc;
use tokio::task::JoinHandle;
use tokio_util::sync::CancellationToken;
use crate::core::config::Config;
use crate::core::constants::STATS_CHANNEL_CAPACITY;
use crate::core::snapshot::StatsSnapshot;
use crate::runner::LoadEngine;
use crate::runner::stats::RunStats;
#[derive(Default)]
pub struct RunController {
handle: Option<JoinHandle<()>>,
cancel: Option<CancellationToken>,
stats_rx: Option<mpsc::Receiver<StatsSnapshot>>,
stats: Option<Arc<RunStats>>,
}
impl RunController {
pub fn new() -> Self {
Self::default()
}
pub fn start(&mut self, cfg: Config) -> Result<(), Vec<String>> {
if self.is_running() {
return Err(vec!["a run is already in progress".to_string()]);
}
let (tx, rx) = mpsc::channel(STATS_CHANNEL_CAPACITY);
let engine = LoadEngine::new(cfg, tx).map_err(|e| vec![e.to_string()])?;
let stats = Arc::clone(engine.stats());
let cancel = CancellationToken::new();
let handle = tokio::spawn({
let cancel = cancel.clone();
async move {
engine.run(cancel).await;
}
});
self.stats = Some(stats);
self.handle = Some(handle);
self.cancel = Some(cancel);
self.stats_rx = Some(rx);
Ok(())
}
pub fn poll(&mut self) -> Option<StatsSnapshot> {
let rx = self.stats_rx.as_mut()?;
let mut newest = None;
while let Ok(snap) = rx.try_recv() {
newest = Some(snap);
}
newest
}
pub fn stop(&mut self) {
if let Some(cancel) = self.cancel.as_ref() {
cancel.cancel();
}
}
pub async fn shutdown(&mut self) {
self.stop();
if let Some(handle) = self.handle.take() {
let _ = handle.await;
}
self.cancel = None;
self.stats_rx = None;
}
pub fn is_running(&self) -> bool {
self.handle.as_ref().is_some_and(|h| !h.is_finished())
}
pub fn stats(&self) -> Option<&Arc<RunStats>> {
self.stats.as_ref()
}
}