use anyhow::Result; #[cfg(test)] use prost::Message; #[cfg(test)] use rmm_domain::jobs::hash; use rmm_domain::jobs::{Action, JobPayload}; use rmm_privileged_helper::Binding; use rmm_protocol::*; use rusqlite::Connection; #[cfg(test)] use uuid::Uuid; pub fn supported_with_binding(job: &JobPayload, binding: Option<&Binding>) -> bool { let Action::RunScript { interpreter, .. } = &job.action else { return false; }; if unsafe { libc::geteuid() } == 0 || !job.action.valid_execution_identity(&job.execution_identity) { return false; } match job.execution_identity.as_str() { "root" => { job.action.full_maintenance() && binding.is_some_and(|b| crate::helper_sync::script_supported(b, job)) } "agent_service" => match interpreter.as_str() { "posix_sh" => rmm_agent_linux::actions::Interpreter::PosixSh.available(), "bash" => rmm_agent_linux::actions::Interpreter::Bash.available(), _ => false, }, _ => false, } } pub use rmm_agent_core::jobs::{ ack, denied_request, event, events, interrupted, interrupted_request, next, no_start, permit_request, recover_interrupted_outcome, requesting, reserve_request, result, transition, }; pub fn accept(db: &Connection, binding: &Binding, offer: &JobOffer) -> Result { rmm_agent_core::jobs::accept(db, binding, offer, |job| { supported_with_binding(job, Some(binding)) }) } /// all new effects stop. Do not paper over this with a new start request. #[cfg(test)] pub fn begin_session(db: &Connection) -> Result { let inserted = db.execute( "INSERT OR IGNORE INTO safety(key,value) VALUES('connected','1')", [], )?; Ok(inserted == 1) } #[cfg(test)] pub fn uncertain(db: &Connection) -> Result> { let mut statement = db.prepare( "SELECT offer,grant_id FROM job_attempts WHERE state IN ('requesting','running')", )?; let bytes = statement .query_map([], |r| { Ok((r.get::<_, Vec>(0)?, r.get::<_, String>(1)?)) })? .collect::>>()?; bytes .into_iter() .map(|(bytes, grant)| Ok((JobOffer::decode(bytes.as_slice())?, grant))) .collect() } #[cfg(test)] mod tests { use super::*; use crate::storage; fn fixture() -> (std::path::PathBuf, Binding, JobOffer) { let path = std::env::temp_dir().join(format!("rmm-agent-jobs-{}", Uuid::new_v4())); storage::prepare_dir(&path).unwrap(); let binding = Binding { tenant_id: Uuid::new_v4(), asset_id: Uuid::new_v4(), agent_id: Uuid::new_v4(), enrollment_generation: 1, assignment_version: 2, public_key_hex: "00".repeat(32), }; let now = chrono::Utc::now(); let job = JobPayload { schema_version: 1, tenant_id: binding.tenant_id, asset_id: binding.asset_id, agent_id: binding.agent_id, enrollment_generation: 1, assignment_version: 2, job_id: Uuid::new_v4(), attempt_id: Uuid::new_v4(), action: Action::RunScript { interpreter: "posix_sh".into(), script_utf8: "true".into(), arguments: vec![], expected_stdout: None, windows_execution_profile: None, privileged_script_profile: None, }, execution_identity: "agent_service".into(), not_before: now, start_before: now + chrono::Duration::minutes(10), max_runtime_seconds: 10, max_output_bytes: 4096, }; let bytes = rmm_domain::jobs::encode(&job).unwrap(); let offer = JobOffer { job_id: job.job_id.to_string(), attempt_id: job.attempt_id.to_string(), authorization_id: Uuid::new_v4().to_string(), plan_hash: hash(b"plan"), job_payload_hash: hash(&bytes), payload_bytes: bytes, }; (path, binding, offer) } #[test] fn sqlite_reopen_offer_dedup_and_no_new_permit_after_ambiguity() { let (path, binding, offer) = fixture(); let mut db = storage::open(&path).unwrap(); let job = binding.job(&offer.payload_bytes).unwrap(); if unsafe { libc::geteuid() } == 0 { assert!(!supported_with_binding(&job, Some(&binding))); assert!(accept(&db, &binding, &offer).is_err()); } else { assert!(accept(&db, &binding, &offer).unwrap()); assert!(!accept(&db, &binding, &offer).unwrap()); let mut changed = offer.clone(); changed.plan_hash = hash(b"different plan"); assert!(accept(&db, &binding, &changed).is_err()); assert!(begin_session(&db).unwrap()); let envelope = Envelope { message_id: Uuid::new_v4().to_string(), sequence: storage::next_sequence(&mut db).unwrap(), payload: Some(Payload::JobAccepted(JobAccepted { job_id: offer.job_id.clone(), attempt_id: offer.attempt_id.clone(), job_payload_hash: offer.job_payload_hash.clone(), journal_proof: "durable".into(), })), ..Default::default() }; event(&db, &envelope).unwrap(); reserve_request(&db, &offer).unwrap(); assert!(reserve_request(&db, &offer).is_err()); assert!(next(&db).unwrap().is_none()); drop(db); db = storage::open(&path).unwrap(); assert!(!begin_session(&db).unwrap()); assert_eq!(uncertain(&db).unwrap().len(), 1); assert_eq!(events(&db).unwrap(), vec![envelope.clone()]); assert_eq!(transition(&db, &offer, "unknown", "").unwrap(), 1); assert!(next(&db).unwrap().is_none()); assert!(!accept(&db, &binding, &offer).unwrap()); ack(&mut db, &envelope.message_id).unwrap(); assert!(events(&db).unwrap().is_empty()); assert!(next(&db).unwrap().is_none()); } drop(db); std::fs::remove_dir_all(path).unwrap(); } #[test] fn cancellation_expiry_and_atomic_event_rollback() { let (path, binding, offer) = fixture(); let mut db = storage::open(&path).unwrap(); if unsafe { libc::geteuid() } != 0 { accept(&db, &binding, &offer).unwrap(); db.execute("UPDATE job_attempts SET cancel_requested=1", []) .unwrap(); assert!(reserve_request(&db, &offer).is_err()); let cancelled = no_start("cancelled", "CANCELLED"); assert_eq!(cancelled.evidence["not_started"], true); let tx = db.transaction().unwrap(); assert_eq!(transition(&tx, &offer, "cancelled", "").unwrap(), 1); let e = Envelope { message_id: Uuid::new_v4().to_string(), payload: Some(Payload::JobResult(result(&offer, 1, "", cancelled))), ..Default::default() }; event(&tx, &e).unwrap(); tx.rollback().unwrap(); assert!(events(&db).unwrap().is_empty()); assert!(next(&db).unwrap().is_none()); let expired = no_start("expired", "DEADLINE_EXPIRED"); assert_eq!(expired.evidence["not_started"], true); assert_eq!(transition(&db, &offer, "expired", "").unwrap(), 1); assert!(next(&db).unwrap().is_none()); } else { assert!(accept(&db, &binding, &offer).is_err()); } drop(db); std::fs::remove_dir_all(path).unwrap(); } #[test] fn legacy_actions_and_unbound_root_are_rejected_before_any_reservation() { let (path, binding, offer) = fixture(); let mut job = binding.job(&offer.payload_bytes).unwrap(); job.execution_identity = "root".into(); assert!(!supported_with_binding(&job, Some(&binding))); for identity in ["agent_service", "root"] { job.execution_identity = identity.into(); job.action = Action::Reboot { reason: "legacy fixture".into(), reconnect_timeout_seconds: 60, dependency_group: "test".into(), }; assert!(!supported_with_binding(&job, Some(&binding))); job.action = Action::RefreshInventory { scope: "linux.base".into(), }; assert!(!supported_with_binding(&job, Some(&binding))); } std::fs::remove_dir_all(path).unwrap(); } #[test] fn scheduled_future_job_does_not_starve_ready_job() { let (path, binding, offer) = fixture(); let db = storage::open(&path).unwrap(); if unsafe { libc::geteuid() } != 0 { let mut future = offer.clone(); let mut job: JobPayload = serde_json::from_slice(&future.payload_bytes).unwrap(); job.job_id = Uuid::new_v4(); job.attempt_id = Uuid::new_v4(); job.not_before = chrono::Utc::now() + chrono::Duration::minutes(1); future.job_id = job.job_id.to_string(); future.attempt_id = job.attempt_id.to_string(); future.payload_bytes = rmm_domain::jobs::encode(&job).unwrap(); future.job_payload_hash = hash(&future.payload_bytes); accept(&db, &binding, &future).unwrap(); accept(&db, &binding, &offer).unwrap(); assert_eq!(next(&db).unwrap().unwrap().job_id, offer.job_id); } drop(db); std::fs::remove_dir_all(path).unwrap(); } }