90 lines
3.4 KiB
Rust
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()}),
|
|
))
|
|
}
|