use std::net::{SocketAddr, ToSocketAddrs};
use std::path::Path;
use std::sync::atomic::{AtomicU64, Ordering};
use std::time::Duration;
use astrs_transport::{ConnectionCounters, FramedStream, HandshakeParams, LocalIdentity, initiate};
use astrs_wire::{
AuthToken, ControlReply, ControlRequest, DataflowId, DataflowSummary, FeatureFlags, Frame,
FrameKind, FrameLimits, Role, SessionId, SubscriptionId,
};
use tokio::net::TcpStream;
use crate::error::CliError;
pub const HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(10);
pub const REQUEST_TIMEOUT: Duration = Duration::from_secs(30);
#[derive(Debug, Clone)]
pub struct Endpoint {
pub addr: SocketAddr,
pub token: AuthToken,
pub display: String,
}
impl Endpoint {
#[must_use]
pub fn new(addr: SocketAddr, token: AuthToken) -> Self {
Self {
addr,
token,
display: addr.to_string(),
}
}
}
pub fn resolve_addr(argument: Option<&str>) -> Result<SocketAddr, CliError> {
let text = match argument {
Some(text) => text.to_owned(),
None => match std::env::var(crate::runtime_dir::ENV_COORDINATOR_ADDR) {
Ok(value) if !value.trim().is_empty() => value,
_ => format!("127.0.0.1:{}", default_port()),
},
};
resolve_text(&text)
}
#[must_use]
pub fn default_port() -> u16 {
std::env::var(astrs_coordinator::ENV_COORDINATOR_PORT)
.ok()
.and_then(|value| value.trim().parse::<u16>().ok())
.unwrap_or(astrs_coordinator::DEFAULT_COORDINATOR_PORT)
}
pub fn resolve_text(text: &str) -> Result<SocketAddr, CliError> {
let trimmed = text.trim();
if trimmed.is_empty() {
return Err(CliError::BadAddress {
input: text.to_owned(),
reason: "the address is empty".to_owned(),
});
}
if let Ok(port) = trimmed.parse::<u16>() {
return Ok(SocketAddr::from(([127, 0, 0, 1], port)));
}
let candidate = if trimmed.contains(':') && !trimmed.ends_with(':') {
trimmed.to_owned()
} else {
format!("{}:{}", trimmed.trim_end_matches(':'), default_port())
};
let mut resolved = candidate
.to_socket_addrs()
.map_err(|error| CliError::BadAddress {
input: text.to_owned(),
reason: error.to_string(),
})?;
resolved.next().ok_or_else(|| CliError::BadAddress {
input: text.to_owned(),
reason: "the name resolved to no addresses".to_owned(),
})
}
pub fn endpoint(
coordinator: Option<&str>,
token: Option<&str>,
token_file: Option<&Path>,
working_dir: Option<&Path>,
require_token: bool,
) -> Result<Endpoint, CliError> {
let addr = resolve_addr(coordinator)?;
let dir = crate::runtime_dir::working_dir(working_dir);
let found = crate::runtime_dir::find_token(token, token_file, &dir)?;
let token = match found {
Some((token, _)) => token,
None if require_token => {
return Err(CliError::NoToken {
env: crate::runtime_dir::ENV_TOKEN,
file: crate::runtime_dir::TOKEN_FILE,
});
}
None => AuthToken::ZERO,
};
Ok(Endpoint {
display: coordinator.map_or_else(|| addr.to_string(), ToOwned::to_owned),
addr,
token,
})
}
#[derive(Debug)]
pub struct Client {
stream: FramedStream<TcpStream>,
session: SessionId,
display: String,
}
impl Client {
pub async fn connect(endpoint: &Endpoint) -> Result<Self, CliError> {
let raw = TcpStream::connect(endpoint.addr).await.map_err(|error| {
if matches!(
error.kind(),
std::io::ErrorKind::ConnectionRefused | std::io::ErrorKind::TimedOut
) {
CliError::NoCluster {
detail: format!("nothing answered at {}: {error}", endpoint.display),
}
} else {
CliError::io(&endpoint.display, error)
}
})?;
let _ = raw.set_nodelay(true);
let mut stream =
FramedStream::new(raw, FrameLimits::network(), ConnectionCounters::shared());
let params = HandshakeParams::new(LocalIdentity::new(Role::Cli), endpoint.token.clone())
.with_features(FeatureFlags::EMPTY);
let handshake = initiate(&mut stream, ¶ms, HANDSHAKE_TIMEOUT).await?;
Ok(Self {
stream,
session: handshake.session.session_id,
display: endpoint.display.clone(),
})
}
#[must_use]
pub const fn session(&self) -> SessionId {
self.session
}
#[must_use]
pub fn display(&self) -> &str {
&self.display
}
pub async fn request(
&mut self,
label: &'static str,
request: &ControlRequest,
) -> Result<ControlReply, CliError> {
self.stream.send_message(request).await?;
let reply = tokio::time::timeout(
REQUEST_TIMEOUT,
self.stream
.expect_message::<ControlReply>(FrameKind::ControlReply),
)
.await
.map_err(|_| astrs_transport::TransportError::Timeout {
operation: "control reply",
timeout: REQUEST_TIMEOUT,
})??;
match reply {
ControlReply::Error {
message, context, ..
} => Err(CliError::Refused {
request: label,
message: if context.is_empty() {
message
} else {
format!("{message} ({})", context.join("; "))
},
}),
other => Ok(other),
}
}
pub async fn request_ok(
&mut self,
label: &'static str,
request: &ControlRequest,
) -> Result<(), CliError> {
match self.request(label, request).await? {
ControlReply::Ok => Ok(()),
other => Err(CliError::UnexpectedReply {
request: label,
reply: reply_name(&other),
}),
}
}
pub async fn next_frame(&mut self) -> Result<Option<Frame>, CliError> {
Ok(self.stream.recv_frame().await?)
}
pub async fn close(self) -> Result<(), CliError> {
let (_, mut writer) = self.stream.into_halves();
writer.shutdown().await?;
Ok(())
}
pub async fn list_dataflows(&mut self, all: bool) -> Result<Vec<DataflowSummary>, CliError> {
match self.request("list", &ControlRequest::List { all }).await? {
ControlReply::DataflowList { dataflows, .. } => Ok(dataflows),
other => Err(CliError::UnexpectedReply {
request: "list",
reply: reply_name(&other),
}),
}
}
pub async fn resolve(&mut self, reference: &DataflowRef) -> Result<DataflowId, CliError> {
let name = match reference {
DataflowRef::Id(id) => return Ok(*id),
DataflowRef::Name(name) => name.clone(),
};
let dataflows = self.list_dataflows(true).await?;
let matched: Vec<&DataflowSummary> = dataflows
.iter()
.filter(|summary| summary.name.as_deref() == Some(name.as_str()))
.collect();
match matched.as_slice() {
[one] => Ok(one.id),
[] => Err(CliError::UnknownDataflow {
reference: name,
reason: describe_known(&dataflows),
}),
many => Err(CliError::UnknownDataflow {
reference: name,
reason: format!(
"{} dataflows share that name; name one by id: {}",
many.len(),
many.iter()
.map(|summary| summary.id.to_string())
.collect::<Vec<_>>()
.join(", ")
),
}),
}
}
pub async fn sole_dataflow(&mut self, all: bool) -> Result<DataflowId, CliError> {
let dataflows = self.list_dataflows(all).await?;
match dataflows.as_slice() {
[one] => Ok(one.id),
[] => Err(CliError::UnknownDataflow {
reference: "(none named)".to_owned(),
reason: "this cluster has no dataflow to act on".to_owned(),
}),
many => Err(CliError::UnknownDataflow {
reference: "(none named)".to_owned(),
reason: format!(
"{} dataflows are known, so one must be named: {}",
many.len(),
describe_known(&dataflows)
),
}),
}
}
}
fn describe_known(dataflows: &[DataflowSummary]) -> String {
if dataflows.is_empty() {
return "this cluster knows no dataflows at all".to_owned();
}
let known: Vec<String> = dataflows
.iter()
.take(8)
.map(DataflowSummary::display_name)
.collect();
format!("known dataflows: {}", known.join(", "))
}
#[must_use]
pub fn new_subscription_id() -> SubscriptionId {
static NEXT: AtomicU64 = AtomicU64::new(0);
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |since| {
u64::try_from(since.as_nanos()).unwrap_or(u64::MAX)
});
let mut hash: u64 = 0xcbf2_9ce4_8422_2325;
for part in [
u64::from(std::process::id()),
nanos,
NEXT.fetch_add(1, Ordering::Relaxed),
] {
for byte in part.to_le_bytes() {
hash ^= u64::from(byte);
hash = hash.wrapping_mul(0x0000_0100_0000_01b3);
}
}
SubscriptionId::new(hash.max(1))
}
#[must_use]
pub fn reply_name(reply: &ControlReply) -> &'static str {
match reply {
ControlReply::Ok => "Ok",
ControlReply::Error { .. } => "Error",
ControlReply::DataflowList { .. } => "DataflowList",
ControlReply::DataflowResult { .. } => "DataflowResult",
ControlReply::NodeInfo { .. } => "NodeInfo",
ControlReply::DaemonList { .. } => "DaemonList",
ControlReply::Logs { .. } => "Logs",
ControlReply::ParamValue { .. } => "ParamValue",
ControlReply::ParamList { .. } => "ParamList",
ControlReply::TraceData { .. } => "TraceData",
ControlReply::Refused(_) => "Refused",
ControlReply::Welcome(_) => "Welcome",
ControlReply::BuildStarted { .. } => "BuildStarted",
ControlReply::Started { .. } => "Started",
_ => "an unknown reply",
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DataflowRef {
Id(DataflowId),
Name(String),
}
impl DataflowRef {
#[must_use]
pub fn parse(text: &str) -> Self {
text.trim()
.parse::<DataflowId>()
.map_or_else(|_| Self::Name(text.trim().to_owned()), Self::Id)
}
#[must_use]
pub const fn id(&self) -> Option<DataflowId> {
match self {
Self::Id(id) => Some(*id),
Self::Name(_) => None,
}
}
}
impl std::fmt::Display for DataflowRef {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Id(id) => write!(f, "{id}"),
Self::Name(name) => f.write_str(name),
}
}
}
pub fn runtime() -> Result<tokio::runtime::Runtime, CliError> {
tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.map_err(|source| CliError::io("tokio runtime", source))
}
#[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-client-{}-{name}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
dir
}
#[test]
fn a_bare_port_means_loopback() {
let addr = resolve_text("7407").unwrap();
assert_eq!(addr, SocketAddr::from(([127, 0, 0, 1], 7407)));
}
#[test]
fn a_host_and_port_is_taken_as_written() {
let addr = resolve_text("127.0.0.1:9001").unwrap();
assert_eq!(addr.port(), 9001);
}
#[test]
fn a_bare_host_gets_the_default_port() {
let addr = resolve_text("127.0.0.1").unwrap();
assert_eq!(addr.port(), default_port());
}
#[test]
fn an_empty_address_is_refused_with_what_was_typed() {
let error = resolve_text(" ").unwrap_err();
match error {
CliError::BadAddress { input, .. } => assert_eq!(input, " "),
other => panic!("expected BadAddress, got {other}"),
}
}
#[test]
fn a_name_that_resolves_to_nothing_is_refused() {
let error = resolve_text("no-such-host.invalid:1").unwrap_err();
assert!(matches!(error, CliError::BadAddress { .. }), "{error}");
}
#[test]
fn a_mutating_verb_without_a_token_refuses_locally() {
let dir = scratch("no-token");
let error = endpoint(Some("127.0.0.1:1"), None, None, Some(&dir), true).unwrap_err();
match error {
CliError::NoToken { file, .. } => {
assert_eq!(file, crate::runtime_dir::TOKEN_FILE);
}
other => panic!("expected NoToken, got {other}"),
}
}
#[test]
fn a_probe_without_a_token_falls_back_to_the_zero_token() {
let dir = scratch("zero-token");
let endpoint = endpoint(Some("127.0.0.1:1"), None, None, Some(&dir), false).unwrap();
assert!(endpoint.token.is_zero());
}
#[test]
fn a_token_file_is_found_and_used() {
let dir = scratch("with-token");
let (token, _) = crate::runtime_dir::ensure_token_file(&dir).unwrap();
let endpoint = endpoint(Some("127.0.0.1:1"), None, None, Some(&dir), true).unwrap();
assert_eq!(endpoint.token, token);
}
#[test]
fn the_endpoint_remembers_how_the_address_was_typed() {
let dir = scratch("display");
let endpoint = endpoint(Some("7407"), None, None, Some(&dir), false).unwrap();
assert_eq!(endpoint.display, "7407");
assert_eq!(endpoint.addr.port(), 7407);
}
#[test]
fn a_dataflow_reference_is_an_id_or_a_name() {
let id = DataflowId::generate();
assert_eq!(DataflowRef::parse(&id.to_string()), DataflowRef::Id(id));
assert_eq!(
DataflowRef::parse(" my-flow "),
DataflowRef::Name("my-flow".to_owned())
);
assert_eq!(DataflowRef::parse(&id.to_string()).id(), Some(id));
assert!(DataflowRef::parse("my-flow").id().is_none());
}
#[test]
fn every_reply_variant_has_a_name() {
assert_eq!(reply_name(&ControlReply::Ok), "Ok");
assert_eq!(
reply_name(&ControlReply::Error {
code: astrs_wire::ErrorCode::Internal,
message: String::new(),
context: Vec::new(),
}),
"Error"
);
}
#[test]
fn connecting_to_nothing_says_to_run_astrs_up() {
let dir = scratch("no-cluster");
let endpoint = endpoint(Some("127.0.0.1:1"), None, None, Some(&dir), false).unwrap();
let runtime = runtime().unwrap();
let error = runtime.block_on(Client::connect(&endpoint)).unwrap_err();
let rendered = error.to_string();
match error {
CliError::NoCluster { detail } => assert!(detail.contains("127.0.0.1:1"), "{detail}"),
other => panic!("expected NoCluster, got {other}"),
}
assert!(rendered.contains("astrs up"), "{rendered}");
}
}