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 { Ok(state.auth.principal(state, headers, false).await?.tenant) } pub async fn job_signing_key( State(state): State, h: HeaderMap, Extension(peer): Extension, ) -> Result, 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, h: HeaderMap, Extension(peer): Extension, ) -> Result, 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, headers: HeaderMap, Path((tenant, asset)): Path<(Uuid, Uuid)>, ) -> Result, 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, headers: HeaderMap, ) -> Result, 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::("tenant_id"),"name":r.get::("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, headers: HeaderMap, Path(tenant): Path, ) -> Result, StatusCode> { Ok(Json( device_list(&state, &headers, tenant, None, Default::default()).await?, )) } pub async fn devices_page( State(state): State, h: HeaderMap, Path(tenant): Path, Query(page): Query, ) -> Result, StatusCode> { Ok(Json(device_list(&state, &h, tenant, None, page).await?)) } async fn device_list( state: &crate::State, headers: &HeaderMap, tenant: Uuid, asset: Option, query: crate::pagination::PageQuery, ) -> Result { 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> = r.get("last_contact_at"); let revoked: Option> = 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::("agent_id"),"asset_id":r.get::("asset_id"),"certificate_sha256":r.get::("certificate_sha256"),"last_authenticated_certificate_sha256":r.get::,_>("last_authenticated_certificate_sha256"),"last_authenticated_at":r.get::>,_>("last_authenticated_at"),"capabilities":r.get::("capabilities"),"enrollment_generation":r.get::("enrollment_generation"),"assignment_version":r.get::("assignment_version"),"presence":presence,"last_contact_at":last,"inventory":r.get::,_>("data"),"observed_at":r.get::>,_>("observed_at"),"received_at":r.get::>,_>("received_at"),"source_id":r.get::,_>("source_id"),"quality":if r.get::,_>("data").is_some(){"valid"}else{"unknown"},"completeness":"partial","health":"unknown"}) }).collect::>(); 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}), ) }