//! Tenant-owned script revisions. Selection materializes an ordinary immutable //! script plan; submitting and approving it use the existing job lifecycle. use crate::{ auth::Principal, jobs::{self, Error, PlanInput, Rollout, Schedule, Targets}, pagination::{Cursor, PageQuery}, }; use axum::{ Json, Router, extract::{Path, Query, State}, http::{HeaderMap, StatusCode}, routing::{get, post}, }; use rmm_domain::jobs::{ Action, PrivilegedScriptProfile, ScriptRevisionReference, WindowsExecutionProfile, hash, }; use serde::Deserialize; use serde_json::{Value, json}; use sqlx::Row; use uuid::Uuid; #[derive(Clone, Deserialize, schemars::JsonSchema)] #[serde(deny_unknown_fields)] pub struct Publish { pub name: String, pub expected_version: i32, pub interpreter: String, pub execution_identity: String, pub script_utf8: String, } #[derive(Deserialize, schemars::JsonSchema)] #[serde(deny_unknown_fields)] pub struct Selection { pub targets: Targets, pub schedule: Schedule, pub rollout: Rollout, pub reason: String, pub max_runtime_seconds: u32, pub max_output_bytes: u32, } fn script(interpreter: &str, identity: &str, body: String) -> Result { let action = Action::RunScript { interpreter: interpreter.to_owned(), script_utf8: body, arguments: vec![], expected_stdout: None, windows_execution_profile: (interpreter == "powershell") .then_some(WindowsExecutionProfile::PowerShell51RemoteSigned), privileged_script_profile: (identity != "agent_service") .then_some(PrivilegedScriptProfile::FullMaintenanceV1), }; if !action.validate() || !action.valid_execution_identity(identity) || !matches!(identity, "agent_service" | "root" | "system") { return Err(Error(StatusCode::BAD_REQUEST, "INVALID_SCRIPT_REVISION")); } Ok(action) } fn view(r: &sqlx::postgres::PgRow) -> Value { let body: String = r.get("script_utf8"); json!({"revision_id":r.get::("revision_id"),"name":r.get::("name"), "version":r.get::("version"),"interpreter":r.get::("interpreter"), "execution_identity":r.get::("execution_identity"),"script_sha256":hash(body.as_bytes()), "script_utf8":body,"created_at":r.get::,_>("created_at"), "created_by":r.get::("created_by")}) } pub async fn list( s: &crate::State, p: &Principal, tenant: Uuid, q: PageQuery, ) -> Result { jobs::scope(p, tenant, false)?; let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?; crate::permissions::require_principal(&mut tx, p, "operations:read").await?; let mut page = Cursor::parse(s, p, "script-library:revision-id", q) .map_err(|s| Error(s, "VALIDATION_ERROR"))?; let rows=sqlx::query("SELECT * FROM script_revisions WHERE revision_id>$1 AND created_at<=$2 ORDER BY revision_id LIMIT $3") .bind(page.last).bind(page.as_of).bind(i64::from(page.limit)+1).fetch_all(&mut *tx).await?; let shown = rows .iter() .take(usize::from(page.limit)) .map(view) .collect::>(); let truncated = rows.len() > shown.len(); let next = if truncated { Some( page.next(s, rows[shown.len() - 1].get("revision_id")) .map_err(|s| Error(s, "CURSOR_ERROR"))?, ) } else { None }; tx.commit().await?; Ok( json!({"items":shown,"as_of":page.as_of,"next_cursor":next,"truncated":truncated,"completeness":if truncated {"partial"} else {"complete"}}), ) } pub async fn publish( s: &crate::State, p: &Principal, tenant: Uuid, input: Publish, ) -> Result { jobs::scope(p, tenant, true)?; if input.name.trim() != input.name || input.name.is_empty() || input.name.chars().count() > 120 || input.name.chars().any(char::is_control) || !(0..i32::MAX).contains(&input.expected_version) { return Err(Error(StatusCode::BAD_REQUEST, "INVALID_SCRIPT_REVISION")); } script( &input.interpreter, &input.execution_identity, input.script_utf8.clone(), )?; let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?; crate::permissions::require_principal(&mut tx, p, "operations:plan").await?; crate::permissions::require_principal(&mut tx, p, "scripts:execute").await?; // Same predecessor implies the same next version. The unique constraint // serializes concurrent publishers without a mutable "latest" row. let version = input.expected_version + 1; let inserted=sqlx::query("INSERT INTO script_revisions(tenant_id,name,version,interpreter,execution_identity,script_utf8,created_by) SELECT $1,$2,$3,$4,$5,$6,$7 WHERE COALESCE((SELECT max(version) FROM script_revisions WHERE name=$2),0)=$8 ON CONFLICT (tenant_id,name,version) DO NOTHING RETURNING *") .bind(tenant).bind(&input.name).bind(version).bind(&input.interpreter) .bind(&input.execution_identity).bind(&input.script_utf8).bind(&p.name) .bind(input.expected_version).fetch_optional(&mut *tx).await?; let row=match inserted{ Some(r)=>r, None=>sqlx::query("SELECT * FROM script_revisions WHERE name=$1 AND version=$2 AND interpreter=$3 AND execution_identity=$4 AND script_utf8=$5 AND created_by=$6") .bind(input.name).bind(version).bind(input.interpreter).bind(input.execution_identity) .bind(input.script_utf8).bind(&p.name).fetch_optional(&mut *tx).await? .ok_or(Error(StatusCode::CONFLICT,"SCRIPT_REVISION_CONFLICT"))? }; tx.commit().await?; Ok(view(&row)) } pub async fn plan( s: &crate::State, p: &Principal, tenant: Uuid, id: Uuid, input: Selection, ) -> Result { jobs::scope(p, tenant, true)?; let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?; crate::permissions::require_principal(&mut tx, p, "operations:plan").await?; crate::permissions::require_principal(&mut tx, p, "scripts:execute").await?; let row = sqlx::query("SELECT * FROM script_revisions WHERE revision_id=$1") .bind(id) .fetch_optional(&mut *tx) .await? .ok_or(Error(StatusCode::NOT_FOUND, "NOT_FOUND"))?; tx.commit().await?; let body: String = row.get("script_utf8"); let reference = ScriptRevisionReference { revision_id: id, name: row.get("name"), version: row.get("version"), script_sha256: hash(body.as_bytes()), }; let identity: String = row.get("execution_identity"); let action = script(row.get("interpreter"), &identity, body)?; let plan = PlanInput { targets: input.targets, action, script_variants: vec![], execution_identity: identity, schedule: input.schedule, max_runtime_seconds: input.max_runtime_seconds, max_output_bytes: input.max_output_bytes, rollout: input.rollout, reason: input.reason, artifact_ids: vec![], }; jobs::plan_resolved(s, p, tenant, plan, None, Some(reference)).await } pub(crate) fn validate_plan_bindings(plan: &rmm_domain::jobs::PlanPayload) -> Result<(), Error> { let Some(reference) = &plan.script_revision else { if plan.jobs.iter().any(|job| { job.payload.max_runtime_seconds > 120 && job.payload.action.is_windows_update_template() }) { return Err(Error( StatusCode::CONFLICT, "WINDOWS_UPDATE_REVISION_REQUIRED", )); } return Ok(()); }; if reference.revision_id.is_nil() || reference.version < 1 || reference.name.is_empty() || plan.jobs.is_empty() || plan.jobs.iter().any(|job| !matches!(&job.payload.action, Action::RunScript { script_utf8, .. } if hash(script_utf8.as_bytes()) == reference.script_sha256 && job.script_sha256.as_ref() == Some(&reference.script_sha256))) { return Err(Error(StatusCode::CONFLICT, "SCRIPT_REVISION_BINDING_MISMATCH")); } Ok(()) } pub fn routes(r: Router) -> Router { r.route( "/api/v1/tenants/{tenant}/script-revisions", get(list_http).post(publish_http), ) .route( "/api/v1/tenants/{tenant}/script-revisions/{revision}/plan", post(plan_http), ) } async fn list_http( State(s): State, h: HeaderMap, Path(t): Path, Query(q): Query, ) -> Result, Error> { let p = jobs::principal(&s, &h, false).await?; Ok(Json(list(&s, &p, t, q).await?)) } async fn publish_http( State(s): State, h: HeaderMap, Path(t): Path, Json(i): Json, ) -> Result, Error> { let p = jobs::principal(&s, &h, true).await?; Ok(Json(publish(&s, &p, t, i).await?)) } async fn plan_http( State(s): State, h: HeaderMap, Path((t, id)): Path<(Uuid, Uuid)>, Json(i): Json, ) -> Result, Error> { let p = jobs::principal(&s, &h, true).await?; Ok(Json(plan(&s, &p, t, id, i).await?)) } #[cfg(test)] pub(crate) mod tests { use super::*; use chrono::{Duration, Utc}; /// Shared isolated PostgreSQL fixture in tests/windows_plan_database.py. pub(crate) async fn revision_plan_contract( s: &crate::State, p: &Principal, linux: Uuid, windows: Uuid, ) { let tenant = p.tenant; let initial = list(s, p, tenant, PageQuery::default()).await.unwrap(); let template = &initial["items"][0]; assert_eq!(template["name"], "Windows-Updates installieren"); assert_eq!(template["interpreter"], "powershell"); let native = script( "powershell", "system", template["script_utf8"].as_str().unwrap().into(), ) .unwrap(); assert!(native.is_windows_update_template()); assert_eq!( template["script_sha256"], rmm_domain::jobs::WINDOWS_UPDATE_SCRIPT_SHA256 ); assert!(native.valid_job_limits(3600, 65536)); assert!(!native.valid_job_limits(3601, 65536)); let v1 = Publish { name: "Agentversion".into(), expected_version: 0, interpreter: "posix_sh".into(), execution_identity: "agent_service".into(), script_utf8: "printf '1\\n'\n".into(), }; let first = publish(s, p, tenant, v1.clone()).await.unwrap(); let retry = publish(s, p, tenant, v1.clone()).await.unwrap(); assert_eq!(first, retry); let id = Uuid::parse_str(first["revision_id"].as_str().unwrap()).unwrap(); let mut v2 = Publish { script_utf8: "printf '2\\n'\n".into(), ..v1.clone() }; assert_eq!( publish(s, p, tenant, v2.clone()).await.unwrap_err().0, StatusCode::CONFLICT ); v2.expected_version = 1; let second = publish(s, p, tenant, v2).await.unwrap(); assert_ne!(first["revision_id"], second["revision_id"]); assert_eq!(second["version"], 2); assert!( list(s, p, Uuid::new_v4(), PageQuery::default()) .await .is_err() ); let mut foreign = rmm_persistence::tenant_tx(&s.pool, Uuid::new_v4()) .await .unwrap(); let visible: i64 = sqlx::query_scalar("SELECT count(*) FROM script_revisions WHERE revision_id=$1") .bind(id) .fetch_one(&mut *foreign) .await .unwrap(); assert_eq!(visible, 0); foreign.rollback().await.unwrap(); let mut own = rmm_persistence::tenant_tx(&s.pool, tenant).await.unwrap(); assert!( sqlx::query( "UPDATE script_revisions SET script_utf8='replacement' WHERE revision_id=$1" ) .bind(id) .execute(&mut *own) .await .is_err() ); own.rollback().await.unwrap(); let selection = |asset| Selection { targets: Targets { asset_ids: vec![asset], }, schedule: Schedule { not_before: Utc::now(), start_before: Utc::now() + Duration::minutes(30), }, rollout: Rollout { max_parallel: 1, halt_after_failures: 1, }, reason: "isolated library contract".into(), max_runtime_seconds: 60, max_output_bytes: 4096, }; assert_eq!( plan(s, p, tenant, id, selection(windows)) .await .unwrap_err() .1, "UNSUPPORTED_CAPABILITY" ); let planned = plan(s, p, tenant, id, selection(linux)).await.unwrap(); let plan_id = Uuid::parse_str(planned["plan_id"].as_str().unwrap()).unwrap(); let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await.unwrap(); let bytes: Vec = sqlx::query_scalar("SELECT payload FROM operation_plans WHERE plan_id=$1") .bind(plan_id) .fetch_one(&mut *tx) .await .unwrap(); tx.commit().await.unwrap(); let bound: rmm_domain::jobs::PlanPayload = serde_json::from_slice(&bytes).unwrap(); let mut extended = bound.clone(); extended.jobs[0].payload.action = native; extended.jobs[0].payload.max_runtime_seconds = 3600; extended.jobs[0].script_sha256 = Some(rmm_domain::jobs::WINDOWS_UPDATE_SCRIPT_SHA256.into()); assert_eq!( validate_plan_bindings(&extended).unwrap_err().1, "SCRIPT_REVISION_BINDING_MISMATCH" ); extended.script_revision = None; assert_eq!( validate_plan_bindings(&extended).unwrap_err().1, "WINDOWS_UPDATE_REVISION_REQUIRED" ); let reference = bound.script_revision.unwrap(); assert_eq!(reference.revision_id, id); assert_eq!(reference.version, 1); assert_eq!(reference.script_sha256, hash(v1.script_utf8.as_bytes())); assert!( matches!(&bound.jobs[0].payload.action, Action::RunScript { script_utf8, .. } if script_utf8 == &v1.script_utf8) ); let response = jobs::submit( s, p, tenant, plan_id, jobs::Submit { idempotency_key: "fixed-library".into(), }, ) .await .unwrap(); assert_eq!(response["approval_state"], "pending_approval"); assert_eq!(response["job_count"], 0); } }