Share signed job core and verify native Linux then Windows contracts
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
+14
-248
@@ -1,9 +1,13 @@
|
||||
use anyhow::{Result, ensure};
|
||||
#[cfg(test)]
|
||||
use prost::Message;
|
||||
use rmm_domain::jobs::{Action, JobPayload, hash};
|
||||
use rmm_privileged_helper::{Binding, Outcome, Request};
|
||||
#[cfg(test)]
|
||||
use rmm_domain::jobs::hash;
|
||||
use rmm_domain::jobs::{Action, JobPayload};
|
||||
use rmm_privileged_helper::{Binding, Outcome};
|
||||
use rmm_protocol::*;
|
||||
use rusqlite::{Connection, OptionalExtension, params};
|
||||
use rusqlite::Connection;
|
||||
#[cfg(test)]
|
||||
use uuid::Uuid;
|
||||
|
||||
pub fn supported(job: &JobPayload) -> bool {
|
||||
@@ -53,242 +57,14 @@ fn supported_as(job: &JobPayload, uid: u32, helper_configured: bool) -> bool {
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
pub use rmm_agent_core::jobs::{
|
||||
ack, event, events, interrupted, interrupted_request, next, no_start, permit_request,
|
||||
requesting, reserve_request, result, transition,
|
||||
};
|
||||
pub fn accept(db: &Connection, binding: &Binding, offer: &JobOffer) -> Result<bool> {
|
||||
let job = binding.job(&offer.payload_bytes)?;
|
||||
ensure!(
|
||||
offer.job_id == job.job_id.to_string()
|
||||
&& offer.attempt_id == job.attempt_id.to_string()
|
||||
&& offer.job_payload_hash == hash(&offer.payload_bytes)
|
||||
&& Uuid::parse_str(&offer.authorization_id).is_ok_and(|id| !id.is_nil())
|
||||
&& offer.plan_hash.len() == 64
|
||||
&& hex_hash(&offer.plan_hash),
|
||||
"OFFER_BINDING"
|
||||
);
|
||||
ensure!(
|
||||
supported_with_binding(&job, Some(binding)),
|
||||
"UNSUPPORTED_CAPABILITY"
|
||||
);
|
||||
let bytes = offer.encode_to_vec();
|
||||
let existing: Option<Vec<u8>> = db
|
||||
.query_row(
|
||||
"SELECT offer FROM job_attempts WHERE job=?1 AND attempt=?2",
|
||||
params![offer.job_id, offer.attempt_id],
|
||||
|r| r.get(0),
|
||||
)
|
||||
.optional()?;
|
||||
if let Some(old) = existing {
|
||||
ensure!(old == bytes, "OFFER_CONFLICT");
|
||||
return Ok(false);
|
||||
}
|
||||
let count: i64 = db.query_row("SELECT count(*) FROM job_attempts", [], |r| r.get(0))?;
|
||||
ensure!(count < 10000, "JOURNAL_CAPACITY_NEW_EFFECTS_BLOCKED");
|
||||
db.execute(
|
||||
"INSERT INTO job_attempts(job,attempt,offer,state) VALUES(?1,?2,?3,'accepted')",
|
||||
params![offer.job_id, offer.attempt_id, bytes],
|
||||
)?;
|
||||
Ok(true)
|
||||
}
|
||||
fn hex_hash(s: &str) -> bool {
|
||||
s.bytes()
|
||||
.all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
|
||||
}
|
||||
|
||||
/// Inspect ONLY at a new process startup, never on a transport reconnect: no
|
||||
/// executor thread from the previous process can still deliver its outcome.
|
||||
/// This does not execute, release consumption or invent a successful outcome.
|
||||
pub fn interrupted(
|
||||
db: &Connection,
|
||||
ledger: &Connection,
|
||||
binding: &Binding,
|
||||
) -> Result<Vec<(JobOffer, String)>> {
|
||||
let mut statement = db.prepare(
|
||||
"SELECT offer,grant_id FROM job_attempts WHERE state IN ('requesting','running','verifying') ORDER BY job,attempt",
|
||||
)?;
|
||||
let rows = statement.query_map([], |r| {
|
||||
Ok((r.get::<_, Vec<u8>>(0)?, r.get::<_, String>(1)?))
|
||||
})?;
|
||||
let mut interrupted = Vec::new();
|
||||
for row in rows {
|
||||
let (bytes, grant) = row?;
|
||||
let offer = JobOffer::decode(bytes.as_slice())?;
|
||||
let job = binding.job(&offer.payload_bytes)?;
|
||||
ensure!(
|
||||
offer.job_id == job.job_id.to_string()
|
||||
&& offer.attempt_id == job.attempt_id.to_string()
|
||||
&& offer.job_payload_hash == hash(&offer.payload_bytes)
|
||||
&& Uuid::parse_str(&offer.authorization_id).is_ok_and(|id| !id.is_nil())
|
||||
&& offer.plan_hash.len() == 64
|
||||
&& hex_hash(&offer.plan_hash),
|
||||
"INTERRUPTED_OFFER_BINDING"
|
||||
);
|
||||
if !grant.is_empty() {
|
||||
let row: Option<(String, u64, String, String, Vec<u8>)> = ledger
|
||||
.query_row(
|
||||
"SELECT c.agent,c.generation,c.job,c.attempt,e.start FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE c.grant_id=?1",
|
||||
[&grant],
|
||||
|r| Ok((r.get(0)?, r.get(1)?, r.get(2)?, r.get(3)?, r.get(4)?)),
|
||||
)
|
||||
.optional()?;
|
||||
let (agent, generation, job_id, attempt, start) =
|
||||
row.ok_or_else(|| anyhow::anyhow!("INTERRUPTED_START_EVIDENCE_MISSING"))?;
|
||||
ensure!(
|
||||
agent == binding.agent_id.to_string()
|
||||
&& generation == binding.enrollment_generation
|
||||
&& job_id == offer.job_id
|
||||
&& attempt == offer.attempt_id,
|
||||
"INTERRUPTED_CONSUMPTION_BINDING"
|
||||
);
|
||||
let start: serde_json::Value = serde_json::from_slice(&start)?;
|
||||
let request: Request = serde_json::from_value(start["request"].clone())?;
|
||||
let permit: rmm_domain::jobs::ExecutionPermitPayload =
|
||||
serde_json::from_slice(&request.permit_bytes)?;
|
||||
// Verify the historical signed request at its original valid time;
|
||||
// this is evidence only, never permission to start it again.
|
||||
let (_, verified) = binding.verify(&request, permit.not_before)?;
|
||||
ensure!(
|
||||
verified == permit
|
||||
&& permit.grant_id.to_string() == grant
|
||||
&& request.job_bytes == offer.payload_bytes
|
||||
&& request.plan_hash == offer.plan_hash
|
||||
&& request.authorization_id.to_string() == offer.authorization_id,
|
||||
"INTERRUPTED_START_BINDING"
|
||||
);
|
||||
} else {
|
||||
// A request may have committed remotely without its reply arriving.
|
||||
// It can only become local unknown, never a fabricated grant/result.
|
||||
let state: String = db.query_row(
|
||||
"SELECT state FROM job_attempts WHERE job=?1 AND attempt=?2",
|
||||
params![offer.job_id, offer.attempt_id],
|
||||
|r| r.get(0),
|
||||
)?;
|
||||
ensure!(state == "requesting", "INTERRUPTED_RUNNING_GRANT_MISSING");
|
||||
}
|
||||
interrupted.push((offer, grant));
|
||||
}
|
||||
Ok(interrupted)
|
||||
}
|
||||
|
||||
pub fn interrupted_request(db: &Connection, offer: &JobOffer) -> Result<()> {
|
||||
ensure!(
|
||||
db.execute(
|
||||
"UPDATE job_attempts SET state='unknown',revision=revision+1 WHERE job=?1 AND attempt=?2 AND state='requesting' AND grant_id=''",
|
||||
params![offer.job_id, offer.attempt_id],
|
||||
)? == 1,
|
||||
"INTERRUPTED_REQUEST_STATE"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
pub fn event(db: &Connection, envelope: &Envelope) -> Result<()> {
|
||||
let count: i64 = db.query_row("SELECT count(*) FROM job_events", [], |r| r.get(0))?;
|
||||
ensure!(count < 1000, "UNACKNOWLEDGED_EVENT_LIMIT");
|
||||
db.execute(
|
||||
"INSERT INTO job_events(id,payload) VALUES(?1,?2)",
|
||||
params![envelope.message_id, envelope.encode_to_vec()],
|
||||
)?;
|
||||
Ok(())
|
||||
}
|
||||
pub fn events(db: &Connection) -> Result<Vec<Envelope>> {
|
||||
let mut statement = db.prepare("SELECT payload FROM job_events ORDER BY rowid LIMIT 100")?;
|
||||
let bytes = statement
|
||||
.query_map([], |r| r.get::<_, Vec<u8>>(0))?
|
||||
.collect::<rusqlite::Result<Vec<_>>>()?;
|
||||
bytes
|
||||
.into_iter()
|
||||
.map(|b| Ok(Envelope::decode(b.as_slice())?))
|
||||
.collect()
|
||||
}
|
||||
pub fn ack(db: &mut Connection, id: &str) -> Result<()> {
|
||||
let tx = db.transaction()?;
|
||||
crate::reconcile::archive_events(&tx)?;
|
||||
tx.execute("DELETE FROM job_events WHERE id=?1", [id])?;
|
||||
tx.commit()?;
|
||||
Ok(())
|
||||
}
|
||||
pub fn next(db: &Connection) -> Result<Option<JobOffer>> {
|
||||
// One device-wide effect at a time; unknown/reserved attempts retain locks.
|
||||
let busy: i64 = db.query_row("SELECT count(*) FROM job_attempts WHERE state IN ('requesting','running','unknown','awaiting_reboot')", [], |r| r.get(0))?;
|
||||
if busy != 0 {
|
||||
return Ok(None);
|
||||
}
|
||||
let mut statement = db.prepare("SELECT offer FROM job_attempts WHERE state='accepted' AND cancel_requested=0 ORDER BY rowid")?;
|
||||
let rows = statement.query_map([], |r| r.get::<_, Vec<u8>>(0))?;
|
||||
let now = chrono::Utc::now();
|
||||
for bytes in rows {
|
||||
let offer = JobOffer::decode(bytes?.as_slice())?;
|
||||
let job: JobPayload = serde_json::from_slice(&offer.payload_bytes)?;
|
||||
if now >= job.not_before || now >= job.start_before {
|
||||
return Ok(Some(offer));
|
||||
}
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
pub fn requesting(db: &Connection) -> Result<Option<JobOffer>> {
|
||||
let bytes: Option<Vec<u8>> = db
|
||||
.query_row(
|
||||
"SELECT offer FROM job_attempts WHERE state='requesting' LIMIT 1",
|
||||
[],
|
||||
|r| r.get(0),
|
||||
)
|
||||
.optional()?;
|
||||
bytes
|
||||
.map(|b| Ok(JobOffer::decode(b.as_slice())?))
|
||||
.transpose()
|
||||
}
|
||||
pub fn reserve_request(db: &Connection, offer: &JobOffer) -> Result<()> {
|
||||
ensure!(db.execute("UPDATE job_attempts SET state='requesting' WHERE job=?1 AND attempt=?2 AND state='accepted' AND cancel_requested=0",
|
||||
params![offer.job_id,offer.attempt_id])? == 1, "ATTEMPT_NOT_STARTABLE");
|
||||
Ok(())
|
||||
}
|
||||
pub fn transition(db: &Connection, offer: &JobOffer, state: &str, grant: &str) -> Result<u64> {
|
||||
let previous: String = db.query_row(
|
||||
"SELECT state FROM job_attempts WHERE job=?1 AND attempt=?2",
|
||||
params![offer.job_id, offer.attempt_id],
|
||||
|r| r.get(0),
|
||||
)?;
|
||||
let allowed = match previous.as_str() {
|
||||
"accepted" | "requesting" => matches!(
|
||||
state,
|
||||
"running" | "failed" | "cancelled" | "expired" | "unknown"
|
||||
),
|
||||
"running" | "verifying" => matches!(
|
||||
state,
|
||||
"verifying" | "succeeded" | "failed" | "cancelled" | "unknown" | "awaiting_reboot"
|
||||
),
|
||||
// Only a definitive completion of the already-running executor calls
|
||||
// this reconciliation path. No new effect is started from unknown.
|
||||
"unknown" | "awaiting_reboot" => matches!(
|
||||
state,
|
||||
"succeeded" | "failed" | "cancelled" | "unknown" | "awaiting_reboot"
|
||||
),
|
||||
_ => false,
|
||||
};
|
||||
ensure!(allowed, "INVALID_LOCAL_STATE_TRANSITION");
|
||||
let rev: i64 = db.query_row("UPDATE job_attempts SET state=?3,grant_id=?4,revision=revision+1 WHERE job=?1 AND attempt=?2 RETURNING revision",
|
||||
params![offer.job_id,offer.attempt_id,state,grant], |r| r.get(0))?;
|
||||
Ok(u64::try_from(rev)?)
|
||||
}
|
||||
pub fn result(offer: &JobOffer, revision: u64, grant: &str, outcome: Outcome) -> JobResult {
|
||||
JobResult {
|
||||
job_id: offer.job_id.clone(),
|
||||
attempt_id: offer.attempt_id.clone(),
|
||||
revision,
|
||||
state: outcome.state,
|
||||
grant_id: grant.into(),
|
||||
stdout: outcome.stdout,
|
||||
stderr: outcome.stderr,
|
||||
output_truncated: outcome.output_truncated,
|
||||
reboot_required: outcome.reboot_required,
|
||||
exit_code: outcome.exit_code,
|
||||
evidence_json: outcome.evidence.to_string(),
|
||||
error_code: outcome.error_code,
|
||||
}
|
||||
}
|
||||
pub fn no_start(state: &str, code: &str) -> Outcome {
|
||||
Outcome {
|
||||
state: state.into(),
|
||||
evidence: serde_json::json!({"not_started":true,"postconditions_passed":false}),
|
||||
..Outcome::unknown(code)
|
||||
}
|
||||
rmm_agent_core::jobs::accept(db, binding, offer, |job| {
|
||||
supported_with_binding(job, Some(binding))
|
||||
})
|
||||
}
|
||||
pub fn execute(job: &JobPayload) -> Outcome {
|
||||
let result = match &job.action {
|
||||
@@ -397,16 +173,6 @@ fn query_logs(job: &JobPayload) -> Result<Outcome> {
|
||||
},
|
||||
})
|
||||
}
|
||||
pub fn permit_request(offer: &JobOffer, permit: &ExecutionPermit) -> Result<Request> {
|
||||
Ok(Request {
|
||||
job_bytes: offer.payload_bytes.clone(),
|
||||
permit_bytes: permit.payload_bytes.clone(),
|
||||
signature: permit.signature.clone(),
|
||||
plan_hash: offer.plan_hash.clone(),
|
||||
authorization_id: Uuid::parse_str(&offer.authorization_id)?,
|
||||
})
|
||||
}
|
||||
|
||||
/// With no backend SyncResponse contract, a reconnect/restart cannot prove an
|
||||
/// earlier reservation never started. Telemetry and evidence replay continue;
|
||||
/// all new effects stop. Do not paper over this with a new start request.
|
||||
|
||||
+4
-1212
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user