Qualify atomic deny-only helper abandonment on actual Linux VM
Rust development slice / linux (push) Failing after 7s

This commit is contained in:
2026-11-14 06:48:32 +01:00
parent 44c45c15b9
commit 67370d21a3
7 changed files with 1174 additions and 14 deletions
+106 -1
View File
@@ -1,5 +1,5 @@
//! Connection-level ledger rules, with OS path/lock/ACL handling left to adapters.
use crate::auth::{Outcome, Request};
use crate::auth::{Outcome, Request, VerifiedHistoricalDenial};
use anyhow::{Context, Result, ensure};
use chrono::{DateTime, Utc};
use rmm_domain::jobs::{ExecutionPermitPayload, JobPayload};
@@ -77,6 +77,111 @@ pub fn begin_execution(
tx.commit()?;
Ok(())
}
/// Retained evidence only. In particular, a legacy consumption without its
/// original start can never be repaired into a proven nonstart by this path.
pub(crate) fn existing_no_start(
db: &rusqlite::Connection,
original: &VerifiedHistoricalDenial,
) -> Result<Option<Outcome>> {
let p = &original.permit;
type Row = (
String,
String,
u64,
String,
String,
Option<Vec<u8>>,
Option<Vec<u8>>,
Option<Vec<u8>>,
);
let mut statement = db.prepare("SELECT c.grant_id,c.agent,c.generation,c.job,c.attempt,c.result,e.start,e.outcome FROM consumed c LEFT JOIN execution_evidence e USING(grant_id) WHERE c.grant_id=?1 OR (c.agent=?2 AND c.generation=?3 AND c.job=?4 AND c.attempt=?5)")?;
let rows = statement
.query_map(
params![
p.grant_id.to_string(),
p.agent_id.to_string(),
p.enrollment_generation,
p.job_id.to_string(),
p.attempt_id.to_string()
],
|r| {
Ok((
r.get(0)?,
r.get(1)?,
r.get(2)?,
r.get(3)?,
r.get(4)?,
r.get(5)?,
r.get(6)?,
r.get(7)?,
))
},
)?
.collect::<rusqlite::Result<Vec<Row>>>()?;
ensure!(rows.len() <= 1, "DENIAL_EXISTING_ATTEMPT_CONFLICT");
let Some((grant, agent, generation, job, attempt, finished, start, outcome)) =
rows.into_iter().next()
else {
return Ok(None);
};
ensure!(
grant == p.grant_id.to_string()
&& agent == p.agent_id.to_string()
&& generation == p.enrollment_generation
&& job == p.job_id.to_string()
&& attempt == p.attempt_id.to_string(),
"DENIAL_EXISTING_ATTEMPT_CONFLICT"
);
let Some(start) = start else {
return Ok(Some(Outcome::unknown("HELPER_PREVIOUS_START_UNRESOLVED")));
};
let start: serde_json::Value = serde_json::from_slice(&start)?;
let saved: Request = serde_json::from_value(start["request"].clone())?;
ensure!(
serde_json::to_vec(&saved)? == serde_json::to_vec(&original.request)?,
"DENIAL_EXISTING_REQUEST_CONFLICT"
);
let boot: Uuid = serde_json::from_value(start["previous_boot_id"].clone())?;
ensure!(!boot.is_nil(), "DENIAL_EXISTING_ORIGINAL_BOOT_MISSING");
let _: DateTime<Utc> = serde_json::from_value(start["reserved_at"].clone())?;
if let (Some(a), Some(b)) = (&finished, &outcome) {
ensure!(
canonical(a)? == canonical(b)?,
"DENIAL_EXISTING_OUTCOME_CONFLICT"
);
}
let Some(bytes) = outcome.or(finished) else {
return Ok(Some(Outcome::unknown("HELPER_PREVIOUS_EFFECT_UNRESOLVED")));
};
Ok(Some(serde_json::from_slice(&canonical(&bytes)?)?))
}
/// Called only inside HelperSync's guarded Immediate transaction after its
/// independent intent/lineage checks. Never finish/unlock here. All three
/// witnesses commit together, so no crash can expose a bare new consumption.
pub(crate) fn record_no_start_in(
db: &rusqlite::Connection,
original: &VerifiedHistoricalDenial,
boot: Uuid,
observed_at: DateTime<Utc>,
witness: &crate::helper_reconcile::NoDispatchObservation,
) -> Result<Outcome> {
let p = &original.permit;
validate_start_request(p, &original.request)?;
consume_in(db, p)?;
save_start(db, p, &original.request, boot, observed_at)?;
let outcome = Outcome {
state: "failed".into(),
evidence: serde_json::json!({"not_started":true,"postconditions_passed":false,
"deny_only":true,"reservation_only":true,"original_request_sha256":original.request_sha256,
"intent_id":witness.intent_id,"intent_sha256":witness.intent_sha256,
"intent_recorded_at":witness.intent_recorded_at,"observed_at":observed_at}),
..Outcome::unknown("HELPER_ABANDONED_BEFORE_DISPATCH")
};
persist_outcome_in(db, p, &outcome)?;
Ok(outcome)
}
fn validate_start_request(p: &ExecutionPermitPayload, request: &Request) -> Result<()> {
ensure!(
request.job_bytes.len() <= 65536