223 lines
8.3 KiB
Rust
223 lines
8.3 KiB
Rust
//! `hivectl agent <name>` — everything scoped to ONE managed agent:
|
|
//! container lifecycle over the host admin socket (restart/pause/resume/
|
|
//! spawn/kill/destroy/rebuild/set-parent/set-limits/choom/watch), plus the
|
|
//! `quota` and `subvol` groups, whose handlers live in their own modules.
|
|
//! `agents_list` (`hivectl list-agents`) is the one genuinely hive-wide
|
|
//! read that lives in this module too since it shares the same daemon
|
|
//! request as everything else here, even though it's dispatched from a
|
|
//! top-level `Cmd` variant, not `AgentCmd`.
|
|
|
|
use std::path::Path;
|
|
|
|
use anyhow::{Context as _, Result, bail};
|
|
use hive_host_sock::HostRequest;
|
|
|
|
use crate::cli::{AgentCmd, AgentQuotaCmd};
|
|
use crate::dag_progress::wait_for_dags;
|
|
use crate::util::render;
|
|
|
|
async fn agents_restart(socket: &Path, name: &str, no_wait: bool) -> Result<()> {
|
|
let resp = crate::client::request(
|
|
socket,
|
|
hive_host_sock::HostRequest::Restart {
|
|
name: crate::util::parse_ident(name)?,
|
|
},
|
|
)
|
|
.await
|
|
.with_context(|| format!("connect to daemon socket {}", socket.display()))?;
|
|
if resp.ok {
|
|
println!("restart queued: {name}");
|
|
wait_for_dags(socket, resp.queued_dags.unwrap_or_default(), no_wait).await
|
|
} else {
|
|
bail!(
|
|
"restart {name}: {}",
|
|
resp.error.as_deref().unwrap_or("unknown error")
|
|
)
|
|
}
|
|
}
|
|
|
|
/// `hivectl list-agents` — fetch the per-agent status roster from the
|
|
/// daemon (`HostRequest::AgentStatus`) and render it as a padded table,
|
|
/// or the raw JSON rows with `--json`. Reuses the dashboard's
|
|
/// `ContainerView` aggregation, so the CLI and the web UI never drift.
|
|
pub(crate) async fn agents_list(socket: &Path, json: bool) -> Result<()> {
|
|
let resp = crate::client::request(socket, hive_host_sock::HostRequest::AgentStatus)
|
|
.await
|
|
.with_context(|| format!("connect to daemon socket {}", socket.display()))?;
|
|
if !resp.ok {
|
|
bail!(
|
|
"agents list: {}",
|
|
resp.error.as_deref().unwrap_or("unknown error")
|
|
);
|
|
}
|
|
let rows = resp.agent_statuses.unwrap_or_default();
|
|
if json {
|
|
println!("{}", serde_json::to_string_pretty(&rows)?);
|
|
return Ok(());
|
|
}
|
|
if rows.is_empty() {
|
|
println!("no managed agents found");
|
|
return Ok(());
|
|
}
|
|
// STATUS collapses the health flags into one space-separated token so
|
|
// the common case (`running`) stays short and anomalies stand out.
|
|
let status_of = |r: &hive_sh4re::AgentStatusRow| -> String {
|
|
let mut s = if r.running { "running" } else { "stopped" }.to_owned();
|
|
if r.paused {
|
|
s.push_str(" paused");
|
|
}
|
|
if r.needs_login {
|
|
s.push_str(" needs-login");
|
|
}
|
|
if r.needs_update {
|
|
s.push_str(" needs-update");
|
|
}
|
|
s
|
|
};
|
|
let headers = ["NAME", "STATUS", "REV", "PARENT", "REMIND"];
|
|
let table: Vec<[String; 5]> = rows
|
|
.iter()
|
|
.map(|r| {
|
|
[
|
|
r.name.clone(),
|
|
status_of(r),
|
|
r.deployed_sha.clone().unwrap_or_else(|| "-".to_owned()),
|
|
r.parent.clone().unwrap_or_else(|| "-".to_owned()),
|
|
if r.pending_reminders > 0 {
|
|
r.pending_reminders.to_string()
|
|
} else {
|
|
"-".to_owned()
|
|
},
|
|
]
|
|
})
|
|
.collect();
|
|
let mut widths = headers.map(str::len);
|
|
for row in &table {
|
|
for (i, cell) in row.iter().enumerate() {
|
|
widths[i] = widths[i].max(cell.len());
|
|
}
|
|
}
|
|
let fmt_row = |cells: &[String]| -> String {
|
|
cells
|
|
.iter()
|
|
.enumerate()
|
|
.map(|(i, c)| format!("{c:<w$}", w = widths[i]))
|
|
.collect::<Vec<_>>()
|
|
.join(" ")
|
|
.trim_end()
|
|
.to_owned()
|
|
};
|
|
let header_cells: Vec<String> = headers.iter().map(|h| (*h).to_owned()).collect();
|
|
println!("{}", fmt_row(&header_cells));
|
|
for row in &table {
|
|
println!("{}", fmt_row(row));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// `hivectl agent <name> pause|resume` — flip the agent's pause marker. Not a
|
|
/// DAG, so there's nothing to wait on: the daemon writes the marker and
|
|
/// the harness picks it up on its next poll.
|
|
async fn set_paused(socket: &Path, name: &str, paused: bool) -> Result<()> {
|
|
let resp = crate::client::request(
|
|
socket,
|
|
HostRequest::SetPaused {
|
|
name: crate::util::parse_ident(name)?,
|
|
paused,
|
|
},
|
|
)
|
|
.await
|
|
.with_context(|| format!("connect to daemon socket {}", socket.display()))?;
|
|
if resp.ok {
|
|
let verb = if paused { "paused" } else { "resumed" };
|
|
println!("{verb}: {name}");
|
|
Ok(())
|
|
} else {
|
|
bail!(
|
|
"{} {name}: {}",
|
|
if paused { "pause" } else { "resume" },
|
|
resp.error.as_deref().unwrap_or("unknown error")
|
|
)
|
|
}
|
|
}
|
|
|
|
/// Dispatch `hivectl agent <name> <verb>` — container lifecycle over the
|
|
/// host admin socket, all scoped to the single `name` hoisted from the
|
|
/// parent command.
|
|
pub(crate) async fn run_agent(socket: &Path, name: &str, cmd: AgentCmd) -> Result<()> {
|
|
match cmd {
|
|
AgentCmd::Restart { no_wait } => agents_restart(socket, name, no_wait).await,
|
|
AgentCmd::Pause => set_paused(socket, name, true).await,
|
|
AgentCmd::Resume => set_paused(socket, name, false).await,
|
|
AgentCmd::Spawn => {
|
|
let name = crate::util::parse_ident(name)?;
|
|
render(crate::client::request(socket, HostRequest::Spawn { name }).await?)
|
|
}
|
|
AgentCmd::RequestSpawn => {
|
|
let name = crate::util::parse_ident(name)?;
|
|
render(crate::client::request(socket, HostRequest::RequestSpawn { name }).await?)
|
|
}
|
|
AgentCmd::Kill => {
|
|
let name = crate::util::parse_ident(name)?;
|
|
render(crate::client::request(socket, HostRequest::Kill { name }).await?)
|
|
}
|
|
AgentCmd::Destroy { purge } => {
|
|
let name = crate::util::parse_ident(name)?;
|
|
render(crate::client::request(socket, HostRequest::Destroy { name, purge }).await?)
|
|
}
|
|
AgentCmd::Rebuild => {
|
|
let name = crate::util::parse_ident(name)?;
|
|
render(crate::client::request(socket, HostRequest::Rebuild { name }).await?)
|
|
}
|
|
AgentCmd::SetParent { parent, root } => {
|
|
let child = crate::util::parse_ident(name)?;
|
|
let new_parent = if root {
|
|
None
|
|
} else {
|
|
parent.map(|p| crate::util::parse_ident(&p)).transpose()?
|
|
};
|
|
render(
|
|
crate::client::request(socket, HostRequest::SetParent { child, new_parent })
|
|
.await?,
|
|
)
|
|
}
|
|
AgentCmd::SetLimits {
|
|
cpu_quota,
|
|
memory_max,
|
|
reset,
|
|
} => {
|
|
let name = crate::util::parse_ident(name)?;
|
|
// `--reset` is the only way to reach an all-`None` request;
|
|
// clap rejects a bare `set-limits` with neither flag, so a
|
|
// forgotten value can't silently clear the overrides.
|
|
let (cpu_quota, memory_max) = if reset {
|
|
(None, None)
|
|
} else {
|
|
(cpu_quota, memory_max)
|
|
};
|
|
render(
|
|
crate::client::request(
|
|
socket,
|
|
HostRequest::SetResourceLimits {
|
|
name,
|
|
cpu_quota,
|
|
memory_max,
|
|
},
|
|
)
|
|
.await?,
|
|
)
|
|
}
|
|
AgentCmd::Choom { resume_session } => {
|
|
crate::choom::choom(socket, name, resume_session.as_deref()).await
|
|
}
|
|
AgentCmd::Watch => crate::watch::watch(socket, name).await,
|
|
// `quota` and `subvol` keep their own modules — these arms are
|
|
// just the reparenting glue that hoists `name` in from the
|
|
// parent `agent <name>` command.
|
|
AgentCmd::Quota { cmd } => match cmd {
|
|
AgentQuotaCmd::Show => crate::quota::quota_show(socket, name).await,
|
|
AgentQuotaCmd::Set { size } => crate::quota::quota_limit(socket, name, &size).await,
|
|
},
|
|
AgentCmd::Subvol { cmd } => crate::subvol::dispatch_subvol(socket, name, cmd).await,
|
|
}
|
|
}
|