use std::io::Write;
use std::path::Path;
use astrs_wire::{ControlRequest, DataId, InputSpec, NodeId, PortRef, QueuePolicy};
use crate::cli::QueuePolicyArg;
use crate::command::client::{Client, DataflowRef, Endpoint, runtime};
use crate::error::CliError;
fn read_node_fragment(
path: &Path,
dataflow: astrs_wire::DataflowId,
generation: u64,
) -> Result<astrs_wire::NodeSpawnSpec, CliError> {
let text = std::fs::read_to_string(path).map_err(|source| CliError::io(path, source))?;
Ok(astrs_coordinator::expand_node_fragment(
dataflow, generation, &text,
)?)
}
fn parse_node_id(flag: &'static str, value: &str) -> Result<NodeId, CliError> {
NodeId::new(value).map_err(|source| CliError::BadArgument {
flag,
value: value.to_owned(),
reason: source.to_string(),
})
}
#[derive(Debug, Clone)]
pub struct AddArgs {
pub dataflow: DataflowRef,
pub node_manifest: std::path::PathBuf,
pub start: bool,
pub json: bool,
}
pub fn add(out: &mut dyn Write, endpoint: &Endpoint, args: &AddArgs) -> Result<(), CliError> {
let runtime = runtime()?;
let node_id = runtime.block_on(async {
let mut client = Client::connect(endpoint).await?;
let dataflow = client.resolve(&args.dataflow).await?;
let spec = read_node_fragment(&args.node_manifest, dataflow, 0)?;
let node_id = spec.node.clone();
client
.request_ok(
"node add",
&ControlRequest::AddNode {
dataflow,
node: Box::new(spec),
start: args.start,
},
)
.await?;
Ok::<_, CliError>(node_id)
})?;
let text = format!(
"{node_id} added to {}{}",
args.dataflow,
if args.start { "" } else { " (not started)" }
);
emit(
out,
args.json,
&text,
|| serde_json::json!({ "ok": true, "node": node_id.as_str(), "started": args.start }),
);
Ok(())
}
#[derive(Debug, Clone)]
pub struct RemoveArgs {
pub dataflow: DataflowRef,
pub node_id: String,
pub grace: Option<f64>,
pub json: bool,
}
pub fn remove(out: &mut dyn Write, endpoint: &Endpoint, args: &RemoveArgs) -> Result<(), CliError> {
let node = parse_node_id("node-id", &args.node_id)?;
let grace = args.grace.map(|secs| {
astrs_wire::DurationMs::from_duration(std::time::Duration::from_secs_f64(secs))
});
let runtime = runtime()?;
runtime.block_on(async {
let mut client = Client::connect(endpoint).await?;
let dataflow = client.resolve(&args.dataflow).await?;
client
.request_ok(
"node remove",
&ControlRequest::RemoveNode {
dataflow,
node: node.clone(),
grace,
},
)
.await
})?;
let text = format!("{node} removed from {}", args.dataflow);
emit(
out,
args.json,
&text,
|| serde_json::json!({ "ok": true, "node": node.as_str() }),
);
Ok(())
}
#[derive(Debug, Clone)]
pub struct ReplaceArgs {
pub dataflow: DataflowRef,
pub node_id: String,
pub node_manifest: std::path::PathBuf,
pub drain: bool,
pub json: bool,
}
pub fn replace(
out: &mut dyn Write,
endpoint: &Endpoint,
args: &ReplaceArgs,
) -> Result<(), CliError> {
let target = parse_node_id("node-id", &args.node_id)?;
let runtime = runtime()?;
runtime.block_on(async {
let mut client = Client::connect(endpoint).await?;
let dataflow = client.resolve(&args.dataflow).await?;
let mut spec = read_node_fragment(&args.node_manifest, dataflow, 0)?;
spec.node = target.clone();
client
.request_ok(
"node replace",
&ControlRequest::ReplaceNode {
dataflow,
node: Box::new(spec),
drain: args.drain,
},
)
.await
})?;
let text = format!("{target} in {} replaced", args.dataflow);
emit(
out,
args.json,
&text,
|| serde_json::json!({ "ok": true, "node": target.as_str() }),
);
Ok(())
}
#[derive(Debug, Clone)]
pub struct ConnectArgs {
pub dataflow: DataflowRef,
pub node_id: String,
pub input: String,
pub source: String,
pub queue_size: Option<u32>,
pub queue_policy: Option<QueuePolicyArg>,
pub json: bool,
}
pub fn connect(
out: &mut dyn Write,
endpoint: &Endpoint,
args: &ConnectArgs,
) -> Result<(), CliError> {
let consumer = parse_node_id("node-id", &args.node_id)?;
let input_id = DataId::new(&args.input).map_err(|source| CliError::BadArgument {
flag: "input",
value: args.input.clone(),
reason: source.to_string(),
})?;
let source: PortRef = args.source.parse().map_err(|_| CliError::BadArgument {
flag: "source",
value: args.source.clone(),
reason: "expected a `node/output` port reference".to_owned(),
})?;
let mut input = InputSpec::new(input_id, source);
if let Some(size) = args.queue_size {
input.queue_size = size;
}
input.queue_policy = match args.queue_policy {
Some(QueuePolicyArg::Backpressure) => QueuePolicy::Backpressure,
Some(QueuePolicyArg::DropOldest) | None => QueuePolicy::DropOldest,
};
let runtime = runtime()?;
runtime.block_on(async {
let mut client = Client::connect(endpoint).await?;
let dataflow = client.resolve(&args.dataflow).await?;
client
.request_ok(
"node connect",
&ControlRequest::AddEdge {
dataflow,
consumer: consumer.clone(),
input: input.clone(),
},
)
.await
})?;
let text = format!(
"{consumer}.{} in {} now reads from {}",
args.input, args.dataflow, input.source
);
emit(out, args.json, &text, || {
serde_json::json!({
"ok": true,
"node": consumer.as_str(),
"input": args.input,
"source": input.source.to_string(),
})
});
Ok(())
}
#[derive(Debug, Clone)]
pub struct DisconnectArgs {
pub dataflow: DataflowRef,
pub node_id: String,
pub input: String,
pub json: bool,
}
pub fn disconnect(
out: &mut dyn Write,
endpoint: &Endpoint,
args: &DisconnectArgs,
) -> Result<(), CliError> {
let consumer = parse_node_id("node-id", &args.node_id)?;
let input_id = DataId::new(&args.input).map_err(|source| CliError::BadArgument {
flag: "input",
value: args.input.clone(),
reason: source.to_string(),
})?;
let runtime = runtime()?;
runtime.block_on(async {
let mut client = Client::connect(endpoint).await?;
let dataflow = client.resolve(&args.dataflow).await?;
client
.request_ok(
"node disconnect",
&ControlRequest::RemoveEdge {
dataflow,
consumer: consumer.clone(),
input: input_id.clone(),
},
)
.await
})?;
let text = format!(
"{consumer}.{} in {} disconnected",
args.input, args.dataflow
);
emit(
out,
args.json,
&text,
|| serde_json::json!({ "ok": true, "node": consumer.as_str(), "input": args.input }),
);
Ok(())
}
fn emit(out: &mut dyn Write, json: bool, text: &str, value: impl FnOnce() -> serde_json::Value) {
if json {
let _ = writeln!(out, "{}", value());
} else {
let _ = writeln!(out, "{text}");
}
let _ = out.flush();
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
fn scratch(name: &str) -> std::path::PathBuf {
let dir =
std::env::temp_dir().join(format!("astrs-cli-node-{}-{name}", std::process::id()));
let _ = std::fs::create_dir_all(&dir);
dir
}
fn write_fragment(dir: &Path, name: &str, yaml: &str) -> std::path::PathBuf {
let path = dir.join(name);
std::fs::write(&path, yaml).unwrap();
path
}
fn dead_endpoint() -> Endpoint {
Endpoint::new(
std::net::SocketAddr::from(([127, 0, 0, 1], 1)),
astrs_wire::AuthToken::ZERO,
)
}
#[test]
fn read_node_fragment_expands_a_bare_node_yaml() {
let dir = scratch("fragment");
let path = write_fragment(
&dir,
"extra.yml",
"id: extra\npath: ./extra\noutputs: [out]\n",
);
let spec = read_node_fragment(&path, astrs_wire::DataflowId::generate(), 0).unwrap();
assert_eq!(spec.node.as_str(), "extra");
assert_eq!(spec.outputs.len(), 1);
}
#[test]
fn read_node_fragment_reports_a_missing_file() {
let err = read_node_fragment(
Path::new("/does/not/exist/node.yml"),
astrs_wire::DataflowId::generate(),
0,
)
.unwrap_err();
assert!(matches!(err, CliError::Io { .. }));
}
#[test]
fn read_node_fragment_reports_a_malformed_fragment() {
let dir = scratch("bad-fragment");
let path = write_fragment(&dir, "bad.yml", "not: [valid");
let err = read_node_fragment(&path, astrs_wire::DataflowId::generate(), 0).unwrap_err();
assert!(matches!(err, CliError::Coordinator(_)));
}
#[test]
fn parse_node_id_names_the_offending_flag() {
let err = parse_node_id("node-id", "not a legal id!").unwrap_err();
match err {
CliError::BadArgument { flag, value, .. } => {
assert_eq!(flag, "node-id");
assert_eq!(value, "not a legal id!");
}
other => panic!("unexpected {other:?}"),
}
}
#[test]
fn add_against_no_cluster_reports_no_cluster_not_a_panic() {
let dir = scratch("add-no-cluster");
let path = write_fragment(&dir, "extra.yml", "id: extra\npath: ./extra\n");
let mut out = Vec::new();
let err = add(
&mut out,
&dead_endpoint(),
&AddArgs {
dataflow: DataflowRef::parse("flow"),
node_manifest: path,
start: true,
json: false,
},
)
.unwrap_err();
assert!(matches!(
err,
CliError::NoCluster { .. } | CliError::Transport(_)
));
}
#[test]
fn remove_rejects_a_malformed_node_id_before_dialling_anything() {
let mut out = Vec::new();
let err = remove(
&mut out,
&dead_endpoint(),
&RemoveArgs {
dataflow: DataflowRef::parse("flow"),
node_id: "not a legal id!".to_owned(),
grace: None,
json: false,
},
)
.unwrap_err();
assert!(matches!(err, CliError::BadArgument { .. }));
assert!(out.is_empty(), "a rejected argument must print nothing");
}
#[test]
fn connect_rejects_a_malformed_source_before_dialling_anything() {
let mut out = Vec::new();
let err = connect(
&mut out,
&dead_endpoint(),
&ConnectArgs {
dataflow: DataflowRef::parse("flow"),
node_id: "detector".to_owned(),
input: "frames".to_owned(),
source: "not-a-port-ref".to_owned(),
queue_size: None,
queue_policy: None,
json: false,
},
)
.unwrap_err();
assert!(matches!(err, CliError::BadArgument { flag: "source", .. }));
}
#[test]
fn disconnect_rejects_a_malformed_input_before_dialling_anything() {
let mut out = Vec::new();
let err = disconnect(
&mut out,
&dead_endpoint(),
&DisconnectArgs {
dataflow: DataflowRef::parse("flow"),
node_id: "detector".to_owned(),
input: "not a legal id!".to_owned(),
json: false,
},
)
.unwrap_err();
assert!(matches!(err, CliError::BadArgument { flag: "input", .. }));
}
}