use crate::error::PipelineError;
use crate::frame::rows;
use crate::graph::{Graph, Kind, Node, Role};
use serde::Serialize;
use serde_json::Value;
use std::collections::HashMap;
use std::fmt::Display;
pub const OK: &str = "ok";
pub const ERROR: &str = "error";
pub const SKIPPED: &str = "skipped";
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct NodeRun {
pub id: String,
pub node: String,
pub status: String,
pub rows_in: usize,
pub rows_out: usize,
pub ms: u64,
#[serde(skip_serializing_if = "Option::is_none")]
pub error: Option<String>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub saved: Vec<String>,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct PipelineRun {
pub pipeline: String,
pub nodes: Vec<NodeRun>,
pub landed: Vec<(String, usize)>,
#[serde(skip)]
pub frames: HashMap<String, Value>,
}
impl PipelineRun {
pub fn ok(&self) -> bool {
self.nodes.iter().all(|n| n.status == OK)
}
}
pub trait Host<K> {
type Error: Display;
fn output(&mut self, node: &Node<K>, inputs: &[(String, Value)]) -> Result<Value, Self::Error>;
fn tee(&mut self, node: &Node<K>, tee: &str, frame: &Value) -> Result<String, Self::Error>;
fn produced(&mut self, _node: &Node<K>, _frame: &Value) {}
fn failed(&mut self, _node: &Node<K>, _error: &Self::Error) -> String {
ERROR.into()
}
fn finished(&mut self, _index: usize, _run: &NodeRun, _frame: Option<&Value>) {}
}
pub fn execute<K: Kind, H: Host<K>>(pipeline: &str, g: &Graph<K>, host: &mut H) -> Result<PipelineRun, PipelineError> {
let order = g.order()?;
let mut out = PipelineRun { pipeline: pipeline.to_string(), ..Default::default() };
for (i, id) in order.iter().enumerate() {
let Some(n) = g.node(id) else { continue };
let t = std::time::Instant::now();
let mut nr = NodeRun { id: id.clone(), node: n.kind.text(), status: OK.into(), ..Default::default() };
let ups: Vec<(String, Value)> =
g.ups(id).iter().filter_map(|e| out.frames.get(&e.from).map(|f| (e.name.clone().unwrap_or_else(|| e.from.clone()), f.clone()))).collect();
if g.ups(id).len() > ups.len() {
nr.status = SKIPPED.into();
nr.error = Some("an upstream node did not finish".into());
} else {
nr.rows_in = ups.iter().map(|(_, f)| rows(f)).sum();
match host.output(n, &ups) {
Ok(f) => {
nr.rows_out = rows(&f);
for tee in &n.tees {
match host.tee(n, tee, &f) {
Ok(m) => nr.saved.push(format!("{tee} → {m}")),
Err(e) => {
nr.status = ERROR.into();
nr.error = Some(format!("save {tee}: {e}"));
}
}
}
if n.kind.role() == Role::Sink {
out.landed.push((n.kind.target(), nr.rows_out));
}
host.produced(n, &f);
if nr.status == OK {
out.frames.insert(id.clone(), f);
}
}
Err(e) => {
nr.error = Some(e.to_string());
nr.status = host.failed(n, &e);
}
}
}
nr.ms = t.elapsed().as_millis() as u64;
host.finished(i, &nr, out.frames.get(id));
out.nodes.push(nr);
}
Ok(out)
}