Organize device inventory by customer and restrict token access to its audience
This commit is contained in:
+18
-83
@@ -1,6 +1,6 @@
|
||||
use axum::{
|
||||
Extension, Json,
|
||||
extract::{Path, Query, State},
|
||||
extract::State,
|
||||
http::{HeaderMap, StatusCode},
|
||||
};
|
||||
use chrono::Utc;
|
||||
@@ -41,37 +41,32 @@ pub async fn agent_job_signing_key(
|
||||
}
|
||||
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 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)?;
|
||||
if crate::permissions::require_principal(&mut tx, &principal, "inventory:read")
|
||||
.await
|
||||
.is_err()
|
||||
{
|
||||
// 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")
|
||||
@@ -89,66 +84,6 @@ pub async fn tenants(
|
||||
return Err(StatusCode::FORBIDDEN);
|
||||
}
|
||||
Ok(Json(
|
||||
json!({"items": items, "next_cursor":null,"completeness":"complete","truncated":false,"as_of":Utc::now()}),
|
||||
json!({"items": items, "can_manage_customers":can_manage, "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.reported_agent_version,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"),"agent_version":r.get::<Option<String>,_>("reported_agent_version"),"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}),
|
||||
)
|
||||
}
|
||||
|
||||
@@ -261,13 +261,26 @@ impl Auth {
|
||||
}
|
||||
p
|
||||
};
|
||||
if p.name.starts_with("local:")
|
||||
&& !self
|
||||
if p.name.starts_with("local:") {
|
||||
let home = self
|
||||
.local
|
||||
.as_ref()
|
||||
.is_some_and(|local| local.enabled(&p.name, p.tenant))
|
||||
{
|
||||
return Err(StatusCode::FORBIDDEN);
|
||||
.and_then(|local| local.home(&p.name))
|
||||
.ok_or(StatusCode::FORBIDDEN)?;
|
||||
let tenants: Vec<Uuid> = sqlx::query_scalar("SELECT local_customer_tenants($1,$2)")
|
||||
.bind(&p.name)
|
||||
.bind(home)
|
||||
.fetch_one(&state.pool)
|
||||
.await
|
||||
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
||||
if !tenants.contains(&home) {
|
||||
return Err(StatusCode::FORBIDDEN);
|
||||
}
|
||||
p.tenant = selected.unwrap_or(home);
|
||||
if !tenants.contains(&p.tenant) {
|
||||
return Err(StatusCode::NOT_FOUND);
|
||||
}
|
||||
p.tenants = tenants;
|
||||
}
|
||||
if selected.is_some_and(|t| t != p.tenant) {
|
||||
return Err(StatusCode::NOT_FOUND);
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
//! Fresh-device bootstrap. Public scripts contain no credentials. Downloads use
|
||||
//! the tenant's one-time enrollment token until the final enrollment consumes it.
|
||||
use super::*;
|
||||
mod starter;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
@@ -22,7 +23,7 @@ struct TenantPins { current: Pin, previous: Vec<Previous> }
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub(super) struct UpdaterQuery { platform: Platform, sha256: Option<String> }
|
||||
|
||||
fn config(platform: Platform, tenant: Uuid, wanted: Option<&str>) -> Result<Config, Error> {
|
||||
async fn config(s: &crate::State, platform: Platform, tenant: Uuid, wanted: Option<&str>) -> Result<Config, Error> {
|
||||
let slot = match platform {
|
||||
Platform::LinuxX64 => "RMM_AGENT_BOOTSTRAP_LINUX_FILE",
|
||||
Platform::WindowsX64 => "RMM_AGENT_BOOTSTRAP_WINDOWS_FILE",
|
||||
@@ -42,6 +43,15 @@ fn config(platform: Platform, tenant: Uuid, wanted: Option<&str>) -> Result<Conf
|
||||
};
|
||||
config.updater_sha256 = selected.sha256;
|
||||
config.updater_bytes = selected.bytes;
|
||||
} else {
|
||||
let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?;
|
||||
let pin = sqlx::query("SELECT sha256,size_bytes FROM customer_starter_workers WHERE platform=$1")
|
||||
.bind(platform_name(platform)).fetch_optional(&mut *tx).await?;
|
||||
tx.commit().await?;
|
||||
if let Some(pin) = pin {
|
||||
config.updater_sha256 = pin.get("sha256");
|
||||
config.updater_bytes = pin.get::<i64, _>("size_bytes") as u64;
|
||||
}
|
||||
}
|
||||
if wanted.is_some_and(|digest| digest != config.updater_sha256) { return Err(missing()); }
|
||||
let url = url::Url::parse(&config.gateway_origin).map_err(|_| invalid())?;
|
||||
@@ -98,6 +108,7 @@ pub(super) async fn issue(
|
||||
let mut bytes = [0; 32];
|
||||
openssl::rand::rand_bytes(&mut bytes).map_err(|_| fail("TOKEN_GENERATION_FAILED"))?;
|
||||
let token = hex::encode(bytes);
|
||||
starter::publish_missing(&mut tx, t).await?;
|
||||
let release_platforms: Vec<String> =
|
||||
sqlx::query_scalar("SELECT DISTINCT platform FROM agent_update_releases ORDER BY platform")
|
||||
.fetch_all(&mut *tx)
|
||||
@@ -170,7 +181,7 @@ pub(super) async fn current(
|
||||
Query(q): Query<Current>,
|
||||
) -> Result<Response, Error> {
|
||||
let t = token_tenant(&s, &headers).await?;
|
||||
let c = config(q.platform, t, None)?;
|
||||
let c = config(&s, q.platform, t, None).await?;
|
||||
let mut tx = rmm_persistence::tenant_tx(&s.pool, t).await?;
|
||||
let release: Uuid = sqlx::query_scalar("SELECT release_id FROM agent_update_releases WHERE platform=$1 ORDER BY release_sequence DESC LIMIT 1")
|
||||
.bind(platform_name(q.platform)).fetch_optional(&mut *tx).await?.ok_or_else(missing)?;
|
||||
@@ -217,6 +228,6 @@ pub(super) async fn updater(
|
||||
Query(q): Query<UpdaterQuery>,
|
||||
) -> Result<Response, Error> {
|
||||
let tenant = token_tenant(&s, &headers).await?;
|
||||
let c = config(q.platform, tenant, q.sha256.as_deref())?;
|
||||
let c = config(&s, q.platform, tenant, q.sha256.as_deref()).await?;
|
||||
verified_binary(tenant, c.updater_sha256, c.updater_bytes).await
|
||||
}
|
||||
|
||||
@@ -0,0 +1,73 @@
|
||||
//! Seed empty platform catalogs from the operator's protected distribution
|
||||
//! directory during enrollment. Every download still uses the customer's own
|
||||
//! catalog, stable-worker pin and verified object store.
|
||||
use super::*;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct Starter {
|
||||
envelope: ReleaseEnvelope,
|
||||
worker: Pin,
|
||||
}
|
||||
|
||||
pub(super) async fn publish_missing(tx: &mut Transaction<'_, Postgres>, tenant: Uuid) -> Result<(), Error> {
|
||||
let Some(slot) = std::env::var_os("RMM_AGENT_BOOTSTRAP_LINUX_FILE") else { return Ok(()) };
|
||||
let Some(config_dir) = FsPath::new(&slot).parent() else { return Err(invalid()) };
|
||||
let distribution = config_dir.join("customer-starters");
|
||||
if !distribution.try_exists().map_err(|_| fail("STARTER_CONFIGURATION"))? { return Ok(()) }
|
||||
for platform in [Platform::LinuxX64, Platform::WindowsGnuX64, Platform::WindowsX64] {
|
||||
let name = platform_name(platform);
|
||||
let exists: bool = sqlx::query_scalar("SELECT EXISTS(SELECT FROM agent_update_releases WHERE platform=$1)")
|
||||
.bind(name).fetch_one(&mut **tx).await?;
|
||||
if exists { continue; }
|
||||
let path = distribution.join(format!("{name}.json"));
|
||||
if !path.try_exists().map_err(|_| fail("STARTER_CONFIGURATION"))? { continue; }
|
||||
// Other requests may be publishing the first package for this customer.
|
||||
sqlx::query("SELECT pg_advisory_xact_lock(hashtextextended($1, 312))")
|
||||
.bind(format!("{tenant}/{name}")).execute(&mut **tx).await?;
|
||||
let exists: bool = sqlx::query_scalar("SELECT EXISTS(SELECT FROM agent_update_releases WHERE platform=$1)")
|
||||
.bind(name).fetch_one(&mut **tx).await?;
|
||||
if exists { continue; }
|
||||
let package: Starter = serde_json::from_slice(&protected_file(&path, 65536)?)?;
|
||||
let manifest = verify_envelope(&package.envelope, None)?;
|
||||
if manifest.platform != platform { return Err(invalid()); }
|
||||
let root = std::env::var("RMM_AGENT_UPDATE_ARTIFACT_DIR").map_err(|_| fail("STARTER_STORE"))?;
|
||||
if !FsPath::new(&root).is_absolute() { return Err(invalid()); }
|
||||
let owner = fs::symlink_metadata(&path).map_err(|_| fail("STARTER_CONFIGURATION"))?.uid();
|
||||
let src = distribution.clone();
|
||||
let mut files: Vec<_> = manifest.artifacts.iter().map(|a| (a.sha256.clone(),a.bytes)).collect();
|
||||
files.push((package.worker.sha256.clone(), package.worker.bytes));
|
||||
tokio::task::spawn_blocking(move || -> Result<(), Error> {
|
||||
let store = UpdateArtifacts::private_directory(root.into(), owner)?;
|
||||
for (digest, size) in files {
|
||||
let mut staged = store.begin(tenant,&digest,size)?;
|
||||
let mut file = fs::OpenOptions::new().read(true).custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC)
|
||||
.open(src.join(&digest)).map_err(|_| fail("STARTER_OBJECT_MISSING"))?;
|
||||
let meta = file.metadata().map_err(|_| fail("STARTER_OBJECT_METADATA"))?;
|
||||
if !meta.is_file() || meta.uid()!=owner || meta.mode() & 0o777 != 0o600 || meta.len()!=size { return Err(fail("STARTER_OBJECT_METADATA")); }
|
||||
let mut buffer = [0; 65536];
|
||||
loop {
|
||||
let n = file.read(&mut buffer).map_err(|_| fail("STARTER_OBJECT_READ"))?;
|
||||
if n == 0 { break; }
|
||||
staged.append(&buffer[..n])?;
|
||||
}
|
||||
staged.finish(&store,tenant)?;
|
||||
}
|
||||
Ok(())
|
||||
}).await.map_err(|_| fail("STARTER_OBJECT_COPY"))??;
|
||||
for artifact in &manifest.artifacts {
|
||||
sqlx::query("INSERT INTO agent_update_artifacts(tenant_id,artifact_id,sha256,size_bytes) VALUES($1,$2,$3,$4) ON CONFLICT DO NOTHING")
|
||||
.bind(tenant).bind(artifact.artifact_id).bind(&artifact.sha256).bind(artifact.bytes as i64).execute(&mut **tx).await?;
|
||||
}
|
||||
let raw = encode(&package.envelope)?;
|
||||
let a = &manifest.artifacts[0];
|
||||
let h = &manifest.artifacts[1];
|
||||
sqlx::query("INSERT INTO agent_update_releases(tenant_id,release_id,platform,release_sequence,manifest_sha256,envelope_sha256,envelope,agent_artifact_id,agent_sha256,agent_bytes,helper_artifact_id,helper_sha256,helper_bytes) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)")
|
||||
.bind(tenant).bind(manifest.release_id).bind(name).bind(i64::try_from(manifest.release_sequence).map_err(|_|invalid())?)
|
||||
.bind(hash(&package.envelope.decode().map_err(|_|invalid())?.payload_bytes)).bind(hash(&raw)).bind(raw)
|
||||
.bind(a.artifact_id).bind(&a.sha256).bind(a.bytes as i64).bind(h.artifact_id).bind(&h.sha256).bind(h.bytes as i64).execute(&mut **tx).await?;
|
||||
sqlx::query("INSERT INTO customer_starter_workers VALUES($1,$2,$3,$4)")
|
||||
.bind(tenant).bind(name).bind(package.worker.sha256).bind(package.worker.bytes as i64).execute(&mut **tx).await?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -25,6 +25,10 @@ pub fn routes(r: Router<crate::State>) -> Router<crate::State> {
|
||||
"/api/v1/tenants/{tenant}/devices/{asset}/revocation",
|
||||
post(revoke_device),
|
||||
)
|
||||
.route(
|
||||
"/api/v1/tenants/{tenant}/devices/{asset}/archive",
|
||||
post(archive_device),
|
||||
)
|
||||
.route(
|
||||
"/api/v1/tenants/{tenant}/operation-plans/{plan}/revocation",
|
||||
post(revoke_plan),
|
||||
@@ -63,6 +67,39 @@ async fn audit(
|
||||
sqlx::query("INSERT INTO audit_events VALUES($1,$2,$3,$4,$5,now())").bind(p.tenant).bind(Uuid::new_v4()).bind(&p.name).bind(event).bind(json!({"decision":data,"session_hash":p.session_hash,"approval_origin":p.approval_origin(),"testsimulation":p.testsimulation})).execute(&mut **tx).await?;
|
||||
Ok(())
|
||||
}
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct Archive {
|
||||
archived: bool,
|
||||
}
|
||||
async fn archive_device(
|
||||
State(s): State<crate::State>,
|
||||
h: HeaderMap,
|
||||
Path((tenant, asset)): Path<(Uuid, Uuid)>,
|
||||
Json(input): Json<Archive>,
|
||||
) -> Result<Json<Value>, Error> {
|
||||
let event = if input.archived {
|
||||
"device_archived"
|
||||
} else {
|
||||
"device_restored"
|
||||
};
|
||||
let (p, mut tx) = context(&s, &h, tenant, "devices:revoke", event).await?;
|
||||
let current: Option<chrono::DateTime<chrono::Utc>> = sqlx::query_scalar(
|
||||
"SELECT archived_at FROM assets WHERE tenant_id=$1 AND asset_id=$2 FOR UPDATE",
|
||||
)
|
||||
.bind(tenant)
|
||||
.bind(asset)
|
||||
.fetch_optional(&mut *tx)
|
||||
.await?
|
||||
.ok_or(Error(StatusCode::NOT_FOUND, "NOT_FOUND"))?;
|
||||
if current.is_some() != input.archived {
|
||||
sqlx::query("UPDATE assets SET archived_at=CASE WHEN $3 THEN now() END WHERE tenant_id=$1 AND asset_id=$2")
|
||||
.bind(tenant).bind(asset).bind(input.archived).execute(&mut *tx).await?;
|
||||
audit(&mut tx, &p, event, json!({"asset_id":asset})).await?;
|
||||
}
|
||||
tx.commit().await?;
|
||||
Ok(Json(json!({"asset_id":asset, "archived":input.archived})))
|
||||
}
|
||||
pub async fn revoke_device(
|
||||
State(s): State<crate::State>,
|
||||
h: HeaderMap,
|
||||
|
||||
@@ -0,0 +1,96 @@
|
||||
//! Customer directory administration. Customer IDs are the existing tenant IDs.
|
||||
use crate::{auth::Principal, jobs::Error};
|
||||
use axum::{
|
||||
Json,
|
||||
extract::{Path, State},
|
||||
http::{HeaderMap, StatusCode},
|
||||
};
|
||||
use serde::Deserialize;
|
||||
use serde_json::{Value, json};
|
||||
use sqlx::{Postgres, Transaction};
|
||||
use uuid::Uuid;
|
||||
|
||||
pub fn database_error(e: sqlx::Error) -> Error {
|
||||
match e.as_database_error().and_then(|e| e.code()).as_deref() {
|
||||
Some("23505") => Error(StatusCode::CONFLICT, "CUSTOMER_ALREADY_EXISTS"),
|
||||
Some("42501") => Error(StatusCode::FORBIDDEN, "FORBIDDEN"),
|
||||
Some("22023") => Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"),
|
||||
_ => e.into(),
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn can_manage(
|
||||
p: &Principal,
|
||||
tx: &mut Transaction<'_, Postgres>,
|
||||
) -> Result<bool, sqlx::Error> {
|
||||
if p.testsimulation
|
||||
|| p.session_hash.is_none()
|
||||
|| p.csrf.is_none()
|
||||
|| !p.name.starts_with("local:")
|
||||
{
|
||||
return Ok(false);
|
||||
}
|
||||
sqlx::query_scalar("SELECT is_customer_admin($1)")
|
||||
.bind(&p.name)
|
||||
.fetch_one(&mut **tx)
|
||||
.await
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Input {
|
||||
name: String,
|
||||
}
|
||||
|
||||
pub async fn create(
|
||||
State(state): State<crate::State>,
|
||||
headers: HeaderMap,
|
||||
Json(input): Json<Input>,
|
||||
) -> Result<Json<Value>, Error> {
|
||||
manage(&state, &headers, input, None).await
|
||||
}
|
||||
pub async fn rename(
|
||||
State(state): State<crate::State>,
|
||||
Path(id): Path<Uuid>,
|
||||
headers: HeaderMap,
|
||||
Json(input): Json<Input>,
|
||||
) -> Result<Json<Value>, Error> {
|
||||
manage(&state, &headers, input, Some(id)).await
|
||||
}
|
||||
async fn manage(
|
||||
state: &crate::State,
|
||||
headers: &HeaderMap,
|
||||
input: Input,
|
||||
existing: Option<Uuid>,
|
||||
) -> Result<Json<Value>, Error> {
|
||||
let p = state
|
||||
.auth
|
||||
.principal(state, headers, true)
|
||||
.await
|
||||
.map_err(|s| Error(s, crate::auth::error_code(s)))?;
|
||||
if input.name.is_empty()
|
||||
|| input.name.trim() != input.name
|
||||
|| input.name.chars().count() > 120
|
||||
|| input.name.chars().any(char::is_control)
|
||||
{
|
||||
return Err(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"));
|
||||
}
|
||||
if existing.is_some_and(|id| id != p.tenant) {
|
||||
return Err(Error(StatusCode::NOT_FOUND, "NOT_FOUND"));
|
||||
}
|
||||
let mut tx = rmm_persistence::tenant_tx(&state.pool, p.tenant).await?;
|
||||
if !can_manage(&p, &mut tx).await? {
|
||||
return Err(Error(StatusCode::FORBIDDEN, "CUSTOMER_ADMIN_REQUIRED"));
|
||||
}
|
||||
let id = existing.unwrap_or_else(Uuid::new_v4);
|
||||
sqlx::query("SELECT manage_customer($1,$2,$3,$4)")
|
||||
.bind(&p.name)
|
||||
.bind(id)
|
||||
.bind(&input.name)
|
||||
.bind(existing.is_none())
|
||||
.execute(&mut *tx)
|
||||
.await
|
||||
.map_err(database_error)?;
|
||||
tx.commit().await?;
|
||||
Ok(Json(json!({"tenant_id":id,"name":input.name})))
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
WITH classified AS (
|
||||
SELECT a.tenant_id,a.asset_id,a.agent_id,a.created_at,a.revoked_at,a.last_contact_at,
|
||||
a.last_authenticated_at,a.last_authenticated_certificate_sha256,a.certificate_sha256,
|
||||
a.enrollment_generation,a.assignment_version,a.capabilities,a.reported_agent_version,
|
||||
asset.archived_at,t.name AS customer_name,
|
||||
CASE
|
||||
WHEN a.revoked_at IS NOT NULL THEN 'revoked'
|
||||
WHEN asset.archived_at IS NOT NULL THEN 'archived'
|
||||
WHEN a.last_contact_at IS NULL THEN 'never_seen'
|
||||
WHEN a.last_authenticated_at IS NULL THEN 'unverified'
|
||||
WHEN EXISTS (
|
||||
SELECT 1 FROM agent_installations newer
|
||||
WHERE newer.tenant_id=a.tenant_id AND newer.asset_id=a.asset_id
|
||||
AND newer.enrollment_generation>a.enrollment_generation
|
||||
AND newer.last_contact_at IS NOT NULL AND newer.last_authenticated_at IS NOT NULL
|
||||
AND newer.created_at<=$2
|
||||
) THEN 'replaced'
|
||||
ELSE 'current'
|
||||
END AS lifecycle,
|
||||
CASE WHEN a.last_contact_at IS NULL THEN 'never_seen'
|
||||
WHEN a.last_contact_at>$2::timestamptz-interval '90 seconds' THEN 'online'
|
||||
ELSE 'offline' END AS status
|
||||
FROM agent_installations a
|
||||
JOIN assets asset USING (tenant_id,asset_id)
|
||||
JOIN tenants t USING(tenant_id)
|
||||
WHERE a.tenant_id=$1 AND a.created_at<=$2 AND a.agent_id>$3
|
||||
AND ($4::uuid IS NULL OR a.asset_id=$4)
|
||||
AND ($5::uuid IS NULL OR a.agent_id=$5)
|
||||
)
|
||||
SELECT c.*,o.observed_at,o.received_at,o.data,o.source_id FROM classified c
|
||||
LEFT JOIN LATERAL (
|
||||
SELECT observed_at,received_at,data,source_id FROM observations
|
||||
WHERE tenant_id=c.tenant_id AND agent_id=c.agent_id AND received_at<=$2
|
||||
AND source_id IN ('linux.base','windows.base')
|
||||
ORDER BY observed_at DESC,received_at DESC,sequence DESC LIMIT 1
|
||||
) o ON true
|
||||
WHERE ($6::text IS NULL OR (c.lifecycle='current')=($6='current'))
|
||||
AND ($7::text IS NULL OR c.status=$7)
|
||||
AND ($8='' OR strpos(lower(o.data->>'hostname'),lower($8))>0)
|
||||
ORDER BY CASE WHEN $4 IS NOT NULL THEN (c.lifecycle='current') END DESC,
|
||||
CASE WHEN $4 IS NOT NULL THEN c.enrollment_generation END DESC,
|
||||
CASE WHEN $4 IS NOT NULL THEN c.created_at END DESC, c.agent_id
|
||||
LIMIT $9
|
||||
@@ -0,0 +1,478 @@
|
||||
//! Visible inventory for the fleet and for a single customer. Each database
|
||||
//! read stays inside an authorized customer's transaction, including pagination.
|
||||
use crate::{
|
||||
jobs::Error,
|
||||
pagination::{Cursor, PageQuery},
|
||||
};
|
||||
use axum::{
|
||||
Json,
|
||||
extract::{Path, Query, State},
|
||||
http::{HeaderMap, HeaderValue, StatusCode},
|
||||
};
|
||||
use chrono::{DateTime, Utc};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::{Value, json};
|
||||
use sqlx::{Postgres, Row, Transaction, postgres::PgRow};
|
||||
use uuid::Uuid;
|
||||
|
||||
#[derive(Default, Deserialize, Serialize, schemars::JsonSchema, Clone, Copy)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum View {
|
||||
#[default]
|
||||
Current,
|
||||
History,
|
||||
}
|
||||
impl View {
|
||||
fn name(self) -> &'static str {
|
||||
match self {
|
||||
Self::Current => "current",
|
||||
Self::History => "history",
|
||||
}
|
||||
}
|
||||
}
|
||||
#[derive(Deserialize, Serialize, schemars::JsonSchema, Clone, Copy)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum Status {
|
||||
Online,
|
||||
Offline,
|
||||
}
|
||||
impl Status {
|
||||
fn name(self) -> &'static str {
|
||||
match self {
|
||||
Self::Online => "online",
|
||||
Self::Offline => "offline",
|
||||
}
|
||||
}
|
||||
}
|
||||
#[derive(Default, Deserialize, schemars::JsonSchema)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Filters {
|
||||
pub cursor: Option<String>,
|
||||
pub limit: Option<u16>,
|
||||
#[serde(default)]
|
||||
pub view: View,
|
||||
pub status: Option<Status>,
|
||||
pub q: Option<String>,
|
||||
}
|
||||
#[derive(Default, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct DetailQuery {
|
||||
pub agent_id: Option<Uuid>,
|
||||
}
|
||||
|
||||
pub async fn page(
|
||||
State(s): State<crate::State>,
|
||||
h: HeaderMap,
|
||||
Path(tenant): Path<Uuid>,
|
||||
Query(q): Query<Filters>,
|
||||
) -> Result<Json<Value>, Error> {
|
||||
list(&s, &h, Some(tenant), q).await.map(Json)
|
||||
}
|
||||
pub async fn all(
|
||||
State(s): State<crate::State>,
|
||||
h: HeaderMap,
|
||||
Query(q): Query<Filters>,
|
||||
) -> Result<Json<Value>, Error> {
|
||||
list(&s, &h, None, q).await.map(Json)
|
||||
}
|
||||
|
||||
struct Selection<'a> {
|
||||
tenant: Uuid,
|
||||
asset: Option<Uuid>,
|
||||
agent: Option<Uuid>,
|
||||
view: Option<View>,
|
||||
status: Option<Status>,
|
||||
hostname: &'a str,
|
||||
last: Uuid,
|
||||
as_of: DateTime<Utc>,
|
||||
limit: i64,
|
||||
}
|
||||
impl Selection<'_> {
|
||||
async fn rows(&self, tx: &mut Transaction<'_, Postgres>) -> Result<Vec<PgRow>, Error> {
|
||||
Ok(sqlx::query(include_str!("device_list.sql"))
|
||||
.bind(self.tenant)
|
||||
.bind(self.as_of)
|
||||
.bind(self.last)
|
||||
.bind(self.asset)
|
||||
.bind(self.agent)
|
||||
.bind(self.view.map(View::name))
|
||||
.bind(self.status.map(Status::name))
|
||||
.bind(self.hostname)
|
||||
.bind(self.limit)
|
||||
.fetch_all(&mut **tx)
|
||||
.await?)
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn list(
|
||||
s: &crate::State,
|
||||
h: &HeaderMap,
|
||||
tenant: Option<Uuid>,
|
||||
q: Filters,
|
||||
) -> Result<Value, Error> {
|
||||
let p = crate::jobs::principal(s, h, false).await?;
|
||||
let mut tenants = match tenant {
|
||||
Some(id) => {
|
||||
crate::jobs::scope(&p, id, false)?;
|
||||
vec![id]
|
||||
}
|
||||
None => p.tenants.clone(),
|
||||
};
|
||||
tenants.sort_unstable();
|
||||
tenants.dedup();
|
||||
let hostname = q.q.as_deref().unwrap_or("").trim();
|
||||
if hostname.len() > 255 || hostname.chars().any(char::is_control) {
|
||||
return Err(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"));
|
||||
}
|
||||
let binding = json!([tenant, tenants, q.view, q.status, hostname]);
|
||||
let scope = format!(
|
||||
"device-fleet:{}",
|
||||
rmm_domain::jobs::hash(binding.to_string().as_bytes())
|
||||
);
|
||||
let mut page = Cursor::parse(
|
||||
s,
|
||||
&p,
|
||||
&scope,
|
||||
PageQuery {
|
||||
cursor: q.cursor,
|
||||
limit: q.limit,
|
||||
},
|
||||
)
|
||||
.map_err(|code| Error(code, crate::auth::error_code(code)))?;
|
||||
let capacity = usize::from(page.limit);
|
||||
let mut items = Vec::new();
|
||||
let mut last = None;
|
||||
let mut truncated = false;
|
||||
let mut authorized = false;
|
||||
for customer in tenants {
|
||||
if page.last_tenant.is_some_and(|after| customer < after) {
|
||||
continue;
|
||||
}
|
||||
let mut headers = h.clone();
|
||||
headers.insert(
|
||||
"x-rmm-tenant",
|
||||
HeaderValue::from_str(&customer.to_string())
|
||||
.map_err(|_| Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"))?,
|
||||
);
|
||||
let current = crate::jobs::principal(s, &headers, false).await?;
|
||||
crate::jobs::scope(¤t, customer, false)?;
|
||||
let mut tx = rmm_persistence::tenant_tx(&s.pool, customer).await?;
|
||||
match crate::permissions::require_principal(&mut tx, ¤t, "inventory:read").await {
|
||||
Err(Error(StatusCode::FORBIDDEN, _)) if tenant.is_none() => continue,
|
||||
other => other?,
|
||||
}
|
||||
authorized = true;
|
||||
let rows = Selection {
|
||||
tenant: customer,
|
||||
asset: None,
|
||||
agent: None,
|
||||
view: Some(q.view),
|
||||
status: q.status,
|
||||
hostname,
|
||||
last: if page.last_tenant == Some(customer) {
|
||||
page.last
|
||||
} else {
|
||||
Uuid::nil()
|
||||
},
|
||||
as_of: page.as_of,
|
||||
limit: (capacity + 1 - items.len()) as i64,
|
||||
}
|
||||
.rows(&mut tx)
|
||||
.await?;
|
||||
tx.commit().await?;
|
||||
for row in rows {
|
||||
if items.len() == capacity {
|
||||
truncated = true;
|
||||
break;
|
||||
}
|
||||
last = Some((customer, row.get::<Uuid, _>("agent_id")));
|
||||
items.push(project(&row, page.as_of, tenant.is_some()));
|
||||
}
|
||||
if truncated {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if !authorized {
|
||||
return Err(Error(StatusCode::FORBIDDEN, "FORBIDDEN"));
|
||||
}
|
||||
let next = if let Some((customer, agent)) = last.filter(|_| truncated) {
|
||||
page.last_tenant = Some(customer);
|
||||
Some(
|
||||
page.next(s, agent)
|
||||
.map_err(|code| Error(code, crate::auth::error_code(code)))?,
|
||||
)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
Ok(
|
||||
json!({"items":items,"next_cursor":next,"truncated":truncated,"completeness":if truncated{"partial"}else{"complete"},"as_of":page.as_of}),
|
||||
)
|
||||
}
|
||||
|
||||
pub async fn detail(
|
||||
State(s): State<crate::State>,
|
||||
h: HeaderMap,
|
||||
Path((tenant, asset)): Path<(Uuid, Uuid)>,
|
||||
Query(query): Query<DetailQuery>,
|
||||
) -> Result<Json<Value>, Error> {
|
||||
let p = crate::jobs::principal(&s, &h, false).await?;
|
||||
crate::jobs::scope(&p, tenant, false)?;
|
||||
let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?;
|
||||
crate::permissions::require_principal(&mut tx, &p, "inventory:read").await?;
|
||||
let now = Utc::now();
|
||||
let row = Selection {
|
||||
tenant,
|
||||
asset: Some(asset),
|
||||
agent: query.agent_id,
|
||||
view: None,
|
||||
status: None,
|
||||
hostname: "",
|
||||
last: Uuid::nil(),
|
||||
as_of: now,
|
||||
limit: 1,
|
||||
}
|
||||
.rows(&mut tx)
|
||||
.await?
|
||||
.pop()
|
||||
.ok_or(Error(StatusCode::NOT_FOUND, "NOT_FOUND"))?;
|
||||
let mut item = project(&row, now, true);
|
||||
item["volumes"] = volumes(&item["inventory"]);
|
||||
item["recent_jobs"] = if p.permits_scope("operations:read")
|
||||
&& crate::permissions::allowed(&mut tx, &p.name, "operations:read").await?
|
||||
{
|
||||
sqlx::query_scalar::<_,Value>("SELECT jsonb_build_object('job_id',j.job_id,'operation_id',j.operation_id,'state',j.state,'created_at',r.created_at) FROM jobs j JOIN approval_requests r USING(tenant_id,operation_id) WHERE j.tenant_id=$1 AND j.asset_id=$2 AND j.agent_id=$3 ORDER BY r.created_at DESC,j.job_id LIMIT 20")
|
||||
.bind(tenant).bind(asset).bind(row.get::<Uuid,_>("agent_id")).fetch_all(&mut *tx).await?.into()
|
||||
} else {
|
||||
Value::Null
|
||||
};
|
||||
tx.commit().await?;
|
||||
Ok(Json(item))
|
||||
}
|
||||
|
||||
fn observed<'a>(data: &'a Value, scope: &str) -> &'a Value {
|
||||
data["observations"]
|
||||
.as_array()
|
||||
.and_then(|items| {
|
||||
items
|
||||
.iter()
|
||||
.find(|o| o["scope"] == scope && o["quality"] == "valid")
|
||||
})
|
||||
.map(|o| &o["data"])
|
||||
.unwrap_or(&Value::Null)
|
||||
}
|
||||
fn volumes(data: &Value) -> Value {
|
||||
let mut items = Vec::new();
|
||||
if let Some(rows) = observed(data, "linux.volumes").as_array() {
|
||||
for entry in rows.iter().filter(|entry| entry["quality"] == "valid") {
|
||||
let v = &entry["data"];
|
||||
if v["mount_point"].is_string() {
|
||||
items.push(json!({"name":v["mount_point"],"free_bytes":v["available_bytes"].as_u64(),"total_bytes":v["total_bytes"].as_u64()}));
|
||||
}
|
||||
}
|
||||
}
|
||||
if items.is_empty() && data["root_total_bytes"].is_number() {
|
||||
let name = if observed(data, "windows.volumes").is_object() {
|
||||
"Systemvolume"
|
||||
} else {
|
||||
"/"
|
||||
};
|
||||
items.push(json!({"name":name,"free_bytes":data["root_available_bytes"],"total_bytes":data["root_total_bytes"]}));
|
||||
}
|
||||
items.into()
|
||||
}
|
||||
fn os_label(data: &Value) -> Option<String> {
|
||||
let raw = data["os"].as_str()?;
|
||||
if let Some(pretty) = observed(data, "linux.os")["release"]["PRETTY_NAME"].as_str() {
|
||||
return Some(pretty.to_owned());
|
||||
}
|
||||
if let Some(pretty) = raw.lines().find_map(|l| l.strip_prefix("PRETTY_NAME=")) {
|
||||
return Some(pretty.trim_matches(['"', '\'']).to_owned());
|
||||
}
|
||||
let product = observed(data, "windows.os");
|
||||
if let Some(name) = product["product_name"].as_str() {
|
||||
// Windows 11 can retain a Windows 10 client ProductName for compatibility.
|
||||
let product_name = match (
|
||||
name.strip_prefix("Windows 10 "),
|
||||
product["build"]
|
||||
.as_str()
|
||||
.and_then(|s| s.parse::<u32>().ok()),
|
||||
) {
|
||||
(Some(edition), Some(build))
|
||||
if build >= 22000
|
||||
&& ["Home", "Pro", "Enterprise", "Education", "IoT"]
|
||||
.iter()
|
||||
.any(|prefix| {
|
||||
edition == *prefix
|
||||
|| edition
|
||||
.strip_prefix(prefix)
|
||||
.is_some_and(|suffix| suffix.starts_with(' '))
|
||||
}) =>
|
||||
{
|
||||
format!("Windows 11 {edition}")
|
||||
}
|
||||
_ => name.to_owned(),
|
||||
};
|
||||
return Some(
|
||||
match product["display_version"]
|
||||
.as_str()
|
||||
.filter(|v| !v.is_empty())
|
||||
{
|
||||
Some(version) => format!("{product_name} {version}"),
|
||||
None => product_name,
|
||||
},
|
||||
);
|
||||
}
|
||||
if !raw.contains('\n') {
|
||||
Some(raw.to_owned())
|
||||
} else {
|
||||
Some("Linux".to_owned())
|
||||
}
|
||||
}
|
||||
fn project(row: &PgRow, now: DateTime<Utc>, full: bool) -> Value {
|
||||
let data = row.get::<Option<Value>, _>("data").unwrap_or(Value::Null);
|
||||
let cpu = observed(&data, "linux.cpu");
|
||||
let windows = observed(&data, "windows.hardware");
|
||||
let last = row.get::<Option<DateTime<Utc>>, _>("last_contact_at");
|
||||
let revoked = row.get::<Option<DateTime<Utc>>, _>("revoked_at");
|
||||
let presence = match (revoked, last.map(|t| (now - t).num_seconds())) {
|
||||
(Some(_), _) => "revoked",
|
||||
(_, None) => "never_seen",
|
||||
(_, Some(age)) if age < 90 => "online",
|
||||
(_, Some(age)) if age < 180 => "stale",
|
||||
_ => "unreachable",
|
||||
};
|
||||
let mut item = json!({
|
||||
"tenant_id":row.get::<Uuid,_>("tenant_id"),"customer_name":row.get::<String,_>("customer_name"),
|
||||
"agent_id":row.get::<Uuid,_>("agent_id"),"asset_id":row.get::<Uuid,_>("asset_id"),
|
||||
"status":row.get::<String,_>("status"),"lifecycle":row.get::<String,_>("lifecycle"),
|
||||
"archived_at":row.get::<Option<DateTime<Utc>>,_>("archived_at"),"revoked_at":revoked,
|
||||
"hostname":data["hostname"].as_str(),"os":os_label(&data),
|
||||
"disk_free_bytes":data["root_available_bytes"].as_u64(),"disk_total_bytes":data["root_total_bytes"].as_u64(),
|
||||
"cpu_model":cpu["model"].as_str().or_else(||windows["cpu_model"].as_str()),
|
||||
"cpu_logical_count":cpu["logical_processors"].as_u64().or_else(||windows["logical_processors_visible"].as_u64()),
|
||||
"ram_total_bytes":observed(&data,"linux.memory")["total_bytes"].as_u64().or_else(||windows["memory_total_bytes"].as_u64()),
|
||||
"last_contact_at":last,"agent_version":row.get::<Option<String>,_>("reported_agent_version"),
|
||||
"presence":presence,"observed_at":row.get::<Option<DateTime<Utc>>,_>("observed_at"),
|
||||
"received_at":row.get::<Option<DateTime<Utc>>,_>("received_at"),
|
||||
"source_id":row.get::<Option<String>,_>("source_id"),"quality":if data.is_null(){"unknown"}else{"valid"},
|
||||
"completeness":"partial","health":"unknown"
|
||||
});
|
||||
if full {
|
||||
item["inventory"] = data;
|
||||
item["capabilities"] = row.get("capabilities");
|
||||
item["enrollment_generation"] = row.get::<i64, _>("enrollment_generation").into();
|
||||
item["assignment_version"] = row.get::<i64, _>("assignment_version").into();
|
||||
item["certificate_sha256"] = row.get::<String, _>("certificate_sha256").into();
|
||||
item["last_authenticated_certificate_sha256"] =
|
||||
json!(row.get::<Option<String>, _>("last_authenticated_certificate_sha256"));
|
||||
item["last_authenticated_at"] =
|
||||
json!(row.get::<Option<DateTime<Utc>>, _>("last_authenticated_at"));
|
||||
}
|
||||
item
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn windows_os(name: &str, build: &str) -> String {
|
||||
let old = json!({"os":name,"observations":[{"scope":"windows.os","quality":"valid",
|
||||
"data":{"product_name":name,"build":build,"display_version":"26H2"}}]});
|
||||
os_label(&old).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn os_labels_keep_the_edition_and_handle_existing_snapshots() {
|
||||
assert_eq!(windows_os("Windows 10 Pro", "26300"), "Windows 11 Pro 26H2");
|
||||
assert_eq!(windows_os("Windows 10 Pro", "19045"), "Windows 10 Pro 26H2");
|
||||
assert_eq!(
|
||||
windows_os("Windows Server 2025", "26100"),
|
||||
"Windows Server 2025 26H2"
|
||||
);
|
||||
assert_eq!(
|
||||
windows_os("Windows 10 Pro", "invalid"),
|
||||
"Windows 10 Pro 26H2"
|
||||
);
|
||||
assert_eq!(
|
||||
windows_os("Windows 10 Custom", "26100"),
|
||||
"Windows 10 Custom 26H2"
|
||||
);
|
||||
let linux = json!({"os":"NAME=Example\nPRETTY_NAME=\"Test Linux 1.2\"\nID=linux"});
|
||||
assert_eq!(os_label(&linux).as_deref(), Some("Test Linux 1.2"));
|
||||
assert!(os_label(&Value::Null).is_none());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "requires the disposable RLS database from tests/local_access_database.py"]
|
||||
async fn visibility_is_filtered_before_the_cursor_limit() {
|
||||
let admin = sqlx::PgPool::connect(&std::env::var("RMM_TEST_REPAIR_ADMIN_URL").unwrap())
|
||||
.await
|
||||
.unwrap();
|
||||
let app = sqlx::PgPool::connect(&std::env::var("RMM_TEST_REPAIR_APP_URL").unwrap())
|
||||
.await
|
||||
.unwrap();
|
||||
let tenant = Uuid::new_v4();
|
||||
sqlx::query("INSERT INTO tenants(tenant_id,name) VALUES($1,'Filter test')")
|
||||
.bind(tenant)
|
||||
.execute(&admin)
|
||||
.await
|
||||
.unwrap();
|
||||
// In this order: archived, revoked, never connected, old unauthenticated
|
||||
// metadata, confirmed offline, confirmed online. Same hostnames are intentional.
|
||||
for n in 1..=6_i32 {
|
||||
let id = Uuid::from_u128(n as u128);
|
||||
sqlx::query("INSERT INTO assets(tenant_id,asset_id,archived_at) VALUES($1,$2,CASE WHEN $3=1 THEN now() END)")
|
||||
.bind(tenant).bind(id).bind(n).execute(&admin).await.unwrap();
|
||||
let cert = hex::encode(openssl::sha::sha256(format!("{tenant}/{id}").as_bytes()));
|
||||
sqlx::query("INSERT INTO agent_installations(tenant_id,asset_id,agent_id,certificate_sha256,revoked_at,last_contact_at,last_authenticated_at,last_authenticated_certificate_sha256) VALUES($1,$2,$2,$3,CASE WHEN $4=2 THEN now() END,CASE WHEN $4=5 THEN now()-interval '30 days' WHEN $4<>3 THEN now() END,CASE WHEN $4 NOT IN (3,4) THEN now() END, CASE WHEN $4 NOT IN (3,4) THEN $3 END)")
|
||||
.bind(tenant).bind(id).bind(cert).bind(n).execute(&admin).await.unwrap();
|
||||
let data = json!({"hostname":"same-host","os":"Ubuntu","root_available_bytes":10,"root_total_bytes":20,
|
||||
"observations":[{"scope":"linux.memory","quality":"valid","data":{"total_bytes":1024}},{"scope":"linux.cpu","quality":"valid","data":{"logical_processors":2,"model":"Test CPU"}}]});
|
||||
sqlx::query("INSERT INTO observations(tenant_id,agent_id,message_id,boot_id,sequence,observed_at,source_id,quality,completeness,snapshot_id,data,payload_sha256) VALUES($1,$2,$3,$4,1,now(),'linux.base','valid','partial',$5,$6,$7)")
|
||||
.bind(tenant).bind(id).bind(Uuid::new_v4()).bind(Uuid::new_v4()).bind(Uuid::new_v4()).bind(data).bind("0".repeat(64)).execute(&admin).await.unwrap();
|
||||
}
|
||||
let mut tx = rmm_persistence::tenant_tx(&app, tenant).await.unwrap();
|
||||
let mut q = Selection {
|
||||
tenant,
|
||||
asset: None,
|
||||
agent: None,
|
||||
view: Some(View::Current),
|
||||
status: None,
|
||||
hostname: "AME-h",
|
||||
last: Uuid::nil(),
|
||||
as_of: Utc::now(),
|
||||
limit: 1,
|
||||
};
|
||||
let row = q.rows(&mut tx).await.unwrap().pop().unwrap();
|
||||
let summary = project(&row, q.as_of, false);
|
||||
assert_eq!(summary["status"], "offline");
|
||||
assert_eq!(summary["ram_total_bytes"], 1024);
|
||||
assert_eq!(summary["cpu_model"], "Test CPU");
|
||||
assert_eq!(summary["disk_free_bytes"], 10);
|
||||
q.last = row.get("agent_id");
|
||||
assert_eq!(
|
||||
q.rows(&mut tx).await.unwrap()[0].get::<String, _>("status"),
|
||||
"online"
|
||||
);
|
||||
q.status = Some(Status::Offline);
|
||||
assert!(q.rows(&mut tx).await.unwrap().is_empty());
|
||||
q.status = None;
|
||||
q.last = Uuid::nil();
|
||||
q.view = Some(View::History);
|
||||
q.limit = 10;
|
||||
let got: Vec<String> = q
|
||||
.rows(&mut tx)
|
||||
.await
|
||||
.unwrap()
|
||||
.iter()
|
||||
.map(|r| r.get("lifecycle"))
|
||||
.collect();
|
||||
assert_eq!(got, ["archived", "revoked", "never_seen", "unverified"]);
|
||||
q.hostname = "%";
|
||||
assert!(q.rows(&mut tx).await.unwrap().is_empty());
|
||||
q.hostname = "";
|
||||
q.tenant = Uuid::new_v4();
|
||||
assert!(q.rows(&mut tx).await.unwrap().is_empty());
|
||||
tx.rollback().await.unwrap();
|
||||
}
|
||||
}
|
||||
@@ -1065,7 +1065,10 @@ pub async fn requester_enabled(
|
||||
tenant: Uuid,
|
||||
) -> std::result::Result<bool, sqlx::Error> {
|
||||
if name.starts_with("mcp:") {
|
||||
crate::mcp_tokens::enabled_in(tx, name).await
|
||||
crate::mcp_tokens::issuer_enabled(state, tx, name).await
|
||||
} else if name.starts_with("local:") {
|
||||
let Some(home)=state.auth.local.as_ref().and_then(|local|local.home(name)) else {return Ok(false);};
|
||||
sqlx::query_scalar("SELECT $3=ANY(local_customer_tenants($1,$2))").bind(name).bind(home).bind(tenant).fetch_one(&mut **tx).await
|
||||
} else {
|
||||
Ok(state.auth.operator_enabled(name, tenant))
|
||||
}
|
||||
|
||||
@@ -210,6 +210,12 @@ impl LocalAuth {
|
||||
workers: Arc::new(Semaphore::new(1)),
|
||||
})
|
||||
}
|
||||
pub fn home(&self, principal: &str) -> Option<Uuid> {
|
||||
self.users
|
||||
.iter()
|
||||
.find(|user| !user.disabled && user.principal == principal)
|
||||
.map(|user| user.tenant)
|
||||
}
|
||||
pub fn enabled(&self, principal: &str, tenant: Uuid) -> bool {
|
||||
self.users
|
||||
.iter()
|
||||
|
||||
@@ -6,10 +6,12 @@ mod agent_update_health;
|
||||
mod agent_update_policy;
|
||||
mod agent_updates;
|
||||
mod api;
|
||||
mod devices;
|
||||
mod artifact_store;
|
||||
mod auth;
|
||||
mod local_auth;
|
||||
mod mcp_tokens;
|
||||
mod customers;
|
||||
mod catalog;
|
||||
mod checkpoint_repair;
|
||||
mod controls;
|
||||
@@ -208,9 +210,11 @@ async fn main() -> Result<()> {
|
||||
.route("/auth/session", get(auth::session))
|
||||
.route("/auth/logout", post(auth::logout))
|
||||
.route("/api/v1/job-signing-key", get(api::job_signing_key))
|
||||
.route("/api/v1/tenants", get(api::tenants))
|
||||
.route("/api/v1/tenants/{tenant}/devices", get(api::devices_page))
|
||||
.route("/api/v1/tenants/{tenant}/devices/{asset}", get(api::device));
|
||||
.route("/api/v1/tenants", get(api::tenants).post(customers::create))
|
||||
.route("/api/v1/tenants/{tenant}", axum::routing::patch(customers::rename))
|
||||
.route("/api/v1/devices", get(devices::all))
|
||||
.route("/api/v1/tenants/{tenant}/devices", get(devices::page))
|
||||
.route("/api/v1/tenants/{tenant}/devices/{asset}", get(devices::detail));
|
||||
routes = mcp_tokens::routes(routes);
|
||||
routes = routes.route("/auth/local/login", post(auth::local_login));
|
||||
routes = jobs::routes(routes);
|
||||
|
||||
+29
-14
@@ -38,9 +38,21 @@ struct Devices {
|
||||
}
|
||||
#[derive(Deserialize, schemars::JsonSchema)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct Fleet {
|
||||
tenant_id: Option<Uuid>,
|
||||
cursor: Option<String>,
|
||||
limit: Option<u16>,
|
||||
#[serde(default)]
|
||||
view: crate::devices::View,
|
||||
status: Option<crate::devices::Status>,
|
||||
q: Option<String>,
|
||||
}
|
||||
#[derive(Deserialize, schemars::JsonSchema)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct Device {
|
||||
tenant_id: Uuid,
|
||||
asset_id: Uuid,
|
||||
agent_id: Option<Uuid>,
|
||||
}
|
||||
#[derive(Deserialize, schemars::JsonSchema)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
@@ -96,9 +108,9 @@ fn tools() -> Vec<Tool> {
|
||||
"tenants.list",
|
||||
"List only the authenticated identity's tenants.",
|
||||
),
|
||||
tool::<Devices>(
|
||||
tool::<Fleet>(
|
||||
"inventory.list_devices",
|
||||
"Stored inventory with source, completeness and timestamps; no live collection.",
|
||||
"List current, previously connected devices. Omit tenant_id for all authorized customers. Use view=history for retired or never-seen installations.",
|
||||
),
|
||||
tool::<Device>(
|
||||
"inventory.get_device",
|
||||
@@ -195,29 +207,32 @@ impl Adapter {
|
||||
.0)
|
||||
}
|
||||
"inventory.list_devices" => {
|
||||
let i: Devices = parse(args)?;
|
||||
Ok(crate::api::devices_page(
|
||||
State(self.state.clone()),
|
||||
h,
|
||||
Path(i.tenant_id),
|
||||
axum::extract::Query(crate::pagination::PageQuery {
|
||||
let i: Fleet = parse(args)?;
|
||||
crate::devices::list(
|
||||
&self.state,
|
||||
&h,
|
||||
i.tenant_id,
|
||||
crate::devices::Filters {
|
||||
cursor: i.cursor,
|
||||
limit: i.limit,
|
||||
}),
|
||||
view: i.view,
|
||||
status: i.status,
|
||||
q: i.q,
|
||||
},
|
||||
)
|
||||
.await
|
||||
.map_err(map_http)?
|
||||
.0)
|
||||
}
|
||||
"inventory.get_device" => {
|
||||
let i: Device = parse(args)?;
|
||||
Ok(crate::api::device(
|
||||
Ok(crate::devices::detail(
|
||||
State(self.state.clone()),
|
||||
h,
|
||||
Path((i.tenant_id, i.asset_id)),
|
||||
axum::extract::Query(crate::devices::DetailQuery {
|
||||
agent_id: i.agent_id,
|
||||
}),
|
||||
)
|
||||
.await
|
||||
.map_err(map_http)?
|
||||
.await?
|
||||
.0)
|
||||
}
|
||||
"monitoring.get_health" => {
|
||||
|
||||
+115
-22
@@ -31,8 +31,7 @@ const SCOPES: [&str; 11] = [
|
||||
"catalog:write",
|
||||
];
|
||||
const READ_SCOPES: [&str; 3] = ["inventory:read", "logs:read", "operations:read"];
|
||||
const COLUMNS: &str =
|
||||
"token_id,principal,name,scopes,created_at,expires_at,last_used_at,revoked_at";
|
||||
const COLUMNS: &str = "token_id,principal,name,scopes,created_at,expires_at,last_used_at,revoked_at,all_customers,coalesce(customer_ids,ARRAY[tenant_id]) AS customer_ids";
|
||||
|
||||
fn invalid() -> Error {
|
||||
Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR")
|
||||
@@ -70,6 +69,8 @@ fn metadata(row: &PgRow) -> Value {
|
||||
"token_id":row.get::<Uuid,_>("token_id"),
|
||||
"principal":row.get::<String,_>("principal"),
|
||||
"name":row.get::<String,_>("name"),
|
||||
"audience":if row.get::<bool,_>("all_customers") {"all"} else {"selected"},
|
||||
"tenant_ids":row.get::<Vec<Uuid>,_>("customer_ids"),
|
||||
"scopes":row.get::<Vec<String>,_>("scopes"),
|
||||
"created_at":row.get::<DateTime<Utc>,_>("created_at"),
|
||||
"expires_at":row.get::<DateTime<Utc>,_>("expires_at"),
|
||||
@@ -119,20 +120,31 @@ async fn list(
|
||||
headers: HeaderMap,
|
||||
Path(tenant): Path<Uuid>,
|
||||
) -> Result<Response, Error> {
|
||||
let (_, allowed, mut tx) = administration(&state, &headers, tenant, false).await?;
|
||||
let (principal, allowed, mut tx) = administration(&state, &headers, tenant, false).await?;
|
||||
let rows = sqlx::query(&format!(
|
||||
"SELECT {COLUMNS} FROM mcp_tokens ORDER BY created_at DESC,token_id"
|
||||
))
|
||||
.fetch_all(&mut *tx)
|
||||
.await?;
|
||||
let can_select_all = crate::customers::can_manage(&principal, &mut tx).await?;
|
||||
tx.commit().await?;
|
||||
let mut available = Vec::new();
|
||||
for customer in &principal.tenants {
|
||||
let mut customer_tx = rmm_persistence::tenant_tx(&state.pool, *customer).await?;
|
||||
let name:Option<String>=sqlx::query_scalar("SELECT name FROM tenants WHERE tenant_id=$1 AND EXISTS(SELECT 1 FROM memberships WHERE principal=$2 AND kind='human' AND revoked_at IS NULL AND 'tokens:manage'=ANY(permissions))")
|
||||
.bind(customer).bind(&principal.name).fetch_optional(&mut *customer_tx).await?;
|
||||
if let Some(name) = name {
|
||||
available.push(json!({"tenant_id":customer,"name":name}));
|
||||
}
|
||||
customer_tx.commit().await?;
|
||||
}
|
||||
let defaults: Vec<_> = READ_SCOPES
|
||||
.into_iter()
|
||||
.filter(|scope| allowed.iter().any(|permission| permission == scope))
|
||||
.collect();
|
||||
Ok(private_json(
|
||||
json!({"tokens":rows.iter().map(metadata).collect::<Vec<_>>(),
|
||||
"allowed_scopes":allowed,"default_scopes":defaults}),
|
||||
"allowed_scopes":allowed,"default_scopes":defaults,"can_select_all":can_select_all,"available_customers":available}),
|
||||
))
|
||||
}
|
||||
|
||||
@@ -140,6 +152,8 @@ async fn list(
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct Create {
|
||||
name: String,
|
||||
audience: Option<String>,
|
||||
tenant_ids: Option<Vec<Uuid>>,
|
||||
scopes: Option<Vec<String>>,
|
||||
expires_at: Option<DateTime<Utc>>,
|
||||
}
|
||||
@@ -200,15 +214,41 @@ async fn create(
|
||||
let (scopes, expiry) = selection(&input, &allowed, Utc::now())?;
|
||||
let token = generate()?;
|
||||
let id = Uuid::new_v4();
|
||||
sqlx::query("SELECT issue_mcp_token($1,$2,$3,$4,$5,$6)")
|
||||
let global = match input.audience.as_deref() {
|
||||
None | Some("selected") => false,
|
||||
Some("all") => true,
|
||||
_ => return Err(invalid()),
|
||||
};
|
||||
let customers = input
|
||||
.tenant_ids
|
||||
.unwrap_or_else(|| if global { vec![] } else { vec![tenant] });
|
||||
if global {
|
||||
if !customers.is_empty() {
|
||||
return Err(invalid());
|
||||
}
|
||||
if !crate::customers::can_manage(&principal, &mut tx).await? {
|
||||
return Err(denied());
|
||||
}
|
||||
} else if customers.is_empty()
|
||||
|| customers.len() > 512
|
||||
|| customers.iter().collect::<BTreeSet<_>>().len() != customers.len()
|
||||
{
|
||||
return Err(invalid());
|
||||
} else if customers.iter().any(|t| !principal.tenants.contains(t)) {
|
||||
return Err(denied());
|
||||
}
|
||||
sqlx::query("SELECT issue_customer_token($1,$2,$3,$4,$5,$6,$7,$8)")
|
||||
.bind(&principal.name)
|
||||
.bind(id)
|
||||
.bind(&input.name)
|
||||
.bind(hash(token.as_bytes()))
|
||||
.bind(scopes)
|
||||
.bind(expiry)
|
||||
.bind(global)
|
||||
.bind(&customers)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
.await
|
||||
.map_err(crate::customers::database_error)?;
|
||||
let row = sqlx::query(&format!(
|
||||
"SELECT {COLUMNS} FROM mcp_tokens WHERE token_id=$1"
|
||||
))
|
||||
@@ -251,7 +291,20 @@ pub async fn authenticate(
|
||||
raw: &str,
|
||||
selected: Option<Uuid>,
|
||||
) -> Result<Principal, StatusCode> {
|
||||
authenticate_pool(&state.pool, raw, selected).await
|
||||
let principal = authenticate_pool(&state.pool, raw, selected).await?;
|
||||
let mut tx = rmm_persistence::tenant_tx(&state.pool, principal.tenant)
|
||||
.await
|
||||
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
||||
if !issuer_enabled(state, &mut tx, &principal.name)
|
||||
.await
|
||||
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?
|
||||
{
|
||||
return Err(StatusCode::UNAUTHORIZED);
|
||||
}
|
||||
tx.commit()
|
||||
.await
|
||||
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
||||
Ok(principal)
|
||||
}
|
||||
|
||||
async fn authenticate_pool(
|
||||
@@ -270,36 +323,49 @@ async fn authenticate_pool(
|
||||
.fetch_optional(pool)
|
||||
.await
|
||||
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
||||
let (tenant, id) = route.ok_or(StatusCode::UNAUTHORIZED)?;
|
||||
if selected.is_some_and(|value| value != tenant) {
|
||||
let (home, id) = route.ok_or(StatusCode::UNAUTHORIZED)?;
|
||||
let tenants: Vec<Uuid> = sqlx::query_scalar("SELECT mcp_credential_customers($1)")
|
||||
.bind(&digest)
|
||||
.fetch_one(pool)
|
||||
.await
|
||||
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
||||
let default = tenants.first().copied().ok_or(StatusCode::UNAUTHORIZED)?;
|
||||
let tenant = selected.unwrap_or(default);
|
||||
if !tenants.contains(&tenant) {
|
||||
return Err(StatusCode::NOT_FOUND);
|
||||
}
|
||||
let principal = format!("mcp:{id}");
|
||||
let mut tx = rmm_persistence::tenant_tx(pool, tenant)
|
||||
.await
|
||||
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
||||
let row = sqlx::query("SELECT t.principal,t.scopes,m.permissions FROM mcp_tokens t JOIN memberships m USING(tenant_id,principal) WHERE t.token_id=$1 AND t.token_hash=$2 AND t.revoked_at IS NULL AND t.expires_at>now() AND m.kind='automation' AND m.revoked_at IS NULL")
|
||||
.bind(id).bind(digest).fetch_optional(&mut *tx).await
|
||||
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?.ok_or(StatusCode::UNAUTHORIZED)?;
|
||||
let allowed: Vec<String> = row.get("permissions");
|
||||
let effective: BTreeSet<String> = row
|
||||
.get::<Vec<String>, _>("scopes")
|
||||
let permissions: Vec<String> = sqlx::query_scalar("SELECT mcp_current_scopes($1)")
|
||||
.bind(&principal)
|
||||
.fetch_one(&mut *tx)
|
||||
.await
|
||||
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
||||
let effective: BTreeSet<String> = permissions
|
||||
.into_iter()
|
||||
.filter(|permission| allowed.contains(permission) && SCOPES.contains(&permission.as_str()))
|
||||
.filter(|p| SCOPES.contains(&p.as_str()))
|
||||
.collect();
|
||||
if effective.is_empty() {
|
||||
return Err(StatusCode::FORBIDDEN);
|
||||
}
|
||||
sqlx::query("UPDATE mcp_tokens SET last_used_at=now() WHERE token_id=$1")
|
||||
.bind(id)
|
||||
sqlx::query("SELECT set_config('app.tenant_id',$1,true)")
|
||||
.bind(home.to_string())
|
||||
.execute(&mut *tx)
|
||||
.await
|
||||
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
||||
let used=sqlx::query("UPDATE mcp_tokens SET last_used_at=now() WHERE token_id=$1 AND token_hash=$2 AND revoked_at IS NULL AND expires_at>now()")
|
||||
.bind(id).bind(&digest).execute(&mut *tx).await.map_err(|_|StatusCode::SERVICE_UNAVAILABLE)?;
|
||||
if used.rows_affected() != 1 {
|
||||
return Err(StatusCode::UNAUTHORIZED);
|
||||
}
|
||||
tx.commit()
|
||||
.await
|
||||
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
||||
Ok(Principal {
|
||||
tenant,
|
||||
name: row.get("principal"),
|
||||
name: principal,
|
||||
operator: effective
|
||||
.iter()
|
||||
.any(|scope| !READ_SCOPES.contains(&scope.as_str())),
|
||||
@@ -308,16 +374,41 @@ async fn authenticate_pool(
|
||||
scopes: Some(effective),
|
||||
testsimulation: false,
|
||||
identity: None,
|
||||
tenants: vec![tenant],
|
||||
tenants,
|
||||
})
|
||||
}
|
||||
|
||||
pub async fn issuer_enabled(
|
||||
state: &crate::State,
|
||||
tx: &mut Transaction<'_, Postgres>,
|
||||
principal: &str,
|
||||
) -> Result<bool, sqlx::Error> {
|
||||
let issuer: Option<String> = sqlx::query_scalar("SELECT mcp_current_issuer($1)")
|
||||
.bind(principal)
|
||||
.fetch_one(&mut **tx)
|
||||
.await?;
|
||||
Ok(issuer.is_some_and(|actor| {
|
||||
if actor.starts_with("local:") {
|
||||
state
|
||||
.auth
|
||||
.local
|
||||
.as_ref()
|
||||
.and_then(|local| local.home(&actor))
|
||||
.is_some()
|
||||
} else {
|
||||
actor.starts_with("oidc:") && state.auth.oidc.is_some()
|
||||
}
|
||||
}))
|
||||
}
|
||||
|
||||
pub async fn enabled_in(
|
||||
tx: &mut Transaction<'_, Postgres>,
|
||||
principal: &str,
|
||||
) -> Result<bool, sqlx::Error> {
|
||||
sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM mcp_tokens t JOIN memberships m USING(tenant_id,principal) WHERE t.principal=$1 AND t.revoked_at IS NULL AND t.expires_at>now() AND m.kind='automation' AND m.revoked_at IS NULL AND t.scopes && m.permissions)")
|
||||
.bind(principal).fetch_one(&mut **tx).await
|
||||
sqlx::query_scalar("SELECT cardinality(mcp_current_scopes($1))>0")
|
||||
.bind(principal)
|
||||
.fetch_one(&mut **tx)
|
||||
.await
|
||||
}
|
||||
|
||||
pub async fn enabled(pool: &PgPool, principal: &str, tenant: Uuid) -> bool {
|
||||
@@ -338,6 +429,8 @@ mod tests {
|
||||
let allowed: Vec<String> = SCOPES.into_iter().map(str::to_owned).collect();
|
||||
let mut input = Create {
|
||||
name: "Inventory reader".into(),
|
||||
audience: None,
|
||||
tenant_ids: None,
|
||||
scopes: None,
|
||||
expires_at: None,
|
||||
};
|
||||
|
||||
@@ -13,7 +13,14 @@ pub async fn health(
|
||||
h: HeaderMap,
|
||||
Path(t): Path<Uuid>,
|
||||
) -> Result<Json<Value>, StatusCode> {
|
||||
let Json(devices) = crate::api::devices(State(s), h, Path(t)).await?;
|
||||
let Json(devices) = crate::devices::page(
|
||||
State(s),
|
||||
h,
|
||||
Path(t),
|
||||
axum::extract::Query(Default::default()),
|
||||
)
|
||||
.await
|
||||
.map_err(|e| e.0)?;
|
||||
Ok(Json(
|
||||
json!({"items":devices["items"],"next_cursor":null,"completeness":devices["completeness"],"truncated":devices["truncated"],"as_of":Utc::now(),"health":"unknown","source_id":"stored_agent_observations"}),
|
||||
))
|
||||
|
||||
@@ -17,6 +17,8 @@ pub struct Cursor {
|
||||
scope: String,
|
||||
pub as_of: DateTime<Utc>,
|
||||
pub last: Uuid,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub last_tenant: Option<Uuid>,
|
||||
pub limit: u16,
|
||||
}
|
||||
impl Cursor {
|
||||
@@ -71,6 +73,7 @@ impl Cursor {
|
||||
scope: scope.into(),
|
||||
as_of: Utc::now(),
|
||||
last: Uuid::nil(),
|
||||
last_tenant: None,
|
||||
limit: q.limit.unwrap_or(100),
|
||||
})
|
||||
}
|
||||
|
||||
@@ -3,11 +3,10 @@ use anyhow::Result;
|
||||
use sqlx::{Postgres, Transaction};
|
||||
use uuid::Uuid;
|
||||
pub async fn maintain(tx: &mut Transaction<'_, Postgres>, agent: Option<Uuid>) -> Result<()> {
|
||||
sqlx::query("UPDATE approval_requests r SET approval_state='expired' FROM operation_plans p WHERE p.tenant_id=r.tenant_id AND p.plan_id=r.plan_id AND r.approval_state='pending_approval' AND p.expires_at<=now()").execute(&mut **tx).await?;
|
||||
sqlx::query("UPDATE jobs j SET state='expired',pending_reason=NULL FROM operations o,approval_requests r,operation_plans p WHERE j.tenant_id=o.tenant_id AND j.operation_id=o.operation_id AND r.tenant_id=o.tenant_id AND r.operation_id=o.operation_id AND p.tenant_id=r.tenant_id AND p.plan_id=r.plan_id AND ($1::uuid IS NULL OR j.agent_id=$1) AND j.state IN ('queued','accepted') AND NOT j.start_reserved AND p.expires_at<=now()").bind(agent).execute(&mut **tx).await?;
|
||||
sqlx::query("UPDATE jobs j SET state='unknown',pending_reason='reconciliation_required',result=COALESCE(j.result,'{}'::jsonb)||jsonb_build_object('error_code','START_OR_RESULT_UNCONFIRMED','source_id','server_grant_ledger') FROM execution_permits e WHERE e.tenant_id=j.tenant_id AND e.job_id=j.job_id AND ($1::uuid IS NULL OR j.agent_id=$1) AND j.start_reserved AND ((j.state='accepted' AND (convert_from(e.payload,'UTF8')::jsonb->>'start_before')::timestamptz<now()) OR (j.state IN ('running','verifying') AND (convert_from(e.payload,'UTF8')::jsonb->>'start_before')::timestamptz+make_interval(secs=>(convert_from(e.payload,'UTF8')::jsonb->>'max_runtime_seconds')::integer)<now()))").bind(agent).execute(&mut **tx).await?;
|
||||
sqlx::query("UPDATE jobs j SET pending_reason=CASE WHEN t.changes_stopped THEN 'tenant_stopped' WHEN r.approval_state<>'approved' THEN 'authorization_revoked' WHEN (convert_from(j.payload,'UTF8')::jsonb->>'not_before')::timestamptz>now() THEN 'maintenance_window' WHEN i.last_contact_at IS NULL OR i.last_contact_at<now()-interval '180 seconds' THEN 'device_offline' ELSE NULL END FROM tenants t,approval_requests r,agent_installations i WHERE j.tenant_id=t.tenant_id AND r.tenant_id=j.tenant_id AND r.operation_id=j.operation_id AND i.tenant_id=j.tenant_id AND i.agent_id=j.agent_id AND j.state IN ('queued','accepted') AND NOT j.start_reserved AND ($1::uuid IS NULL OR j.agent_id=$1)").bind(agent).execute(&mut **tx).await?;
|
||||
sqlx::query("UPDATE jobs j SET state='unknown',pending_reason='reconciliation_required',result=COALESCE(j.result,'{}'::jsonb)||jsonb_build_object('error_code','REBOOT_REJOIN_UNCONFIRMED','source_id','server_grant_ledger') FROM execution_permits e WHERE e.tenant_id=j.tenant_id AND e.job_id=j.job_id AND ($1::uuid IS NULL OR j.agent_id=$1) AND j.state='awaiting_reboot' AND (convert_from(e.payload,'UTF8')::jsonb->>'start_before')::timestamptz+make_interval(secs=>COALESCE((convert_from(j.payload,'UTF8')::jsonb->'action'->>'reconnect_timeout_seconds')::integer,3600))<now()").bind(agent).execute(&mut **tx).await?;
|
||||
sqlx::query("SELECT maintain_current_customer($1)")
|
||||
.bind(agent)
|
||||
.execute(&mut **tx)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
pub fn start(state: crate::State) {
|
||||
@@ -15,26 +14,8 @@ pub fn start(state: crate::State) {
|
||||
let mut timer = tokio::time::interval(std::time::Duration::from_secs(1));
|
||||
loop {
|
||||
timer.tick().await;
|
||||
for tenant in [rmm_domain::TENANT_A, rmm_domain::TENANT_B] {
|
||||
let result = async {
|
||||
let tenant = Uuid::parse_str(tenant)?;
|
||||
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant).await?;
|
||||
let acquired: bool = sqlx::query_scalar(
|
||||
"SELECT pg_try_advisory_xact_lock(hashtextextended($1,0))",
|
||||
)
|
||||
.bind(format!("maintenance:{tenant}"))
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
if acquired {
|
||||
maintain(&mut tx, None).await?;
|
||||
}
|
||||
tx.commit().await?;
|
||||
Ok::<(), anyhow::Error>(())
|
||||
}
|
||||
.await;
|
||||
if result.is_err() {
|
||||
eprintln!("tenant housekeeping failed; no starts authorized by scheduler");
|
||||
}
|
||||
if sqlx::query("SELECT maintain_customers()").execute(&state.pool).await.is_err() {
|
||||
eprintln!("customer housekeeping failed");
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
@@ -54,6 +54,10 @@ impl UpdateArtifacts {
|
||||
profile == "development",
|
||||
"update object adapter is development-only"
|
||||
);
|
||||
Self::private_directory(root, owner)
|
||||
}
|
||||
|
||||
pub(crate) fn private_directory(root: PathBuf, owner: u32) -> Result<Self> {
|
||||
match fs::create_dir(&root) {
|
||||
Ok(()) => fs::set_permissions(&root, fs::Permissions::from_mode(0o700))?,
|
||||
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {}
|
||||
|
||||
Reference in New Issue
Block a user