338 lines
12 KiB
Rust
338 lines
12 KiB
Rust
//! Refresh agents independently: one failed relay or snapshot does not cancel others.
|
|
|
|
use axum::{Json, extract::State, http::StatusCode, response::IntoResponse};
|
|
use futures_util::StreamExt;
|
|
use tracing::{info, warn};
|
|
use wakey_agent::protocol::{AgentCommand, InventoryRequest};
|
|
|
|
use super::types::{
|
|
RefreshFleetAgentResult, RefreshFleetDevicesRequest, RefreshFleetDevicesResponse,
|
|
};
|
|
use crate::api::{
|
|
ApiError,
|
|
commands::{RelayCommandResponse, relay_agent_command},
|
|
};
|
|
use crate::runtime::AppState;
|
|
use crate::state::Store;
|
|
|
|
const REFRESH_CONCURRENCY: usize = 8;
|
|
|
|
#[tracing::instrument(name = "fleet_refresh", skip_all, fields(agents = tracing::field::Empty, succeeded = tracing::field::Empty, failed = tracing::field::Empty, accepted = tracing::field::Empty))]
|
|
pub async fn refresh_fleet_devices(
|
|
State(state): State<AppState>,
|
|
Json(req): Json<RefreshFleetDevicesRequest>,
|
|
) -> Result<impl IntoResponse, ApiError> {
|
|
let agent_ids = select_agents(&state, req.agent_ids).await;
|
|
tracing::Span::current().record("agents", agent_ids.len());
|
|
let results = futures_util::stream::iter(
|
|
agent_ids
|
|
.into_iter()
|
|
.map(|agent_id| refresh_agent(&state, agent_id, req.timeout_ms)),
|
|
)
|
|
.buffer_unordered(REFRESH_CONCURRENCY)
|
|
.collect::<Vec<_>>()
|
|
.await;
|
|
let response = summarize(results);
|
|
let succeeded = response
|
|
.agents
|
|
.iter()
|
|
.filter(|result| result.status == "ok")
|
|
.count();
|
|
let span = tracing::Span::current();
|
|
span.record("succeeded", succeeded);
|
|
span.record("failed", response.agents.len() - succeeded);
|
|
span.record("accepted", response.total_accepted);
|
|
info!("fleet refresh completed");
|
|
Ok((StatusCode::OK, Json(response)))
|
|
}
|
|
|
|
/// Default to a point-in-time connected set. Explicit IDs remain eligible so
|
|
/// the relay can report disconnected agents as per-agent errors, not omit them.
|
|
async fn select_agents(state: &AppState, requested: Vec<String>) -> Vec<String> {
|
|
let ids = if requested.is_empty() {
|
|
state.sessions.read().await.keys().cloned().collect()
|
|
} else {
|
|
requested
|
|
};
|
|
normalize_refresh_agent_ids(ids)
|
|
}
|
|
|
|
pub(super) fn normalize_refresh_agent_ids(mut agent_ids: Vec<String>) -> Vec<String> {
|
|
agent_ids.sort();
|
|
agent_ids.dedup();
|
|
agent_ids
|
|
}
|
|
|
|
#[tracing::instrument(name = "fleet_refresh_agent", skip_all, fields(agent_id = %agent_id, outcome = tracing::field::Empty, accepted = tracing::field::Empty))]
|
|
async fn refresh_agent(
|
|
state: &AppState,
|
|
agent_id: String,
|
|
timeout_ms: Option<u64>,
|
|
) -> RefreshFleetAgentResult {
|
|
let response = relay_agent_command(
|
|
state,
|
|
&agent_id,
|
|
AgentCommand::Inventory(InventoryRequest {
|
|
query: None,
|
|
name: None,
|
|
ips: Vec::new(),
|
|
devs: Vec::new(),
|
|
nuds: Vec::new(),
|
|
macs: Vec::new(),
|
|
}),
|
|
timeout_ms,
|
|
)
|
|
.await;
|
|
let result = store_inventory(&state.store, &agent_id, response).await;
|
|
tracing::Span::current().record("outcome", result.status.as_str());
|
|
tracing::Span::current().record("accepted", result.accepted);
|
|
if result.status != "ok" {
|
|
// The response retains diagnostic detail; do not export payloads.
|
|
warn!("fleet agent refresh failed");
|
|
}
|
|
result
|
|
}
|
|
|
|
/// Validate the relay result before replacing anything. An empty *valid*
|
|
/// inventory is still a complete snapshot and intentionally clears old rows.
|
|
fn decode_inventory(
|
|
response: Result<RelayCommandResponse, ApiError>,
|
|
) -> Result<wakey_core::DeviceInventory, String> {
|
|
let response = response.map_err(|err| format!("{}: {}", err.status, err.message))?;
|
|
if response.status != "ok" {
|
|
return Err(response
|
|
.error
|
|
.map(|error| error.message)
|
|
.unwrap_or_else(|| "inventory command failed".into()));
|
|
}
|
|
let result = response
|
|
.result
|
|
.ok_or_else(|| "inventory command returned no result".to_string())?;
|
|
serde_json::from_value(result).map_err(|err| err.to_string())
|
|
}
|
|
|
|
async fn store_inventory(
|
|
store: &Store,
|
|
agent_id: &str,
|
|
response: Result<RelayCommandResponse, ApiError>,
|
|
) -> RefreshFleetAgentResult {
|
|
let accepted = async {
|
|
let inventory = decode_inventory(response)?;
|
|
store
|
|
.replace_agent_device_snapshot(agent_id, &inventory.devices)
|
|
.await
|
|
.map_err(|err| err.to_string())
|
|
}
|
|
.await;
|
|
match accepted {
|
|
Ok(accepted) => RefreshFleetAgentResult {
|
|
agent_id: agent_id.into(),
|
|
status: "ok".into(),
|
|
accepted,
|
|
error: None,
|
|
},
|
|
Err(error) => RefreshFleetAgentResult {
|
|
agent_id: agent_id.into(),
|
|
status: "error".into(),
|
|
accepted: 0,
|
|
error: Some(error),
|
|
},
|
|
}
|
|
}
|
|
|
|
/// Concurrent completion order is deliberately not part of the response contract.
|
|
fn summarize(mut agents: Vec<RefreshFleetAgentResult>) -> RefreshFleetDevicesResponse {
|
|
agents.sort_by(|a, b| a.agent_id.cmp(&b.agent_id));
|
|
RefreshFleetDevicesResponse {
|
|
total_accepted: agents.iter().map(|result| result.accepted).sum(),
|
|
agents,
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use serde_json::json;
|
|
|
|
fn response(result: Option<serde_json::Value>) -> RelayCommandResponse {
|
|
RelayCommandResponse {
|
|
request_id: "refresh-test".into(),
|
|
status: "ok".into(),
|
|
result,
|
|
error: None,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn decode_keeps_relay_and_payload_failures_distinct() {
|
|
assert_eq!(
|
|
decode_inventory(Ok(response(None))).unwrap_err(),
|
|
"inventory command returned no result"
|
|
);
|
|
assert!(decode_inventory(Ok(response(Some(json!({"devices": "invalid"}))))).is_err());
|
|
let mut failed = response(Some(json!({"devices": []})));
|
|
failed.status = "error".into();
|
|
assert_eq!(
|
|
decode_inventory(Ok(failed)).unwrap_err(),
|
|
"inventory command failed"
|
|
);
|
|
assert_eq!(
|
|
decode_inventory(Err(ApiError::new(
|
|
StatusCode::NOT_FOUND,
|
|
"agent_not_connected",
|
|
"agent is not connected"
|
|
)))
|
|
.unwrap_err(),
|
|
"404 Not Found: agent is not connected"
|
|
);
|
|
assert!(
|
|
decode_inventory(Ok(response(Some(json!({"devices": []})))))
|
|
.unwrap()
|
|
.devices
|
|
.is_empty()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn summary_keeps_partial_failures_and_sorts_by_agent() {
|
|
let result = summarize(vec![
|
|
RefreshFleetAgentResult {
|
|
agent_id: "z".into(),
|
|
status: "ok".into(),
|
|
accepted: 2,
|
|
error: None,
|
|
},
|
|
RefreshFleetAgentResult {
|
|
agent_id: "b".into(),
|
|
status: "error".into(),
|
|
accepted: 0,
|
|
error: Some("disconnected".into()),
|
|
},
|
|
RefreshFleetAgentResult {
|
|
agent_id: "a".into(),
|
|
status: "ok".into(),
|
|
accepted: 3,
|
|
error: None,
|
|
},
|
|
]);
|
|
assert_eq!(result.total_accepted, 5);
|
|
assert_eq!(
|
|
result
|
|
.agents
|
|
.iter()
|
|
.map(|row| row.agent_id.as_str())
|
|
.collect::<Vec<_>>(),
|
|
["a", "b", "z"]
|
|
);
|
|
assert_eq!(result.agents[1].error.as_deref(), Some("disconnected"));
|
|
assert!(summarize(vec![]).agents.is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn handler_reports_explicit_disconnected_agents_without_omitting_them() {
|
|
use std::{collections::HashMap, sync::Arc, time::Duration};
|
|
use tokio::sync::{Mutex, RwLock};
|
|
|
|
let dir =
|
|
std::env::temp_dir().join(format!("wakey-refresh-handler-{}", uuid::Uuid::new_v4()));
|
|
let state = AppState {
|
|
store: Arc::new(
|
|
Store::load_or_init(&dir.join("state.sqlite3"), vec![], Duration::from_secs(60))
|
|
.await
|
|
.unwrap(),
|
|
),
|
|
sessions: Arc::new(RwLock::new(HashMap::new())),
|
|
pending: Arc::new(Mutex::new(HashMap::new())),
|
|
public_url: "http://localhost".into(),
|
|
command_timeout: Duration::from_secs(30),
|
|
enroll_token_ttl: Duration::from_secs(60),
|
|
terminals: crate::runtime::terminals::TerminalRegistry::new(),
|
|
alerts: crate::api::AlertsHub::new(),
|
|
fleet: Arc::new(super::super::FleetCache::default()),
|
|
};
|
|
assert!(select_agents(&state, vec![]).await.is_empty());
|
|
let response = refresh_fleet_devices(
|
|
State(state.clone()),
|
|
Json(RefreshFleetDevicesRequest {
|
|
agent_ids: vec!["missing-b".into(), "missing-a".into(), "missing-b".into()],
|
|
timeout_ms: None,
|
|
}),
|
|
)
|
|
.await
|
|
.unwrap()
|
|
.into_response();
|
|
assert_eq!(response.status(), StatusCode::OK);
|
|
let body = axum::body::to_bytes(response.into_body(), 4096)
|
|
.await
|
|
.unwrap();
|
|
let result: RefreshFleetDevicesResponse = serde_json::from_slice(&body).unwrap();
|
|
assert_eq!(result.total_accepted, 0);
|
|
assert_eq!(result.agents.len(), 2);
|
|
assert_eq!(result.agents[0].agent_id, "missing-a");
|
|
assert_eq!(result.agents[1].agent_id, "missing-b");
|
|
for agent in result.agents {
|
|
assert_eq!(agent.status, "error");
|
|
assert_eq!(agent.accepted, 0);
|
|
assert_eq!(
|
|
agent.error.as_deref(),
|
|
Some("404 Not Found: agent is not connected")
|
|
);
|
|
}
|
|
assert!(state.pending.lock().await.is_empty());
|
|
drop(state);
|
|
std::fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn refresh_stores_snapshots_but_invalid_results_leave_them_untouched() {
|
|
let dir = std::env::temp_dir().join(format!("wakey-refresh-{}", uuid::Uuid::new_v4()));
|
|
let store = Store::load_or_init(
|
|
&dir.join("state.sqlite3"),
|
|
vec![],
|
|
std::time::Duration::from_secs(60),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
let device = wakey_core::Device::from_parts(
|
|
vec![wakey_core::NeighborEntry {
|
|
ip: "192.168.1.10".parse().unwrap(),
|
|
mac: Some("aa:bb:cc:dd:ee:01".parse().unwrap()),
|
|
dev: Some("br-lan".into()),
|
|
state: wakey_core::NeighborState::Reachable,
|
|
}],
|
|
vec![],
|
|
);
|
|
let inventory = serde_json::to_value(wakey_core::DeviceInventory {
|
|
devices: vec![device],
|
|
})
|
|
.unwrap();
|
|
let stored = store_inventory(&store, "agent", Ok(response(Some(inventory)))).await;
|
|
assert_eq!(stored.status, "ok");
|
|
assert_eq!(stored.accepted, 1);
|
|
let revision = store.fleet_revision();
|
|
let invalid = store_inventory(&store, "agent", Ok(response(None))).await;
|
|
assert_eq!(invalid.status, "error");
|
|
assert_eq!(invalid.accepted, 0);
|
|
assert_eq!(store.fleet_revision(), revision);
|
|
let rows = store
|
|
.list_agent_device_rows_for_agent("agent")
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(rows.len(), 1);
|
|
assert_eq!(rows[0].endpoints.len(), 1);
|
|
let empty =
|
|
store_inventory(&store, "agent", Ok(response(Some(json!({"devices": []}))))).await;
|
|
assert_eq!(empty.status, "ok");
|
|
assert_eq!(empty.accepted, 0);
|
|
assert!(
|
|
store
|
|
.list_agent_device_rows_for_agent("agent")
|
|
.await
|
|
.unwrap()
|
|
.is_empty()
|
|
);
|
|
drop(store);
|
|
std::fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
}
|