Files
rust-discovery/crates/server/src/api.rs
T
2026-11-15 16:26:37 +01:00

155 lines
7.2 KiB
Rust

use axum::{
Extension, Json,
extract::{Path, Query, State},
http::{HeaderMap, StatusCode},
};
use chrono::Utc;
use serde_json::{Value, json};
use sqlx::Row;
use uuid::Uuid;
async fn identity(state: &crate::State, headers: &HeaderMap) -> Result<Uuid, StatusCode> {
Ok(state.auth.principal(state, headers, false).await?.tenant)
}
pub async fn job_signing_key(
State(state): State<crate::State>,
h: HeaderMap,
Extension(peer): Extension<crate::Peer>,
) -> Result<Json<Value>, StatusCode> {
// Explicit bearer credentials never fall back to a device/cookie identity.
if h.contains_key("authorization") || peer.0.is_none() {
identity(&state, &h).await?;
} else {
if !peer.1.is_some_and(|expires| expires > Utc::now()) {
return Err(StatusCode::UNAUTHORIZED);
}
crate::agent_service::binding(&state, peer.0.as_deref().ok_or(StatusCode::UNAUTHORIZED)?)
.await
.map_err(|_| StatusCode::UNAUTHORIZED)?;
}
Ok(Json(
json!({"key_id":state.job_signer.key_id,"algorithm":"Ed25519","schema_version":1,"public_key_hex":hex::encode(state.job_signer.public_key().map_err(|_|StatusCode::INTERNAL_SERVER_ERROR)?)}),
))
}
pub async fn agent_job_signing_key(
State(state): State<crate::State>,
h: HeaderMap,
Extension(peer): Extension<crate::Peer>,
) -> Result<Json<Value>, StatusCode> {
if h.contains_key("authorization") || h.contains_key("cookie") || peer.0.is_none() {
return Err(StatusCode::UNAUTHORIZED);
}
job_signing_key(State(state), h, Extension(peer)).await
}
pub async fn device(
State(state): State<crate::State>,
headers: HeaderMap,
Path((tenant, asset)): Path<(Uuid, Uuid)>,
) -> Result<Json<Value>, StatusCode> {
let list = device_list(&state, &headers, tenant, Some(asset), Default::default()).await?;
let item = list["items"]
.as_array()
.and_then(|items| {
items
.iter()
.find(|i| i["asset_id"].as_str() == Some(asset.to_string().as_str()))
})
.cloned()
.ok_or(StatusCode::NOT_FOUND)?;
Ok(Json(item))
}
pub async fn tenants(
State(state): State<crate::State>,
headers: HeaderMap,
) -> Result<Json<Value>, StatusCode> {
let principal = state.auth.principal(&state, &headers, false).await?;
let mut items = Vec::new();
for tenant in &principal.tenants {
let mut tx = rmm_persistence::tenant_tx(&state.pool, *tenant)
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
if crate::permissions::require_principal(&mut tx, &principal, "inventory:read")
.await
.is_err()
{
continue;
}
let rows = sqlx::query("SELECT tenant_id,name FROM tenants")
.fetch_all(&mut *tx)
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
items.extend(rows.iter().map(
|r| json!({"tenant_id":r.get::<Uuid,_>("tenant_id"),"name":r.get::<String,_>("name")}),
));
tx.commit()
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
}
if items.is_empty() {
return Err(StatusCode::FORBIDDEN);
}
Ok(Json(
json!({"items": items, "next_cursor":null,"completeness":"complete","truncated":false,"as_of":Utc::now()}),
))
}
pub async fn devices(
State(state): State<crate::State>,
headers: HeaderMap,
Path(tenant): Path<Uuid>,
) -> Result<Json<Value>, StatusCode> {
Ok(Json(
device_list(&state, &headers, tenant, None, Default::default()).await?,
))
}
pub async fn devices_page(
State(state): State<crate::State>,
h: HeaderMap,
Path(tenant): Path<Uuid>,
Query(page): Query<crate::pagination::PageQuery>,
) -> Result<Json<Value>, StatusCode> {
Ok(Json(device_list(&state, &h, tenant, None, page).await?))
}
async fn device_list(
state: &crate::State,
headers: &HeaderMap,
tenant: Uuid,
asset: Option<Uuid>,
query: crate::pagination::PageQuery,
) -> Result<Value, StatusCode> {
if identity(state, headers).await? != tenant {
return Err(StatusCode::NOT_FOUND);
}
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
let principal = state.auth.principal(state, headers, false).await?;
crate::permissions::require_principal(&mut tx, &principal, "inventory:read")
.await
.map_err(|e| e.0)?;
let mut page =
crate::pagination::Cursor::parse(state, &principal, "devices:agent_id:asc", query)?;
let rows = sqlx::query("SELECT a.agent_id,a.asset_id,a.revoked_at,a.last_contact_at,a.certificate_sha256,a.last_authenticated_certificate_sha256,a.last_authenticated_at,a.capabilities,a.enrollment_generation,a.assignment_version,o.observed_at,o.received_at,o.data,o.source_id FROM agent_installations a LEFT JOIN LATERAL (SELECT observed_at,received_at,data,source_id FROM observations WHERE tenant_id=a.tenant_id AND agent_id=a.agent_id AND source_id IN ('linux.base','windows.base') AND received_at<=$2 ORDER BY observed_at DESC, received_at DESC LIMIT 1) o ON true WHERE ($1::uuid IS NULL OR a.asset_id=$1) AND a.agent_id>$3 AND a.created_at<=$2 ORDER BY a.agent_id LIMIT $4")
.bind(asset)
.bind(page.as_of).bind(page.last).bind(i64::from(page.limit)+1)
.fetch_all(&mut *tx).await.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
tx.commit()
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
let truncated = rows.len() > usize::from(page.limit);
let items = rows.iter().take(usize::from(page.limit)).map(|r| {
let last: Option<chrono::DateTime<Utc>> = r.get("last_contact_at");
let revoked: Option<chrono::DateTime<Utc>> = r.get("revoked_at");
let age = last.map(|t| (Utc::now()-t).num_seconds());
let presence = if revoked.is_some() { "revoked" } else { match age { None=>"never_seen",Some(n) if n<90=>"online",Some(n) if n<180=>"stale",_=>"unreachable" } };
json!({"agent_id":r.get::<Uuid,_>("agent_id"),"asset_id":r.get::<Uuid,_>("asset_id"),"certificate_sha256":r.get::<String,_>("certificate_sha256"),"last_authenticated_certificate_sha256":r.get::<Option<String>,_>("last_authenticated_certificate_sha256"),"last_authenticated_at":r.get::<Option<chrono::DateTime<Utc>>,_>("last_authenticated_at"),"capabilities":r.get::<Value,_>("capabilities"),"enrollment_generation":r.get::<i64,_>("enrollment_generation"),"assignment_version":r.get::<i64,_>("assignment_version"),"presence":presence,"last_contact_at":last,"inventory":r.get::<Option<Value>,_>("data"),"observed_at":r.get::<Option<chrono::DateTime<Utc>>,_>("observed_at"),"received_at":r.get::<Option<chrono::DateTime<Utc>>,_>("received_at"),"source_id":r.get::<Option<String>,_>("source_id"),"quality":if r.get::<Option<Value>,_>("data").is_some(){"valid"}else{"unknown"},"completeness":"partial","health":"unknown"})
}).collect::<Vec<_>>();
let next = if truncated {
Some(page.next(state, rows[usize::from(page.limit) - 1].get("agent_id"))?)
} else {
None
};
Ok(
json!({"items":items,"next_cursor":next,"completeness":if truncated{"partial"}else{"complete"},"truncated":truncated,"as_of":page.as_of}),
)
}