pub mod expose;
pub mod policy;
pub mod reconcile;
pub mod runtime;
pub mod serve;
pub mod state;
use std::sync::Arc;
use std::time::Duration;
use serde::{Deserialize, Serialize};
#[allow(unused_imports)]
pub use reconcile::{plan, plan_failure, Action};
#[allow(unused_imports)]
pub use runtime::{
doctor_report, runtime_available, runtime_probe, ContainerRuntime, DockerCli, RunSpec,
RuntimeError, RuntimeProbe,
};
#[allow(unused_imports)]
pub use state::DeploymentRecord;
pub use state::LocalState;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Port {
pub container: u16,
#[serde(default = "default_protocol")]
pub protocol: String,
}
fn default_protocol() -> String {
"http".to_string()
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Healthcheck {
#[serde(rename = "type")]
pub kind: String, pub port: u16,
#[serde(default)]
pub path: Option<String>,
#[serde(default = "default_timeout_s")]
pub timeout_s: u64,
}
fn default_timeout_s() -> u64 {
60
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
pub struct ServiceAccount {
pub name: String,
#[serde(default)]
pub grants: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub policy: Option<serde_json::Value>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PreviousDeployment {
pub id: String,
pub image: String,
#[serde(default)]
pub cmd: Option<String>,
#[serde(default)]
pub ports: Vec<Port>,
#[serde(default)]
pub env: std::collections::HashMap<String, String>,
#[serde(default)]
pub healthcheck: Option<Healthcheck>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Desired {
pub id: String,
pub version: u64,
pub name: String,
pub image: String,
#[serde(default)]
pub cmd: Option<String>,
#[serde(default)]
pub ports: Vec<Port>,
#[serde(default)]
pub env: std::collections::HashMap<String, String>,
#[serde(default)]
pub healthcheck: Option<Healthcheck>,
pub price_per_second: f64,
pub desired_state: String, #[serde(default)]
pub service_account: Option<ServiceAccount>,
#[serde(default = "default_warm")]
pub warm: bool,
#[serde(default)]
pub previous: Option<Box<PreviousDeployment>>,
}
pub(crate) fn default_warm() -> bool {
true
}
#[derive(Debug, Deserialize)]
struct DesiredResponse {
deployments: Vec<Desired>,
}
pub fn fetch_desired(
api_url: &str,
api_key: &str,
node_pubkey: &str,
) -> Result<Vec<Desired>, String> {
let endpoint = format!(
"{}/api/broker/deployments/desired",
api_url.trim_end_matches('/')
);
let resp = ureq::get(&endpoint)
.config()
.timeout_global(Some(Duration::from_secs(10)))
.http_status_as_error(false)
.build()
.header("X-Broker-Api-Key", api_key)
.header("X-Node-Pubkey", node_pubkey)
.call()
.map_err(|e| e.to_string())?;
if resp.status().as_u16() != 200 {
return Err(format!("fetch_desired HTTP {}", resp.status().as_u16()));
}
let text = resp
.into_body()
.read_to_string()
.map_err(|e| e.to_string())?;
let parsed: DesiredResponse = serde_json::from_str(&text).map_err(|e| e.to_string())?;
Ok(parsed.deployments)
}
#[allow(clippy::too_many_arguments)]
fn status_payload(
node_pubkey: &str,
version: u64,
phase: &str,
message: &str,
attempt: u32,
container_id: Option<&str>,
endpoint: Option<&str>,
mesh_endpoint: Option<&str>,
failure: Option<&reconcile::FailureDetail>,
logs: Option<&str>,
) -> serde_json::Value {
let mut payload = serde_json::json!({
"node_pubkey": node_pubkey,
"version": version,
"phase": phase,
"message": message,
"attempt": attempt,
"container_id": container_id,
"endpoint": endpoint,
"mesh_endpoint": mesh_endpoint,
});
if let Some(f) = failure {
payload["code"] = serde_json::json!(f.code);
if let Some(logs) = &f.logs {
payload["logs"] = serde_json::json!(logs);
}
if let Some(n) = f.probes_failed {
payload["probes_failed"] = serde_json::json!(n);
}
} else if let Some(logs) = logs {
payload["logs"] = serde_json::json!(logs);
}
payload
}
#[allow(clippy::too_many_arguments)]
pub fn report_status(
api_url: &str,
api_key: &str,
node_pubkey: &str,
id: &str,
version: u64,
phase: &str,
message: &str,
attempt: u32,
container_id: Option<&str>,
endpoint: Option<&str>,
mesh_endpoint: Option<&str>,
failure: Option<&reconcile::FailureDetail>,
logs: Option<&str>,
) {
let url = format!(
"{}/api/broker/deployments/{}/status",
api_url.trim_end_matches('/'),
id
);
let payload = status_payload(
node_pubkey,
version,
phase,
message,
attempt,
container_id,
endpoint,
mesh_endpoint,
failure,
logs,
);
let body = serde_json::to_string(&payload).unwrap_or_default();
let result = ureq::post(&url)
.config()
.timeout_global(Some(Duration::from_secs(10)))
.http_status_as_error(false)
.build()
.header("X-Broker-Api-Key", api_key)
.header("X-Node-Pubkey", node_pubkey)
.header("Content-Type", "application/json")
.send(body.as_str());
if let Err(e) = result {
eprintln!(" [DEPLOY] failed to report status for {id}: {e}");
}
}
pub struct HttpReporter<'a> {
pub api_url: &'a str,
pub api_key: &'a str,
pub node_pubkey: &'a str,
}
impl reconcile::StatusReporter for HttpReporter<'_> {
fn report(
&self,
id: &str,
version: u64,
phase: &str,
message: &str,
attempt: u32,
container_id: Option<&str>,
endpoint: Option<&str>,
mesh_endpoint: Option<&str>,
) {
report_status(
self.api_url,
self.api_key,
self.node_pubkey,
id,
version,
phase,
message,
attempt,
container_id,
endpoint,
mesh_endpoint,
None,
None,
);
}
fn report_healthy(
&self,
id: &str,
version: u64,
attempt: u32,
container_id: Option<&str>,
endpoint: Option<&str>,
logs: Option<&str>,
) {
report_status(
self.api_url,
self.api_key,
self.node_pubkey,
id,
version,
"healthy",
"",
attempt,
container_id,
endpoint,
None,
None,
logs,
);
}
fn report_failure(
&self,
id: &str,
version: u64,
attempt: u32,
container_id: Option<&str>,
failure: &reconcile::FailureDetail,
) {
report_status(
self.api_url,
self.api_key,
self.node_pubkey,
id,
version,
"failed",
&failure.message,
attempt,
container_id,
None,
None,
Some(failure),
None,
);
}
}
pub fn tick(state: &Arc<crate::broker::BrokerState>) {
let (Some(api_url), Some(api_key)) = (&state.config.api_url, &state.config.api_key) else {
return;
};
let node_pubkey = state.node_key.public_b64();
let desired = match fetch_desired(api_url, api_key, &node_pubkey) {
Ok(d) => d,
Err(e) => {
eprintln!(" [DEPLOY] failed to fetch desired deployments: {e}");
return;
}
};
let rt = DockerCli;
if !rt.available() {
let failure =
reconcile::FailureDetail::new("no_runtime", runtime_probe().failure_message());
for d in &desired {
if d.desired_state == "running" {
report_status(
api_url,
api_key,
&node_pubkey,
&d.id,
d.version,
"failed",
&failure.message,
1,
None,
None,
None,
Some(&failure),
None,
);
}
}
return;
}
let mut local = LocalState::load();
let reporter = HttpReporter {
api_url,
api_key,
node_pubkey: &node_pubkey,
};
let mesh_ip = expose::exposure_ip(
crate::broker::discovery::get_mesh_ip(),
std::env::var("ZAKURO_MESH_EXPOSE").ok().as_deref(),
);
if mesh_ip.is_some() {
expose::refresh_allowlist(api_url, api_key);
}
reconcile::drive_and_expose(
&rt,
&reporter,
expose::forwarder(),
mesh_ip.as_deref(),
&desired,
&mut local,
);
}
pub fn print_deployments() {
let local = LocalState::load();
if local.deployments.is_empty() {
println!("No local deployment state (nothing reconciled on this node yet).");
} else {
println!(
"{:<24} {:>7} {:<12} {:<22} {:<22} {:<6} {:<20} CONTAINER",
"DEPLOYMENT", "VERSION", "PHASE", "ENDPOINT", "MESH", "WARM", "SERVICE_ACCOUNT"
);
let mut ids: Vec<&String> = local.deployments.keys().collect();
ids.sort();
for id in ids {
let rec = &local.deployments[id];
let service_account = rec
.service_account
.as_ref()
.map(|sa| {
let net = if policy::network_access(Some(sa)).isolated() {
" net=isolated"
} else {
""
};
format!("{}[{}]{net}", sa.name, sa.grants.join(","))
})
.unwrap_or_else(|| "-".to_string());
println!(
"{:<24} {:>7} {:<12} {:<22} {:<22} {:<6} {:<20} {}",
id,
rec.version,
rec.phase,
rec.endpoint.as_deref().unwrap_or("-"),
rec.mesh_endpoint.as_deref().unwrap_or("-"),
rec.warm,
service_account,
rec.container_id.as_deref().unwrap_or("-"),
);
}
}
println!();
let rt = DockerCli;
if !rt.available() {
println!("(docker not available on this host)");
return;
}
let ps = [
"ps",
"-a",
"--filter",
"label=zakuro.deployment",
"--format",
"table {{.Names}}\t{{.Status}}\t{{.Ports}}",
]
.map(String::from);
match crate::sandbox::engine::command(&ps)
.and_then(|mut c| c.output().map_err(|e| e.to_string()))
{
Ok(out) if out.status.success() => {
print!("{}", String::from_utf8_lossy(&out.stdout));
}
Ok(out) => {
eprintln!(
"docker ps failed: {}",
String::from_utf8_lossy(&out.stderr).trim()
);
}
Err(e) => eprintln!("docker ps failed: {e}"),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn status_payload_carries_the_mesh_endpoint() {
let payload = status_payload(
"pk",
3,
"healthy",
"",
1,
Some("c1"),
Some("172.17.0.3:8888"),
Some("10.13.13.22:8888"),
None,
None,
);
assert_eq!(payload["endpoint"], "172.17.0.3:8888");
assert_eq!(payload["mesh_endpoint"], "10.13.13.22:8888");
}
#[test]
fn status_payload_sends_an_explicit_null_when_not_exposed() {
let payload = status_payload("pk", 3, "stopped", "", 1, None, None, None, None, None);
assert!(payload.get("mesh_endpoint").is_some_and(|v| v.is_null()));
}
#[test]
fn status_payload_omits_failure_fields_unless_set() {
let payload = status_payload("pk", 3, "healthy", "", 1, None, None, None, None, None);
for key in ["code", "logs", "probes_failed"] {
assert!(payload.get(key).is_none(), "{key} should be absent");
}
}
#[test]
fn status_payload_carries_healthy_startup_logs_without_a_code() {
let payload = status_payload(
"pk",
3,
"healthy",
"",
1,
Some("c1"),
Some("172.17.0.3:8888"),
None,
None,
Some("token=abc"),
);
assert_eq!(payload["phase"], "healthy");
assert_eq!(payload["logs"], "token=abc");
assert!(payload.get("code").is_none());
assert!(payload.get("probes_failed").is_none());
}
#[test]
fn status_payload_carries_failure_code_logs_and_probes() {
let mut f =
reconcile::FailureDetail::new("health_failed", "GET http://1.2.3.4:80/ → HTTP 503");
f.logs = Some("boom".to_string());
f.probes_failed = Some(7);
let payload = status_payload(
"pk",
3,
"failed",
&f.message,
1,
Some("c1"),
None,
None,
Some(&f),
None,
);
assert_eq!(payload["phase"], "failed");
assert_eq!(payload["code"], "health_failed");
assert_eq!(payload["message"], "GET http://1.2.3.4:80/ → HTTP 503");
assert_eq!(payload["logs"], "boom");
assert_eq!(payload["probes_failed"], 7);
let pull = reconcile::FailureDetail::new("pull_failed", "denied");
let payload = status_payload(
"pk",
3,
"failed",
&pull.message,
1,
None,
None,
None,
Some(&pull),
None,
);
assert_eq!(payload["code"], "pull_failed");
assert!(payload.get("logs").is_none());
assert!(payload.get("probes_failed").is_none());
}
}