155 lines
7.2 KiB
Rust
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 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}),
|
|
)
|
|
}
|