Files
rust-discovery/crates/server/src/api.rs
T

90 lines
3.4 KiB
Rust

use axum::{
Extension, Json,
extract::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 tenants(
State(state): State<crate::State>,
headers: HeaderMap,
) -> Result<Json<Value>, StatusCode> {
let principal = state.auth.principal(&state, &headers, false).await?;
let mut tx = rmm_persistence::tenant_tx(&state.pool, principal.tenant)
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
let can_manage = crate::customers::can_manage(&principal, &mut tx)
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
tx.commit()
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
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)?;
// A bearer can have different effective scopes in each customer.
let has_read = (principal.name.starts_with("mcp:")
|| principal.permits_scope("inventory:read"))
&& crate::permissions::allowed(&mut tx, &principal.name, "inventory:read")
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
if !has_read {
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, "can_manage_customers":can_manage, "next_cursor":null,"completeness":"complete","truncated":false,"as_of":Utc::now()}),
))
}