use std::io::Write;
use astrs_wire::{ControlRequest, PortRef};
use crate::command::client::{Client, DataflowRef, Endpoint, runtime};
use crate::error::CliError;
#[derive(Debug, Clone)]
pub struct StartArgs {
pub dataflow: String,
pub output: String,
pub only: Vec<String>,
pub overwrite: bool,
pub json: bool,
}
pub fn start(out: &mut dyn Write, endpoint: &Endpoint, args: &StartArgs) -> Result<(), CliError> {
let ports = parse_ports(&args.only)?;
let reference = DataflowRef::parse(&args.dataflow);
let runtime = runtime()?;
let dataflow = runtime.block_on(async {
let mut client = Client::connect(endpoint).await?;
let dataflow = client.resolve(&reference).await?;
client
.request_ok(
"record start",
&ControlRequest::RecordStart {
dataflow,
path: args.output.clone(),
ports: ports.clone(),
overwrite: args.overwrite,
},
)
.await?;
Ok::<_, CliError>(dataflow)
})?;
if args.json {
emit_json(
out,
&serde_json::json!({
"dataflow": dataflow.to_string(),
"output": args.output,
"ports": ports.iter().map(ToString::to_string).collect::<Vec<_>>(),
}),
);
} else {
let _ = writeln!(out, "recording {dataflow} to {}", args.output);
let _ = out.flush();
}
Ok(())
}
#[derive(Debug, Clone)]
pub struct StopArgs {
pub dataflow: String,
pub json: bool,
}
pub fn stop(out: &mut dyn Write, endpoint: &Endpoint, args: &StopArgs) -> Result<(), CliError> {
let reference = DataflowRef::parse(&args.dataflow);
let runtime = runtime()?;
let dataflow = runtime.block_on(async {
let mut client = Client::connect(endpoint).await?;
let dataflow = client.resolve(&reference).await?;
client
.request_ok("record stop", &ControlRequest::RecordStop { dataflow })
.await?;
Ok::<_, CliError>(dataflow)
})?;
if args.json {
emit_json(
out,
&serde_json::json!({ "dataflow": dataflow.to_string() }),
);
} else {
let _ = writeln!(out, "stopped recording {dataflow}");
let _ = out.flush();
}
Ok(())
}
fn parse_ports(only: &[String]) -> Result<Vec<PortRef>, CliError> {
only.iter()
.map(|text| {
text.parse::<PortRef>()
.map_err(|error| CliError::BadArgument {
flag: "only",
value: text.clone(),
reason: error.to_string(),
})
})
.collect()
}
fn emit_json(out: &mut dyn Write, value: &serde_json::Value) {
let _ = writeln!(
out,
"{}",
serde_json::to_string_pretty(value).unwrap_or_else(|_| "{}".to_owned())
);
let _ = out.flush();
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
#[test]
fn parse_ports_accepts_well_formed_entries() {
let ports =
parse_ports(&["camera/frames".to_string(), "detector/boxes".to_string()]).unwrap();
assert_eq!(ports.len(), 2);
assert_eq!(ports[0].to_string(), "camera/frames");
}
#[test]
fn parse_ports_is_empty_for_an_empty_list() {
assert!(parse_ports(&[]).unwrap().is_empty());
}
#[test]
fn parse_ports_rejects_a_malformed_entry() {
let error = parse_ports(&["not a port".to_string()]).unwrap_err();
assert!(matches!(error, CliError::BadArgument { flag: "only", .. }));
}
}