use introspection_core::{StatusSnapshot, read_status_snapshot};
use crate::constants::DEFAULT_STATUS_REPORT_PATH;
use crate::demo::capture_demo_status_report;
use crate::helpers::{has_flag, option_value, parse_report_path, parse_u64_option};
use crate::status_api::{
STATUS_SERVICE_NAME, StatusServiceResponse, build_snapshot_request, make_udp_service_client,
next_request_id, validate_response,
};
use super::StatusSource;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum CliRuntimeMode {
Embedded,
Daemon,
}
fn parse_runtime_mode(args: &[String]) -> Result<CliRuntimeMode, String> {
match option_value(args, "--mode").as_deref() {
None => Ok(CliRuntimeMode::Embedded),
Some("embedded") => Ok(CliRuntimeMode::Embedded),
Some("daemon") => Ok(CliRuntimeMode::Daemon),
Some(other) => Err(format!(
"unsupported --mode value: {other} (expected embedded|daemon)"
)),
}
}
fn resolve_remote_endpoint(args: &[String]) -> Result<Option<String>, String> {
let mode = parse_runtime_mode(args)?;
let endpoint = option_value(args, "--endpoint");
match (mode, endpoint) {
(CliRuntimeMode::Daemon, Some(raw)) => Ok(Some(raw)),
(CliRuntimeMode::Daemon, None) => Ok(Some(super::DEFAULT_STATUS_BIND_ADDR.to_string())),
(CliRuntimeMode::Embedded, Some(raw)) => Ok(Some(raw)),
(CliRuntimeMode::Embedded, None) => Ok(None),
}
}
pub(super) fn load_status_snapshot(
args: &[String],
) -> Result<(StatusSnapshot, StatusSource), String> {
if let Some(raw_endpoint) = resolve_remote_endpoint(args)? {
let timeout_ms = parse_u64_option(args, "--timeout-ms", 1000)?;
let (snapshot, endpoint) = fetch_remote_status_snapshot(&raw_endpoint, timeout_ms)?;
let source = StatusSource {
label: format!("remote:{endpoint}"),
json: serde_json::json!({
"mode": "remote_service",
"service": STATUS_SERVICE_NAME,
"endpoint": endpoint,
"timeout_ms": timeout_ms,
}),
};
return Ok((snapshot, source));
}
let report_path = parse_report_path(args, DEFAULT_STATUS_REPORT_PATH)?;
let refresh_demo = has_flag(args, "--refresh-demo");
if refresh_demo {
capture_demo_status_report(&report_path).map_err(|err| {
format!(
"refresh demo status report to {} failed: {err}",
report_path.display()
)
})?;
}
let snapshot = read_status_snapshot(&report_path).map_err(|err| {
format!(
"read status snapshot from {} failed: {err}. Hint: run `cargo run -p local-loop` first, or pass --refresh-demo.",
report_path.display()
)
})?;
let source = StatusSource {
label: report_path.display().to_string(),
json: serde_json::json!({
"mode": "file",
"report": report_path,
}),
};
Ok((snapshot, source))
}
pub(super) fn fetch_remote_status_snapshot(
endpoint: &str,
timeout_ms: u64,
) -> Result<(StatusSnapshot, String), String> {
let endpoint = normalize_udp_endpoint(endpoint)?;
let client = make_udp_service_client(endpoint.clone(), timeout_ms)?;
let request_id = next_request_id();
let request = build_snapshot_request(request_id);
let response: StatusServiceResponse = client
.call_json(STATUS_SERVICE_NAME, request_id, &request)
.map_err(|err| format!("status query to {endpoint} failed: {err}"))?;
validate_response(&response, request_id)?;
Ok((response.snapshot, endpoint))
}
pub(super) fn normalize_udp_endpoint(raw: &str) -> Result<String, String> {
if let Some(rest) = raw.strip_prefix("udp://") {
if rest.is_empty() {
return Err(String::from("invalid --endpoint value: udp://"));
}
return Ok(rest.to_string());
}
if raw.contains("://") {
return Err(format!("unsupported endpoint scheme: {raw}"));
}
Ok(raw.to_string())
}