feat: snapshot Linux-first RMM MVP and pause handover
Rust development slice / linux (push) Failing after 1m10s
Rust development slice / linux (push) Failing after 1m10s
This commit is contained in:
@@ -0,0 +1,208 @@
|
||||
use crate::reconcile;
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use rmm_privileged_helper::{Binding, control, readiness, reconcile as root};
|
||||
use rmm_protocol::{SyncAttempt, SyncRequest, SyncResponse};
|
||||
use std::path::{Path, PathBuf};
|
||||
use uuid::Uuid;
|
||||
#[derive(Clone)]
|
||||
struct Endpoint {
|
||||
socket: PathBuf,
|
||||
profile: String,
|
||||
hash: String,
|
||||
}
|
||||
#[derive(Clone)]
|
||||
pub struct Helpers {
|
||||
binding: Binding,
|
||||
endpoints: Vec<Endpoint>,
|
||||
}
|
||||
fn map(s: &root::Snapshot) -> reconcile::HelperSnapshot {
|
||||
reconcile::HelperSnapshot {
|
||||
journal_id: s.journal_id,
|
||||
checkpoint: s.checkpoint,
|
||||
previous_decision_id: s.previous_decision_id,
|
||||
attempts: s
|
||||
.attempts
|
||||
.iter()
|
||||
.map(|a| SyncAttempt {
|
||||
job_id: a.job_id.to_string(),
|
||||
attempt_id: a.attempt_id.to_string(),
|
||||
job_payload_hash: a.job_payload_hash.clone(),
|
||||
grant_id: a.grant_id.to_string(),
|
||||
consumption: a.consumption.clone(),
|
||||
state: a.state.clone(),
|
||||
revision: a.revision,
|
||||
original_boot_id: a.original_boot_id.to_string(),
|
||||
outcome_sha256: a.outcome_sha256.clone(),
|
||||
outcome_bytes: a.outcome_bytes.clone(),
|
||||
..Default::default()
|
||||
})
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
fn general(binding: &Binding) -> Result<control::Response> {
|
||||
let socket = std::env::var_os("RMM_HELPER_SOCKET").context("NO_GENERAL_HELPER")?;
|
||||
let path = std::env::var_os("RMM_HELPER_POLICY_FILE").context("GENERAL_POLICY_PIN_REQUIRED")?;
|
||||
let pin = control::GeneralPin::read(Path::new(&path), binding)?;
|
||||
control::general_probe(Path::new(&socket), binding, &pin)
|
||||
}
|
||||
impl Helpers {
|
||||
pub fn configured(binding: &Binding) -> Result<Self> {
|
||||
let mut endpoints = vec![];
|
||||
if let Some(socket) = std::env::var_os("RMM_HELPER_SOCKET") {
|
||||
let path = std::env::var_os("RMM_HELPER_POLICY_FILE")
|
||||
.context("GENERAL_POLICY_PIN_REQUIRED")?;
|
||||
let pin = control::GeneralPin::read(Path::new(&path), binding)?;
|
||||
endpoints.push(Endpoint {
|
||||
socket: socket.into(),
|
||||
profile: "general".into(),
|
||||
hash: pin.policy_sha256,
|
||||
});
|
||||
}
|
||||
if let Some(socket) = std::env::var_os("RMM_APT_HELPER_SOCKET") {
|
||||
ensure!(
|
||||
Path::new(&socket) == Path::new(readiness::SOCKET),
|
||||
"APT_HELPER_ROUTE"
|
||||
);
|
||||
let path =
|
||||
std::env::var_os("RMM_APT_HELPER_PROOF_FILE").context("APT_PROOF_REQUIRED")?;
|
||||
let pin = readiness::Pin::read(Path::new(&path), binding)?;
|
||||
endpoints.push(Endpoint {
|
||||
socket: socket.into(),
|
||||
profile: "apt_only".into(),
|
||||
hash: pin.provider_stack_sha256,
|
||||
});
|
||||
}
|
||||
Ok(Self {
|
||||
binding: binding.clone(),
|
||||
endpoints,
|
||||
})
|
||||
}
|
||||
fn validate(&self, e: &Endpoint, r: &control::Response) -> Result<()> {
|
||||
ensure!(
|
||||
r.profile == e.profile && r.policy_sha256 == e.hash,
|
||||
"HELPER_PIN_PROFILE_MISMATCH"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
pub fn snapshot(&self, generation: u64) -> Result<Option<reconcile::HelperSnapshot>> {
|
||||
if self.endpoints.is_empty() {
|
||||
return Ok(None);
|
||||
}
|
||||
for _ in 0..3 {
|
||||
let mut snapshots = vec![];
|
||||
let mut inodes = None;
|
||||
for e in &self.endpoints {
|
||||
let q = control::Request::Snapshot {
|
||||
challenge: Uuid::new_v4(),
|
||||
identity: readiness::Identity::from_binding(&self.binding)?,
|
||||
generation,
|
||||
};
|
||||
let r = control::call(&e.socket, &self.binding, &q)?;
|
||||
self.validate(e, &r)?;
|
||||
let ids = (r.ledger_device, r.ledger_inode, r.lock_device, r.lock_inode);
|
||||
if let Some(old) = inodes {
|
||||
ensure!(old == ids, "HELPERS_MUST_SHARE_LEDGER_AND_LOCK");
|
||||
}
|
||||
inodes = Some(ids);
|
||||
snapshots.push(r.snapshot.context("HELPER_SNAPSHOT_REQUIRED")?);
|
||||
}
|
||||
let first = &snapshots[0];
|
||||
if snapshots.iter().all(|s| {
|
||||
s.journal_id == first.journal_id
|
||||
&& s.checkpoint == first.checkpoint
|
||||
&& s.previous_decision_id == first.previous_decision_id
|
||||
&& serde_json::to_vec(&s.attempts).ok()
|
||||
== serde_json::to_vec(&first.attempts).ok()
|
||||
}) {
|
||||
return Ok(Some(map(first)));
|
||||
}
|
||||
}
|
||||
anyhow::bail!("HELPER_CHECKPOINTS_DID_NOT_CONVERGE")
|
||||
}
|
||||
pub fn apply(
|
||||
&self,
|
||||
response: &SyncResponse,
|
||||
request: &SyncRequest,
|
||||
) -> Result<Option<reconcile::HelperSnapshot>> {
|
||||
use prost::Message;
|
||||
let mut applied: Option<root::Snapshot> = None;
|
||||
for e in &self.endpoints {
|
||||
let q = control::Request::Apply {
|
||||
challenge: Uuid::new_v4(),
|
||||
identity: readiness::Identity::from_binding(&self.binding)?,
|
||||
response: root::SignedResponse {
|
||||
decision_bytes: response.decision_bytes.clone(),
|
||||
signature: response.signature.clone(),
|
||||
},
|
||||
request_bytes: request.encode_to_vec(),
|
||||
};
|
||||
let r = control::call(&e.socket, &self.binding, &q)?;
|
||||
self.validate(e, &r)?;
|
||||
let s = r.snapshot.context("APPLIED_HELPER_SNAPSHOT_REQUIRED")?;
|
||||
if let Some(old) = &applied {
|
||||
ensure!(
|
||||
old.journal_id == s.journal_id
|
||||
&& old.checkpoint == s.checkpoint
|
||||
&& old.previous_decision_id == s.previous_decision_id,
|
||||
"HELPER_APPLY_CHECKPOINT_MISMATCH"
|
||||
);
|
||||
}
|
||||
applied = Some(s);
|
||||
}
|
||||
Ok(applied.as_ref().map(map))
|
||||
}
|
||||
}
|
||||
pub fn general_capabilities(binding: &Binding) -> Vec<String> {
|
||||
(|| -> Result<Vec<String>> {
|
||||
let response = general(binding)?;
|
||||
let policy = response.policy.context("NO_GENERAL_POLICY")?;
|
||||
let mut caps = vec![
|
||||
"helper.root.v1".into(),
|
||||
format!("helper.policy.sha256:{}", response.policy_sha256),
|
||||
];
|
||||
let mut actions = vec![];
|
||||
if policy.allow_root_scripts && rmm_agent_linux::actions::Interpreter::PosixSh.available() {
|
||||
actions.push("run_script");
|
||||
}
|
||||
if !policy.allowed_services.is_empty() {
|
||||
actions.extend(["set_service_state", "query_logs"]);
|
||||
}
|
||||
if policy.allow_reboot {
|
||||
actions.push("reboot");
|
||||
}
|
||||
for action in actions {
|
||||
caps.push(action.into());
|
||||
caps.push(format!("root:{action}"));
|
||||
}
|
||||
Ok(caps)
|
||||
})()
|
||||
.unwrap_or_default()
|
||||
}
|
||||
pub fn general_supported(binding: &Binding, job: &rmm_domain::jobs::JobPayload) -> bool {
|
||||
(|| -> Result<bool> {
|
||||
let p = general(binding)?.policy.context("NO_GENERAL_POLICY")?;
|
||||
Ok(match &job.action {
|
||||
rmm_domain::jobs::Action::RunScript { interpreter, .. } => {
|
||||
p.allow_root_scripts
|
||||
&& match interpreter.as_str() {
|
||||
"posix_sh" => rmm_agent_linux::actions::Interpreter::PosixSh.available(),
|
||||
"bash" => rmm_agent_linux::actions::Interpreter::Bash.available(),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
rmm_domain::jobs::Action::SetServiceState { unit, state } => {
|
||||
p.allowed_services.contains(unit)
|
||||
&& matches!(state.as_str(), "running" | "stopped")
|
||||
&& job.max_runtime_seconds >= 180
|
||||
}
|
||||
rmm_domain::jobs::Action::QueryLogs { unit, .. } => {
|
||||
p.allowed_services.contains(unit) && job.max_runtime_seconds >= 20
|
||||
}
|
||||
rmm_domain::jobs::Action::Reboot { .. } => {
|
||||
p.allow_reboot && job.max_runtime_seconds >= 60
|
||||
}
|
||||
_ => false,
|
||||
})
|
||||
})()
|
||||
.unwrap_or(false)
|
||||
}
|
||||
Reference in New Issue
Block a user