Make start evidence atomic and recover only bound durable outcomes
Rust development slice / linux (push) Failing after 7s

This commit is contained in:
2026-11-14 02:01:17 +01:00
parent de3b408c34
commit 74736483df
13 changed files with 764 additions and 87 deletions
+167 -45
View File
@@ -72,60 +72,56 @@ pub fn interrupted_with(
verifier: &impl crate::crypto::Ed25519Verifier, verifier: &impl crate::crypto::Ed25519Verifier,
) -> Result<Vec<(JobOffer, String)>> { ) -> Result<Vec<(JobOffer, String)>> {
let mut statement = db.prepare( let mut statement = db.prepare(
"SELECT offer,grant_id FROM job_attempts WHERE state IN ('requesting','running','verifying') ORDER BY job,attempt", "SELECT offer,grant_id,state FROM job_attempts WHERE state IN ('requesting','running','verifying','unknown') ORDER BY job,attempt",
)?; )?;
let rows = statement.query_map([], |r| { let rows = statement.query_map([], |r| {
Ok((r.get::<_, Vec<u8>>(0)?, r.get::<_, String>(1)?)) Ok((
r.get::<_, Vec<u8>>(0)?,
r.get::<_, String>(1)?,
r.get::<_, String>(2)?,
))
})?; })?;
let mut interrupted = Vec::new(); let mut interrupted = Vec::new();
for row in rows { for row in rows {
let (bytes, grant) = row?; let (bytes, mut grant, state) = row?;
let offer = JobOffer::decode(bytes.as_slice())?; let offer = JobOffer::decode(bytes.as_slice())?;
let job = binding.job(&offer.payload_bytes)?; let job = binding.job(&offer.payload_bytes)?;
ensure!( validate_interrupted_offer(&offer, &job)?;
offer.job_id == job.job_id.to_string() // begin_execution may have committed before the running journal event.
&& offer.attempt_id == job.attempt_id.to_string() // Recover its actual grant, never invent one from an accepted offer.
&& offer.job_payload_hash == hash(&offer.payload_bytes) let (count, stored): (u64, Option<String>) = ledger.query_row(
&& Uuid::parse_str(&offer.authorization_id).is_ok_and(|id| !id.is_nil()) "SELECT count(*),MIN(grant_id) FROM consumed WHERE job=?1 AND attempt=?2",
&& offer.plan_hash.len() == 64 params![offer.job_id, offer.attempt_id],
&& hex_hash(&offer.plan_hash), |r| Ok((r.get(0)?, r.get(1)?)),
"INTERRUPTED_OFFER_BINDING" )?;
); ensure!(count <= 1, "INTERRUPTED_MULTIPLE_CONSUMPTIONS");
if let Some(stored) = stored {
ensure!(
grant.is_empty() || grant == stored,
"INTERRUPTED_GRANT_CONFLICT"
);
grant = stored;
}
if state == "unknown" {
// A reconnect may have closed the running journal while the same
// original executor was still finishing. Only its already-durable
// terminal completion can repair this event gap; uncertainty stays.
if !grant.is_empty()
&& recover_interrupted_outcome_with(ledger, binding, &offer, &grant, verifier)?
.is_some_and(|saved| {
matches!(
saved.state.as_str(),
"succeeded" | "failed" | "cancelled" | "expired"
)
})
{
interrupted.push((offer, grant));
}
continue;
}
if !grant.is_empty() { if !grant.is_empty() {
let row: Option<(String, u64, String, String, Vec<u8>)> = ledger verified_interrupted_start(ledger, binding, &offer, &grant, verifier)?;
.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_with(&request, permit.not_before, verifier)?;
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 { } 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( let state: String = db.query_row(
"SELECT state FROM job_attempts WHERE job=?1 AND attempt=?2", "SELECT state FROM job_attempts WHERE job=?1 AND attempt=?2",
params![offer.job_id, offer.attempt_id], params![offer.job_id, offer.attempt_id],
@@ -138,6 +134,132 @@ pub fn interrupted_with(
Ok(interrupted) Ok(interrupted)
} }
fn validate_interrupted_offer(offer: &JobOffer, job: &JobPayload) -> Result<()> {
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"
);
Ok(())
}
type InterruptedStartRow = (
String,
u64,
String,
String,
Vec<u8>,
Option<Vec<u8>>,
Option<Vec<u8>>,
);
type InterruptedOutcomes = (Option<Vec<u8>>, Option<Vec<u8>>);
fn verified_interrupted_start(
ledger: &Connection,
binding: &Binding,
offer: &JobOffer,
grant: &str,
verifier: &impl crate::crypto::Ed25519Verifier,
) -> Result<InterruptedOutcomes> {
let job = binding.job(&offer.payload_bytes)?;
validate_interrupted_offer(offer, &job)?;
ensure!(
Uuid::parse_str(grant).is_ok_and(|id| !id.is_nil()),
"INTERRUPTED_GRANT_ID"
);
let row:Option<InterruptedStartRow>=ledger.query_row(
"SELECT c.agent,c.generation,c.job,c.attempt,e.start,e.outcome,c.result 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)?,r.get(5)?,r.get(6)?))).optional()?;
let (agent, generation, job_id, attempt, start, outcome, result) =
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 boot = start["previous_boot_id"]
.as_str()
.ok_or_else(|| anyhow::anyhow!("INTERRUPTED_ORIGINAL_BOOT_MISSING"))?;
ensure!(
Uuid::parse_str(boot).is_ok_and(|id| !id.is_nil()),
"INTERRUPTED_ORIGINAL_BOOT_MISSING"
);
let _: chrono::DateTime<chrono::Utc> = serde_json::from_value(start["reserved_at"].clone())?;
ensure!(
start["reauthentication_required"] == true && start["postconditions_passed"] == false,
"INTERRUPTED_START_WITNESS_PROFILE"
);
let request: Request = serde_json::from_value(start["request"].clone())?;
let permit: rmm_domain::jobs::ExecutionPermitPayload =
serde_json::from_slice(&request.permit_bytes)?;
// Historical verification is evidence only; it can NEVER start another job.
let (_, verified) = binding.verify_with(&request, permit.not_before, verifier)?;
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"
);
Ok((outcome, result))
}
/// Recover only a completion already durably recorded by the original executor.
/// No outcome means uncertainty, not nonstart or a permission to execute again.
/// Caller re-journalizes this evidence, never calls finish/unlocks at startup.
pub fn recover_interrupted_outcome(
ledger: &Connection,
binding: &Binding,
offer: &JobOffer,
grant: &str,
) -> Result<Option<Outcome>> {
recover_interrupted_outcome_with(
ledger,
binding,
offer,
grant,
&crate::crypto::DefaultVerifier::default(),
)
}
pub fn recover_interrupted_outcome_with(
ledger: &Connection,
binding: &Binding,
offer: &JobOffer,
grant: &str,
verifier: &impl crate::crypto::Ed25519Verifier,
) -> Result<Option<Outcome>> {
use rmm_domain::reconciliation::{ReconciledOutcome, canonical_outcome_bytes};
let (outcome, result) = verified_interrupted_start(ledger, binding, offer, grant, verifier)?;
let canonical = |bytes: &[u8]| -> Result<Vec<u8>> {
Ok(canonical_outcome_bytes(&serde_json::from_slice::<
ReconciledOutcome,
>(bytes)?)?)
};
if let (Some(a), Some(b)) = (&outcome, &result) {
ensure!(
canonical(a)? == canonical(b)?,
"INTERRUPTED_OUTCOME_CONFLICT"
);
}
let Some(bytes) = outcome.or(result) else {
return Ok(None);
};
let saved: Outcome = serde_json::from_slice(&canonical(&bytes)?)?;
ensure!(
matches!(
saved.state.as_str(),
"unknown" | "awaiting_reboot" | "succeeded" | "failed" | "cancelled" | "expired"
),
"INTERRUPTED_OUTCOME_STATE"
);
Ok(Some(saved))
}
pub fn interrupted_request(db: &Connection, offer: &JobOffer) -> Result<()> { pub fn interrupted_request(db: &Connection, offer: &JobOffer) -> Result<()> {
ensure!( ensure!(
db.execute( db.execute(
+141 -19
View File
@@ -1,8 +1,13 @@
//! Connection-level ledger rules, with OS path/lock/ACL handling left to adapters. //! Connection-level ledger rules, with OS path/lock/ACL handling left to adapters.
use crate::auth::{Outcome, Request}; use crate::auth::{Outcome, Request};
use anyhow::{Result, ensure}; use anyhow::{Context, Result, ensure};
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use rmm_domain::jobs::{ExecutionPermitPayload, JobPayload}; use rmm_domain::jobs::{ExecutionPermitPayload, JobPayload};
use rmm_domain::{
jobs::hash,
reconciliation::{ReconciledOutcome, canonical_outcome_bytes},
};
use rusqlite::{OptionalExtension, TransactionBehavior, params};
use uuid::Uuid; use uuid::Uuid;
/// Finite 1 GiB bound for durable agent/helper history. Unexpected page sizes /// Finite 1 GiB bound for durable agent/helper history. Unexpected page sizes
@@ -29,18 +34,24 @@ pub fn initialize_ledger(db: &rusqlite::Connection) -> Result<()> {
Ok(()) Ok(())
} }
/// Legacy split reservation API retained for old fixtures/readers. Production
/// callers use begin_execution so a crash cannot lose the original start witness.
pub fn consume(db: &mut rusqlite::Connection, p: &ExecutionPermitPayload) -> Result<()> { pub fn consume(db: &mut rusqlite::Connection, p: &ExecutionPermitPayload) -> Result<()> {
let tx = db.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?; let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?;
// Unknown effects retain the global device lock, including across restart. consume_in(&tx, p)?;
let unresolved: i64 = tx.query_row( tx.commit()?;
Ok(())
}
fn consume_in(db: &rusqlite::Connection, p: &ExecutionPermitPayload) -> Result<()> {
let unresolved: i64 = db.query_row(
"SELECT count(*) FROM consumed WHERE result IS NULL", "SELECT count(*) FROM consumed WHERE result IS NULL",
[], [],
|r| r.get(0), |r| r.get(0),
)?; )?;
ensure!(unresolved == 0, "UNRESOLVED_EFFECT_RESOURCE_LOCKED"); ensure!(unresolved == 0, "UNRESOLVED_EFFECT_RESOURCE_LOCKED");
tx.execute( db.execute(
"INSERT INTO consumed(grant_id,agent,generation,job,attempt) VALUES(?1,?2,?3,?4,?5)", "INSERT INTO consumed(grant_id,agent,generation,job,attempt) VALUES(?1,?2,?3,?4,?5)",
rusqlite::params![ params![
p.grant_id.to_string(), p.grant_id.to_string(),
p.agent_id.to_string(), p.agent_id.to_string(),
p.enrollment_generation, p.enrollment_generation,
@@ -48,29 +59,140 @@ pub fn consume(db: &mut rusqlite::Connection, p: &ExecutionPermitPayload) -> Res
p.attempt_id.to_string() p.attempt_id.to_string()
], ],
)?; )?;
Ok(())
}
/// Caller has already checked the signature, qualified clock, fresh Sync and
/// policy. Persist consumption and the exact legacy start witness atomically.
pub fn begin_execution(
db: &mut rusqlite::Connection,
permit: &ExecutionPermitPayload,
request: &Request,
previous_boot_id: Uuid,
recorded_at: DateTime<Utc>,
) -> Result<()> {
validate_start_request(permit, request)?;
let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?;
consume_in(&tx, permit)?;
save_start(&tx, permit, request, previous_boot_id, recorded_at)?;
tx.commit()?; tx.commit()?;
Ok(()) Ok(())
} }
fn validate_start_request(p: &ExecutionPermitPayload, request: &Request) -> Result<()> {
ensure!(
request.job_bytes.len() <= 65536
&& request.permit_bytes.len() <= 8192
&& request.signature.len() == 64,
"START_REQUEST_SIZE"
);
let saved: ExecutionPermitPayload = serde_json::from_slice(&request.permit_bytes)?;
let j: JobPayload = serde_json::from_slice(&request.job_bytes)?;
ensure!(
saved == *p
&& request.authorization_id == p.authorization_id
&& request.plan_hash == p.plan_hash
&& p.job_payload_hash == hash(&request.job_bytes)
&& p.tenant_id == j.tenant_id
&& p.asset_id == j.asset_id
&& p.agent_id == j.agent_id
&& p.enrollment_generation == j.enrollment_generation
&& p.assignment_version == j.assignment_version
&& p.job_id == j.job_id
&& p.attempt_id == j.attempt_id
&& p.action == j.action.name()
&& p.execution_identity == j.execution_identity
&& p.max_runtime_seconds == j.max_runtime_seconds,
"STORED_START_REQUEST_BINDING"
);
Ok(())
}
fn canonical(bytes: &[u8]) -> Result<Vec<u8>> {
Ok(canonical_outcome_bytes(&serde_json::from_slice::<
ReconciledOutcome,
>(bytes)?)?)
}
/// Compare-and-set the original completion evidence WITHOUT releasing a lock.
/// Existing identical bytes are preserved; contradictory completions fail closed.
pub fn persist_outcome(
db: &rusqlite::Connection,
p: &ExecutionPermitPayload,
outcome: &Outcome,
) -> Result<()> {
let tx = db.unchecked_transaction()?;
persist_outcome_in(&tx, p, outcome)?;
tx.commit()?;
Ok(())
}
fn persist_outcome_in(
db: &rusqlite::Connection,
p: &ExecutionPermitPayload,
outcome: &Outcome,
) -> Result<Vec<u8>> {
ensure!(
matches!(
outcome.state.as_str(),
"unknown" | "awaiting_reboot" | "succeeded" | "failed" | "cancelled" | "expired"
),
"INVALID_STORED_OUTCOME_STATE"
);
type CompletionRow = (
String,
u64,
String,
String,
Vec<u8>,
Option<Vec<u8>>,
Option<Vec<u8>>,
);
let row:Option<CompletionRow>=db.query_row(
"SELECT c.agent,c.generation,c.job,c.attempt,e.start,e.outcome,c.result FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE c.grant_id=?1",[p.grant_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)?))).optional()?;
let (agent, generation, job, attempt, start, prior, finished) =
row.context("STORED_COMPLETION_START_MISSING")?;
ensure!(
agent == p.agent_id.to_string()
&& generation == p.enrollment_generation
&& job == p.job_id.to_string()
&& attempt == p.attempt_id.to_string(),
"STORED_COMPLETION_CONSUMPTION_BINDING"
);
let start: serde_json::Value = serde_json::from_slice(&start)?;
let request: Request = serde_json::from_value(start["request"].clone())?;
validate_start_request(p, &request)?;
let bytes = serde_json::to_vec(outcome)?;
let expected = canonical(&bytes)?;
for previous in [&prior, &finished].into_iter().flatten() {
ensure!(
canonical(previous)? == expected,
"STORED_COMPLETION_CONFLICT"
);
}
if prior.is_none() {
ensure!(
db.execute(
"UPDATE execution_evidence SET outcome=?2 WHERE grant_id=?1 AND outcome IS NULL",
params![p.grant_id.to_string(), bytes]
)? == 1,
"STORED_COMPLETION_CAS_CONFLICT"
);
}
Ok(prior.unwrap_or(bytes))
}
/// Called only AFTER the corresponding journal result committed. A crash before
/// this call retains the original outcome for the normal signed reconciliation.
pub fn finish( pub fn finish(
db: &rusqlite::Connection, db: &rusqlite::Connection,
p: &ExecutionPermitPayload, p: &ExecutionPermitPayload,
outcome: &Outcome, outcome: &Outcome,
) -> Result<()> { ) -> Result<()> {
db.execute( let tx = db.unchecked_transaction()?;
"UPDATE execution_evidence SET outcome=?2 WHERE grant_id=?1", let bytes = persist_outcome_in(&tx, p, outcome)?;
rusqlite::params![p.grant_id.to_string(), serde_json::to_vec(outcome)?],
)?;
// Unknown / awaiting reboot keep the resource reserved until a real sync
// protocol exists. Never unlock on a process exit or a network reconnect.
if outcome.state != "unknown" && outcome.state != "awaiting_reboot" { if outcome.state != "unknown" && outcome.state != "awaiting_reboot" {
ensure!( tx.execute(
db.execute( "UPDATE consumed SET result=?2 WHERE grant_id=?1 AND result IS NULL",
"UPDATE consumed SET result=?2 WHERE grant_id=?1 AND result IS NULL", params![p.grant_id.to_string(), bytes],
rusqlite::params![p.grant_id.to_string(), serde_json::to_vec(outcome)?] )?;
)? == 1,
"CONSUMPTION_NOT_FOUND"
);
} }
tx.commit()?;
Ok(()) Ok(())
} }
+126
View File
@@ -290,3 +290,129 @@ fn portable_acceptance_requires_platform_capability_and_exact_redelivery() {
assert!(jobs::next(&db).unwrap().is_none()); assert!(jobs::next(&db).unwrap().is_none());
assert!(jobs::transition(&db, &offer, "running", "").is_err()); assert!(jobs::transition(&db, &offer, "running", "").is_err());
} }
#[test]
fn atomic_begin_execution_rolls_back_both_rows_on_missing_witness_or_start_insert_failure() {
let (_, request, permit, now) = fixture();
let mut db = Connection::open_in_memory().unwrap();
ledger::initialize_ledger(&db).unwrap();
assert!(ledger::begin_execution(&mut db, &permit, &request, Uuid::nil(), now).is_err());
assert_eq!(
db.query_row::<u32, _, _>("SELECT count(*) FROM consumed", [], |r| r.get(0))
.unwrap(),
0
);
db.execute_batch("CREATE TRIGGER refuse_start BEFORE INSERT ON execution_evidence BEGIN SELECT RAISE(ABORT,'fixture storage failure'); END;").unwrap();
assert!(ledger::begin_execution(&mut db, &permit, &request, Uuid::from_u128(9), now).is_err());
assert_eq!(
db.query_row::<u32, _, _>("SELECT count(*) FROM consumed", [], |r| r.get(0))
.unwrap(),
0
);
assert_eq!(
db.query_row::<u32, _, _>("SELECT count(*) FROM execution_evidence", [], |r| r.get(0))
.unwrap(),
0
);
db.execute_batch("DROP TRIGGER refuse_start").unwrap();
ledger::begin_execution(&mut db, &permit, &request, Uuid::from_u128(9), now).unwrap();
assert!(ledger::begin_execution(&mut db, &permit, &request, Uuid::from_u128(9), now).is_err());
assert_eq!(
db.query_row::<u32, _, _>("SELECT count(*) FROM consumed", [], |r| r.get(0))
.unwrap(),
1
);
}
#[test]
fn completion_cas_preserves_original_bytes_and_recovers_only_verified_bound_evidence() {
let (binding, request, permit, now) = fixture();
let mut db = Connection::open_in_memory().unwrap();
ledger::initialize_ledger(&db).unwrap();
ledger::begin_execution(&mut db, &permit, &request, Uuid::from_u128(9), now).unwrap();
let offer = JobOffer {
job_id: permit.job_id.to_string(),
attempt_id: permit.attempt_id.to_string(),
payload_bytes: request.job_bytes.clone(),
job_payload_hash: permit.job_payload_hash.clone(),
plan_hash: permit.plan_hash.clone(),
authorization_id: permit.authorization_id.to_string(),
};
assert!(
jobs::recover_interrupted_outcome(&db, &binding, &offer, &permit.grant_id.to_string())
.unwrap()
.is_none()
);
let mut original = Outcome::unknown("");
original.state = "succeeded".into();
original.stdout = b"Hello\n".to_vec();
original.exit_code = Some(0);
original.evidence = serde_json::json!({"postconditions_passed":true});
ledger::persist_outcome(&db, &permit, &original).unwrap();
let saved: Vec<u8> = db
.query_row("SELECT outcome FROM execution_evidence", [], |r| r.get(0))
.unwrap();
ledger::persist_outcome(&db, &permit, &original).unwrap();
assert_eq!(
saved,
db.query_row::<Vec<u8>, _, _>("SELECT outcome FROM execution_evidence", [], |r| r.get(0))
.unwrap()
);
assert_eq!(
db.query_row::<u32, _, _>(
"SELECT count(*) FROM consumed WHERE result IS NULL",
[],
|r| r.get(0)
)
.unwrap(),
1
);
assert!(ledger::persist_outcome(&db, &permit, &Outcome::unknown("late uncertainty")).is_err());
assert!(ledger::finish(&db, &permit, &Outcome::unknown("late uncertainty")).is_err());
let recovered =
jobs::recover_interrupted_outcome(&db, &binding, &offer, &permit.grant_id.to_string())
.unwrap()
.unwrap();
assert_eq!(serde_json::to_vec(&recovered).unwrap(), saved);
let mut forged = binding.clone();
forged.public_key_hex =
hex::encode(SigningKey::from_bytes(&[31; 32]).verifying_key().as_bytes());
assert!(
jobs::recover_interrupted_outcome(&db, &forged, &offer, &permit.grant_id.to_string())
.is_err()
);
let mut changed = offer.clone();
changed.authorization_id = Uuid::new_v4().to_string();
assert!(
jobs::recover_interrupted_outcome(&db, &binding, &changed, &permit.grant_id.to_string())
.is_err()
);
let mut changed = permit.clone();
changed.assignment_version += 1;
assert!(ledger::persist_outcome(&db, &changed, &original).is_err());
ledger::finish(&db, &permit, &original).unwrap();
ledger::finish(&db, &permit, &original).unwrap();
assert_eq!(
db.query_row::<u32, _, _>("SELECT count(*) FROM consumed", [], |r| r.get(0))
.unwrap(),
1
);
assert!(ledger::consume(&mut db, &permit).is_err());
let mut corrupted: serde_json::Value = db
.query_row("SELECT start FROM execution_evidence", [], |r| {
r.get::<_, Vec<u8>>(0)
})
.map(|b| serde_json::from_slice(&b).unwrap())
.unwrap();
let changed = corrupted["request"]["signature"][0].as_u64().unwrap() ^ 1;
corrupted["request"]["signature"][0] = serde_json::json!(changed);
db.execute(
"UPDATE execution_evidence SET start=?1",
[serde_json::to_vec(&corrupted).unwrap()],
)
.unwrap();
assert!(
jobs::recover_interrupted_outcome(&db, &binding, &offer, &permit.grant_id.to_string())
.is_err()
);
}
+231
View File
@@ -1232,3 +1232,234 @@ fn system_helper_import_requires_explicit_system_identity_and_never_root_alias()
let changed = c.with_helper_identity(HelperIdentity::Root); let changed = c.with_helper_identity(HelperIdentity::Root);
assert!(!changed.can_start(&f.channel, true, &f.clock)); assert!(!changed.can_start(&f.channel, true, &f.clock));
} }
fn persist_original_fixture_result(
f: &mut Fixture,
offer: &JobOffer,
grant: &ExecutionPermitPayload,
outcome: rmm_agent_core::auth::Outcome,
) -> Envelope {
let tx = f.db.transaction().unwrap();
let revision =
rmm_agent_core::jobs::transition(&tx, offer, &outcome.state, &grant.grant_id.to_string())
.unwrap();
let sequence: i64 = tx
.query_row(
"UPDATE counter SET seq=seq+1 WHERE id=1 RETURNING seq",
[],
|r| r.get(0),
)
.unwrap();
let envelope = Envelope {
protocol_major: 1,
protocol_minor: 0,
message_id: Uuid::new_v4().to_string(),
agent_id: f.binding.agent_id.to_string(),
enrollment_generation: f.binding.enrollment_generation,
connection_generation: f.channel.connection_generation,
boot_id: f.channel.boot_id.to_string(),
sequence: sequence.try_into().unwrap(),
observed_at: f.clock.now.timestamp_millis(),
payload: Some(Payload::JobResult(rmm_agent_core::jobs::result(
offer,
revision,
&grant.grant_id.to_string(),
outcome,
))),
};
rmm_agent_core::jobs::event(&tx, &envelope).unwrap();
tx.commit().unwrap();
envelope
}
fn completion_outcome() -> rmm_agent_core::auth::Outcome {
serde_json::from_slice(&canonical_outcome_bytes(&success()).unwrap()).unwrap()
}
#[test]
fn crash_after_durable_outcome_before_result_recovers_original_then_signed_sync_closes() {
let mut f = Fixture::new();
let (offer, grant, _) = f.add("running", true, None, script());
let grant = grant.unwrap();
rmm_agent_core::ledger::persist_outcome(&f.ledger, &grant, &completion_outcome()).unwrap();
let interrupted = rmm_agent_core::jobs::interrupted(&f.db, &f.ledger, &f.binding).unwrap();
assert_eq!(interrupted.len(), 1);
let original = rmm_agent_core::jobs::recover_interrupted_outcome(
&f.ledger,
&f.binding,
&offer,
&interrupted[0].1,
)
.unwrap()
.unwrap();
let envelope = persist_original_fixture_result(&mut f, &offer, &grant, original);
assert_eq!(
f.ledger
.query_row::<u32, _, _>(
"SELECT count(*) FROM consumed WHERE result IS NULL",
[],
|r| r.get(0)
)
.unwrap(),
1
);
let mut client = f.client();
let prepared = f.prepare(&mut client);
let decision = f.decision(&prepared, true);
assert!(decision.attempts[0].unlock);
assert_eq!(
prepared.request.attempts[0].result_message_id,
envelope.message_id
);
f.apply(&mut client, &decision).unwrap();
assert!(!client.can_start(&f.channel, false, &f.clock));
client.apply_consumption(&mut f.ledger, &f.clock).unwrap();
assert!(client.can_start(&f.channel, false, &f.clock));
assert_eq!(
f.ledger
.query_row::<u32, _, _>("SELECT count(*) FROM consumed", [], |r| r.get(0))
.unwrap(),
1
);
assert!(rmm_agent_core::ledger::consume(&mut f.ledger, &grant).is_err());
}
#[test]
fn crash_after_result_commit_before_finish_retains_exact_result_and_local_prior() {
let mut f = Fixture::new();
let (offer, grant, _) = f.add("running", true, None, script());
let grant = grant.unwrap();
rmm_agent_core::ledger::persist_outcome(&f.ledger, &grant, &completion_outcome()).unwrap();
let original = persist_original_fixture_result(&mut f, &offer, &grant, completion_outcome());
assert!(
rmm_agent_core::jobs::interrupted(&f.db, &f.ledger, &f.binding)
.unwrap()
.is_empty()
);
assert_eq!(
rmm_agent_core::jobs::events(&f.db).unwrap(),
vec![original.clone()]
);
let mut client = f.client();
let p = f.prepare(&mut client);
let d = f.decision(&p, true);
f.apply(&mut client, &d).unwrap();
client.apply_consumption(&mut f.ledger, &f.clock).unwrap();
assert!(client.can_start(&f.channel, false, &f.clock));
let archived: Vec<u8> =
f.db.query_row(
"SELECT envelope FROM reconcile_results WHERE id=?1",
[&original.message_id],
|r| r.get(0),
)
.unwrap();
assert_eq!(archived, original.encode_to_vec());
}
#[test]
fn crash_before_running_event_recovers_real_consumption_without_inventing_completion() {
let mut f = Fixture::new();
let (offer, grant, _) = f.add("running", true, None, script());
let grant = grant.unwrap();
f.db.execute("UPDATE job_attempts SET state='requesting',grant_id=''", [])
.unwrap();
let interrupted = rmm_agent_core::jobs::interrupted(&f.db, &f.ledger, &f.binding).unwrap();
assert_eq!(interrupted[0].1, grant.grant_id.to_string());
assert!(
rmm_agent_core::jobs::recover_interrupted_outcome(
&f.ledger,
&f.binding,
&offer,
&interrupted[0].1
)
.unwrap()
.is_none()
);
persist_original_fixture_result(
&mut f,
&offer,
&grant,
rmm_agent_core::auth::Outcome::unknown("AGENT_PROCESS_INTERRUPTED"),
);
let mut c = f.client();
let p = f.prepare(&mut c);
let d = f.decision(&p, false);
assert!(!d.attempts[0].unlock);
f.apply(&mut c, &d).unwrap();
assert!(!c.can_start(&f.channel, false, &f.clock));
assert_eq!(
f.ledger
.query_row::<u32, _, _>(
"SELECT count(*) FROM consumed WHERE result IS NULL",
[],
|r| r.get(0)
)
.unwrap(),
1
);
let missing: Option<Vec<u8>> = f
.ledger
.query_row("SELECT outcome FROM execution_evidence", [], |r| r.get(0))
.unwrap();
assert!(missing.is_none());
}
#[test]
fn signed_unlock_still_rejects_a_missing_local_outcome_in_legacy_crash_window() {
let mut f = Fixture::new();
let (_, grant, _) = f.add("succeeded", true, Some(success()), script());
let grant = grant.unwrap();
f.ledger
.execute("UPDATE execution_evidence SET outcome=NULL", [])
.unwrap();
let mut c = f.client();
let p = f.prepare(&mut c);
let d = f.decision(&p, true);
assert!(d.attempts[0].unlock);
f.apply(&mut c, &d).unwrap();
assert!(c.apply_consumption(&mut f.ledger, &f.clock).is_err());
assert!(!c.can_start(&f.channel, false, &f.clock));
assert!(rmm_agent_core::ledger::consume(&mut f.ledger, &grant).is_err());
}
#[test]
fn original_completion_after_reconnect_unknown_is_recovered_without_reexecuting() {
let mut f = Fixture::new();
let (offer, grant, _) = f.add("running", true, None, script());
let grant = grant.unwrap();
let mut previous = f.client();
let previous_request = f.prepare(&mut previous);
assert_eq!(previous_request.request.attempts[0].state, "unknown");
assert!(
rmm_agent_core::jobs::interrupted(&f.db, &f.ledger, &f.binding)
.unwrap()
.is_empty()
);
// The already-running executor completes after the transport fenced it.
rmm_agent_core::ledger::persist_outcome(&f.ledger, &grant, &completion_outcome()).unwrap();
drop(previous);
let interrupted = rmm_agent_core::jobs::interrupted(&f.db, &f.ledger, &f.binding).unwrap();
assert_eq!(interrupted.len(), 1);
let saved = rmm_agent_core::jobs::recover_interrupted_outcome(
&f.ledger,
&f.binding,
&offer,
&interrupted[0].1,
)
.unwrap()
.unwrap();
let original = persist_original_fixture_result(&mut f, &offer, &grant, saved);
let mut process = f.client();
let p = f.prepare(&mut process);
let d = f.decision(&p, true);
assert_eq!(p.request.attempts[0].result_message_id, original.message_id);
f.apply(&mut process, &d).unwrap();
process.apply_consumption(&mut f.ledger, &f.clock).unwrap();
assert!(process.can_start(&f.channel, false, &f.clock));
assert_eq!(
f.ledger
.query_row::<u32, _, _>("SELECT count(*) FROM consumed", [], |r| r.get(0))
.unwrap(),
1
);
assert!(
rmm_agent_core::jobs::interrupted(&f.db, &f.ledger, &f.binding)
.unwrap()
.is_empty()
);
}
+1 -1
View File
@@ -59,7 +59,7 @@ fn supported_as(job: &JobPayload, uid: u32, helper_configured: bool) -> bool {
} }
pub use rmm_agent_core::jobs::{ pub use rmm_agent_core::jobs::{
ack, event, events, interrupted, interrupted_request, next, no_start, permit_request, ack, event, events, interrupted, interrupted_request, next, no_start, permit_request,
requesting, reserve_request, result, transition, recover_interrupted_outcome, requesting, reserve_request, result, transition,
}; };
pub fn accept(db: &Connection, binding: &Binding, offer: &JobOffer) -> Result<bool> { pub fn accept(db: &Connection, binding: &Binding, offer: &JobOffer) -> Result<bool> {
rmm_agent_core::jobs::accept(db, binding, offer, |job| { rmm_agent_core::jobs::accept(db, binding, offer, |job| {
+11 -7
View File
@@ -212,10 +212,10 @@ impl<C: reconcile::SyncClock> Agent<C> {
/// New process only. Persist honest uncertainty before any helper snapshot /// New process only. Persist honest uncertainty before any helper snapshot
/// can block; the ordinary first-channel replay publishes it before Sync. /// can block; the ordinary first-channel replay publishes it before Sync.
fn recover_interrupted(&mut self) -> Result<()> { fn recover_interrupted(&mut self) -> Result<()> {
let Some(binding) = &self.binding else { let Some(binding) = self.binding.clone() else {
return Ok(()); return Ok(());
}; };
let interrupted = jobs::interrupted(&self.db, &self.ledger, binding)?; let interrupted = jobs::interrupted(&self.db, &self.ledger, &binding)?;
for (offer, grant) in interrupted { for (offer, grant) in interrupted {
if grant.is_empty() { if grant.is_empty() {
jobs::interrupted_request(&self.db, &offer)?; jobs::interrupted_request(&self.db, &offer)?;
@@ -224,7 +224,10 @@ impl<C: reconcile::SyncClock> Agent<C> {
0, 0,
&offer, &offer,
&grant, &grant,
rmm_privileged_helper::Outcome::unknown("AGENT_PROCESS_INTERRUPTED"), jobs::recover_interrupted_outcome(&self.ledger, &binding, &offer, &grant)?
.unwrap_or_else(|| {
rmm_privileged_helper::Outcome::unknown("AGENT_PROCESS_INTERRUPTED")
}),
)?; )?;
} }
} }
@@ -286,8 +289,7 @@ impl<C: reconcile::SyncClock> Agent<C> {
jobs::supported_with_binding(&job, Some(&binding)), jobs::supported_with_binding(&job, Some(&binding)),
"UNSUPPORTED_CAPABILITY" "UNSUPPORTED_CAPABILITY"
); );
rmm_privileged_helper::consume(&mut self.ledger, &grant)?; rmm_privileged_helper::begin_execution(&mut self.ledger, &grant, &request)?;
rmm_privileged_helper::save_start(&self.ledger, &grant, &request)?;
let cancelled: bool = self.db.query_row( let cancelled: bool = self.db.query_row(
"SELECT cancel_requested FROM job_attempts WHERE job=?1 AND attempt=?2", "SELECT cancel_requested FROM job_attempts WHERE job=?1 AND attempt=?2",
rusqlite::params![offer.job_id, offer.attempt_id], rusqlite::params![offer.job_id, offer.attempt_id],
@@ -295,6 +297,7 @@ impl<C: reconcile::SyncClock> Agent<C> {
)?; )?;
if cancelled { if cancelled {
let outcome = jobs::no_start("cancelled", "CANCELLED_BEFORE_EFFECT"); let outcome = jobs::no_start("cancelled", "CANCELLED_BEFORE_EFFECT");
rmm_privileged_helper::persist_outcome(&self.ledger, &grant, &outcome)?;
self.record( self.record(
generation, generation,
&offer, &offer,
@@ -546,10 +549,11 @@ impl<C: reconcile::SyncClock> Agent<C> {
} }
} }
Some((offer, grant, outcome)) = self.completed_rx.recv() => { Some((offer, grant, outcome)) = self.completed_rx.recv() => {
// Persist the wire result before releasing a consumption lock. // First preserve the original completion without unlocking.
// A crash in between is fail-closed, not a second execution. // A startup can replay it if the journal transaction is lost.
let state = outcome.state.clone(); let state = outcome.state.clone();
let refresh_capabilities=state=="succeeded" && serde_json::from_slice::<rmm_domain::jobs::JobPayload>(&offer.payload_bytes)?.action.name()=="apt_native_acceptance"; let refresh_capabilities=state=="succeeded" && serde_json::from_slice::<rmm_domain::jobs::JobPayload>(&offer.payload_bytes)?.action.name()=="apt_native_acceptance";
rmm_privileged_helper::persist_outcome(&self.ledger,&grant,&outcome)?;
let serialized = serde_json::to_vec(&outcome)?; let serialized = serde_json::to_vec(&outcome)?;
self.record(generation, &offer, &grant.grant_id.to_string(), outcome)?; self.record(generation, &offer, &grant.grant_id.to_string(), outcome)?;
let outcome: rmm_privileged_helper::Outcome = serde_json::from_slice(&serialized)?; let outcome: rmm_privileged_helper::Outcome = serde_json::from_slice(&serialized)?;
+11 -1
View File
@@ -78,7 +78,7 @@ pub fn lock_state(dir: &Path, uid: u32) -> Result<fs::File> {
f.try_lock_exclusive()?; f.try_lock_exclusive()?;
Ok(f) Ok(f)
} }
pub use rmm_agent_core::ledger::{bounded_journal_capacity, consume, finish}; pub use rmm_agent_core::ledger::{bounded_journal_capacity, consume, finish, persist_outcome};
pub fn open_ledger(dir: &Path, uid: u32) -> Result<rusqlite::Connection> { pub fn open_ledger(dir: &Path, uid: u32) -> Result<rusqlite::Connection> {
use std::os::unix::fs::OpenOptionsExt; use std::os::unix::fs::OpenOptionsExt;
@@ -98,6 +98,16 @@ pub fn open_ledger(dir: &Path, uid: u32) -> Result<rusqlite::Connection> {
fs::File::open(dir)?.sync_all()?; fs::File::open(dir)?.sync_all()?;
Ok(db) Ok(db)
} }
/// Atomically reserve and persist the exact original signed request before effect.
pub fn begin_execution(
db: &mut rusqlite::Connection,
permit: &ExecutionPermitPayload,
request: &Request,
) -> Result<()> {
let recorded_at = Utc::now();
let boot = Uuid::parse_str(&rmm_agent_linux::boot_id()?)?;
rmm_agent_core::ledger::begin_execution(db, permit, request, boot, recorded_at)
}
/// Persist the same exact request/boot/time evidence through the shared ledger. /// Persist the same exact request/boot/time evidence through the shared ledger.
pub fn save_start( pub fn save_start(
db: &rusqlite::Connection, db: &rusqlite::Connection,
+2 -4
View File
@@ -1,8 +1,7 @@
use anyhow::{Result, ensure}; use anyhow::{Result, ensure};
use rmm_domain::jobs::Action; use rmm_domain::jobs::Action;
use rmm_privileged_helper::{ use rmm_privileged_helper::{
Binding, Outcome, Request, consume, control, finish, lock_state, open_ledger, private_path, Binding, Outcome, Request, control, finish, lock_state, open_ledger, private_path, reconcile,
reconcile,
}; };
use serde::Deserialize; use serde::Deserialize;
use std::{ use std::{
@@ -442,8 +441,7 @@ fn handle(
if let Some(apt) = &apt { if let Some(apt) = &apt {
apt.verify_retry_history(db)?; apt.verify_retry_history(db)?;
} }
consume(db, &permit)?; rmm_privileged_helper::begin_execution(db, &permit, &request)?;
rmm_privileged_helper::save_start(db, &permit, &request)?;
let mut outcome = let mut outcome =
if !clock.trusted() || config.binding.verify(&request, chrono::Utc::now()).is_err() { if !clock.trusted() || config.binding.verify(&request, chrono::Utc::now()).is_err() {
Outcome { Outcome {
+14 -5
View File
@@ -237,7 +237,7 @@ fn reopen_consumption_duplicate_grant_attempt_unknown_and_resource_lock() {
let lock = lock_state(&path, uid).unwrap(); let lock = lock_state(&path, uid).unwrap();
assert!(lock_state(&path, uid).is_err()); assert!(lock_state(&path, uid).is_err());
let mut db = open_ledger(&path, uid).unwrap(); let mut db = open_ledger(&path, uid).unwrap();
consume(&mut db, &permit).unwrap(); begin_execution(&mut db, &permit, &request).unwrap();
drop(db); drop(db);
let mut db = open_ledger(&path, uid).unwrap(); let mut db = open_ledger(&path, uid).unwrap();
assert!(consume(&mut db, &permit).is_err()); assert!(consume(&mut db, &permit).is_err());
@@ -248,17 +248,26 @@ fn reopen_consumption_duplicate_grant_attempt_unknown_and_resource_lock() {
replacement.job_id = Uuid::new_v4(); replacement.job_id = Uuid::new_v4();
replacement.attempt_id = Uuid::new_v4(); replacement.attempt_id = Uuid::new_v4();
assert!(consume(&mut db, &replacement).is_err()); assert!(consume(&mut db, &replacement).is_err());
// Only definitive evidence releases the resource, not an ACK or new grant. // A contradictory completion cannot overwrite original unknown evidence.
let mut definitive = Outcome::unknown(""); let mut definitive = Outcome::unknown("");
definitive.state = "succeeded".into(); definitive.state = "succeeded".into();
finish(&db, &permit, &definitive).unwrap(); assert!(finish(&db, &permit, &definitive).is_err());
assert!(consume(&mut db, &permit).is_err()); assert!(consume(&mut db, &permit).is_err());
replacement.job_id = permit.job_id; replacement.job_id = permit.job_id;
replacement.attempt_id = permit.attempt_id; replacement.attempt_id = permit.attempt_id;
assert!(consume(&mut db, &replacement).is_err()); assert!(consume(&mut db, &replacement).is_err());
replacement.job_id = Uuid::new_v4(); replacement.job_id = Uuid::new_v4();
replacement.attempt_id = Uuid::new_v4(); replacement.attempt_id = Uuid::new_v4();
consume(&mut db, &replacement).unwrap(); assert!(consume(&mut db, &replacement).is_err());
assert_eq!(
db.query_row::<u32, _, _>(
"SELECT count(*) FROM consumed WHERE result IS NULL",
[],
|r| r.get(0)
)
.unwrap(),
1
);
drop(db); drop(db);
drop(lock); drop(lock);
fs::remove_dir_all(path).unwrap(); fs::remove_dir_all(path).unwrap();
@@ -327,7 +336,7 @@ fn two_helper_connections_share_exact_lock_and_sqlite_consumption() {
); );
let mut general = open_ledger(&path, uid).unwrap(); let mut general = open_ledger(&path, uid).unwrap();
let mut apt = open_ledger(&path, uid).unwrap(); let mut apt = open_ledger(&path, uid).unwrap();
consume(&mut general, &permit).unwrap(); begin_execution(&mut general, &permit, &request).unwrap();
assert!(consume(&mut apt, &permit).is_err()); assert!(consume(&mut apt, &permit).is_err());
let mut other = permit.clone(); let mut other = permit.clone();
other.grant_id = Uuid::new_v4(); other.grant_id = Uuid::new_v4();
+26
View File
@@ -1,5 +1,9 @@
# Native gemeinsame Core-Unitabnahme # Native gemeinsame Core-Unitabnahme
**Persistenzprofil tatsächlich ausgeführt, 2026-11-14:**
Fall `08a9be72-dd7c-46b7-a2c6-7d17424533c2`, Linux76 vor Windows54, ohne Skip.
Getrennte eigene SQLite-/Signaturfixturen, keine native Job-/Dienstabnahme.
**Helper-Sync-Profil tatsächlich ausgeführt, 2026-11-14:** **Helper-Sync-Profil tatsächlich ausgeführt, 2026-11-14:**
Fall `5704073c-a135-431c-aa84-fedc68a3de0b`, Linux 69/69 vor Windows 47/47, Fall `5704073c-a135-431c-aa84-fedc68a3de0b`, Linux 69/69 vor Windows 47/47,
keine Skips oder RMM-Wirkung. Auch dies ersetzt keine Windows-SYSTEM-Dienstprobe. keine Skips oder RMM-Wirkung. Auch dies ersetzt keine Windows-SYSTEM-Dienstprobe.
@@ -72,3 +76,25 @@ python3 deploy/shared_core_acceptance.py finish-windows --profile helper-sync-v1
Profil, Quellen und Artefakte sind an den privaten create-only Intent gebunden. Profil, Quellen und Artefakte sind an den privaten create-only Intent gebunden.
Es gibt weiterhin keinen frei wählbaren Programmpfad oder Argumentvektor. Es gibt weiterhin keinen frei wählbaren Programmpfad oder Argumentvektor.
## Persistenzkorrektur `durable-outcome-v1`
Neue unveränderliche Qualifikation unter `devstate/*core/durable-outcome-v1/`.
Das feste Profil erwartet Linux **7+26+22+21=76**, danach Windows **6+26+22=54**.
Lokale Regressionen und Cross-Builds sind im Manifest separat von der noch
geplanten tatsächlichen VM-Ausführung ausgewiesen. Kein früherer Nachweis wird
umgeschrieben. Vorläufige verworfene Builds sind ausdrücklich unqualifiziert.
```sh
# GEPLANT, NICHT AUSGEFÜHRT: tatsächliche VM-Ausführung durch Parent.
python3 deploy/shared_core_acceptance.py linux --profile durable-outcome-v1
python3 deploy/shared_core_acceptance.py windows --profile durable-outcome-v1 --case-id <UUID>
```
Die gezielten Fälle prüfen atomaren Verbrauch+Startzeugen, Original-Outcome-CAS,
Crash vor/nach Resultcommit, Reconnect-Unknown mit späterer Originalcompletion
und die weiterhin verweigerte Freigabe bei fehlendem lokalen Outcome.
Startup journalisiert ausschließlich bereits gebundene gespeicherte Belege neu;
Unknown ohne solchen Beleg bleibt gesperrt. Server-/Unlockregeln bleiben strikt.
Dies simuliert Commitgrenzen mit eigenen Fixtures; es ersetzt keinen späteren
wirklichen Agentprozessabsturz oder unabhängigen SYSTEM-Helperabschlussnachweis.
+6 -5
View File
@@ -26,6 +26,7 @@ STATE = ROOT / 'devstate/shared-core/acceptance'
PROFILES = { PROFILES = {
'original': {'linux': {'contracts':5, 'reconcile':20}, 'windows': {'contracts':4, 'reconcile':20}}, 'original': {'linux': {'contracts':5, 'reconcile':20}, 'windows': {'contracts':4, 'reconcile':20}},
'helper-sync-v1': {'linux': {'contracts':5, 'reconcile':21, 'helper-reconcile':22, 'linux-helper':21}, 'windows': {'contracts':4, 'reconcile':21, 'helper-reconcile':22}}, 'helper-sync-v1': {'linux': {'contracts':5, 'reconcile':21, 'helper-reconcile':22, 'linux-helper':21}, 'windows': {'contracts':4, 'reconcile':21, 'helper-reconcile':22}},
'durable-outcome-v1': {'linux': {'contracts':7, 'reconcile':26, 'helper-reconcile':22, 'linux-helper':21}, 'windows': {'contracts':6, 'reconcile':26, 'helper-reconcile':22}},
} }
KINDS = ('contracts', 'reconcile') # Historical original qualification only. KINDS = ('contracts', 'reconcile') # Historical original qualification only.
REMOTE_LINUX = '/var/lib/rmm-shared-core-acceptance' REMOTE_LINUX = '/var/lib/rmm-shared-core-acceptance'
@@ -44,11 +45,11 @@ def source_paths(profile):
contract.require(profile in PROFILES, 'fixed qualification profile') contract.require(profile in PROFILES, 'fixed qualification profile')
sources = [ROOT/'Cargo.toml', ROOT/'Cargo.lock', ROOT/'rust-toolchain.toml'] sources = [ROOT/'Cargo.toml', ROOT/'Cargo.lock', ROOT/'rust-toolchain.toml']
crates = ['agent-core', 'domain', 'protocol'] crates = ['agent-core', 'domain', 'protocol']
if profile == 'helper-sync-v1': crates.extend(('agent', 'agent-linux', 'privileged-helper')) if profile in ('helper-sync-v1','durable-outcome-v1'): crates.extend(('agent', 'agent-linux', 'privileged-helper'))
for name in crates: for name in crates:
sources.extend(p for p in (ROOT/'crates'/name).rglob('*') if p.is_file() and (p.suffix == '.rs' or p.name == 'Cargo.toml')) sources.extend(p for p in (ROOT/'crates'/name).rglob('*') if p.is_file() and (p.suffix == '.rs' or p.name == 'Cargo.toml'))
sources.extend((ROOT/'proto').glob('*.proto')) sources.extend((ROOT/'proto').glob('*.proto'))
if profile == 'helper-sync-v1': if profile in ('helper-sync-v1','durable-outcome-v1'):
sources.extend(ROOT/p for p in ('tools/apt-transaction/apt_transaction.py', 'tools/apt-transaction/hook', 'deploy/linux/rmm-apt-helper.service', 'tests/apt_transaction/fixtures/planning-canonical.json')) sources.extend(ROOT/p for p in ('tools/apt-transaction/apt_transaction.py', 'tools/apt-transaction/hook', 'deploy/linux/rmm-apt-helper.service', 'tests/apt_transaction/fixtures/planning-canonical.json'))
return sources return sources
@@ -83,7 +84,7 @@ def linux_case(payload):
require(ident == payload['id'] and payload['action'] in ('prepare', 'run', 'read'), 'fixed case') require(ident == payload['id'] and payload['action'] in ('prepare', 'run', 'read'), 'fixed case')
entries = payload['artifacts'] entries = payload['artifacts']
profile=payload.get('profile','original') profile=payload.get('profile','original')
profiles={'original':{'contracts':5,'reconcile':20},'helper-sync-v1':{'contracts':5,'reconcile':21,'helper-reconcile':22,'linux-helper':21}} profiles={'original':{'contracts':5,'reconcile':20},'helper-sync-v1':{'contracts':5,'reconcile':21,'helper-reconcile':22,'linux-helper':21},'durable-outcome-v1':{'contracts':7,'reconcile':26,'helper-reconcile':22,'linux-helper':21}}
require(profile in profiles and set(entries)==set(profiles[profile]), 'fixed qualification artifacts') require(profile in profiles and set(entries)==set(profiles[profile]), 'fixed qualification artifacts')
for kind, item in entries.items(): for kind, item in entries.items():
require(len(item['binary_sha256']) == 64 and all(c in '0123456789abcdef' for c in item['binary_sha256']), 'fixed hash') require(len(item['binary_sha256']) == 64 and all(c in '0123456789abcdef' for c in item['binary_sha256']), 'fixed hash')
@@ -141,8 +142,8 @@ WINDOWS = r'''
$ErrorActionPreference='Stop' $ErrorActionPreference='Stop'
$p=([Console]::In.ReadLine() | ConvertFrom-Json) $p=([Console]::In.ReadLine() | ConvertFrom-Json)
if (!$p.profile) {$p | Add-Member -NotePropertyName profile -NotePropertyValue 'original'} if (!$p.profile) {$p | Add-Member -NotePropertyName profile -NotePropertyValue 'original'}
$kinds=@('contracts','reconcile');if ($p.profile -eq 'helper-sync-v1') {$kinds+=@('helper-reconcile')} $kinds=@('contracts','reconcile');if ($p.profile -in @('helper-sync-v1','durable-outcome-v1')) {$kinds+=@('helper-reconcile')}
if ($p.profile -notin @('original','helper-sync-v1')) {throw 'Fixed qualification profile'} if ($p.profile -notin @('original','helper-sync-v1','durable-outcome-v1')) {throw 'Fixed qualification profile'}
if ([string]([guid]$p.id) -cne $p.id -or $p.kind -notin $kinds -or $p.action -notin @('run','read') -or $p.sha256 -notmatch '^[0-9a-f]{64}$' -or $p.linux_evidence_sha256 -notmatch '^[0-9a-f]{64}$') {throw 'Fixed native core case'} if ([string]([guid]$p.id) -cne $p.id -or $p.kind -notin $kinds -or $p.action -notin @('run','read') -or $p.sha256 -notmatch '^[0-9a-f]{64}$' -or $p.linux_evidence_sha256 -notmatch '^[0-9a-f]{64}$') {throw 'Fixed native core case'}
$root='C:\ProgramData\RustDiscoveryBootstrap' $root='C:\ProgramData\RustDiscoveryBootstrap'
$case=Join-Path $root ('shared-core-'+$p.id) $case=Join-Path $root ('shared-core-'+$p.id)
+7
View File
@@ -76,6 +76,13 @@ Rootpolicy und deaktivierte Faults erhalten. Passiver Windowsclient hat nach
Hello ein Legacy-Readyflag, weiterhin keinen signierten Sync-/Executornachweis. Hello ein Legacy-Readyflag, weiterhin keinen signierten Sync-/Executornachweis.
Windows-PowerShell-Plan ohne Fähigkeiten tatsächlich verweigert. Windows-PowerShell-Plan ohne Fähigkeiten tatsächlich verweigert.
Gemeinsamer Persistenzfix anschließend nativ qualifiziert: atomarer Start,
Outcome-CAS vor Result und Startup-Recovery nur aus vollständig gebundenen
Originalbelegen. Fall `08a9be72-dd7c-46b7-a2c6-7d17424533c2`, zuerst Linux76,
danach Windows54, keine Skips oder RMM-Wirkung. Fehlender Outcome bleibt Unknown;
keine abgeschwächte signierte Freigabe. Die noch laufenden Dienste sind dadurch
nicht automatisch als aktualisiert nachgewiesen.
Der bestehende Windows-11-LocalService bleibt passiv: gleiche Geräteidentität, Der bestehende Windows-11-LocalService bleibt passiv: gleiche Geräteidentität,
Telemetriehistorie und Schlüssel; keine Jobs, Outbox oder Startgrants. Native Telemetriehistorie und Schlüssel; keine Jobs, Outbox oder Startgrants. Native
WSS-/Inventar-/Tenantnachweise und sieben Rusttests liegen vor. Explizites HTTPS WSS-/Inventar-/Tenantnachweise und sieben Rusttests liegen vor. Explizites HTTPS
+21
View File
@@ -1,5 +1,26 @@
# Tatsächlicher Implementierungsstand # Tatsächlicher Implementierungsstand
## Dauerhafte Outcomes und atomarer Start nativ geprüft — 2026-11-14
Beim Portieren wurde eine bestehende Verfügbarkeitslücke gefunden: Ein Crash
zwischen dauerhaftem JobResult und Ledgerabschluss konnte den Verbrauch ohne
lokalen Outcome gesperrt lassen. Jetzt werden Verbrauch und Startzeuge atomar
gespeichert; der gebundene Outcome wird ohne Unlock vor der Result-Transaktion
persistiert. Erst danach darf der Verbrauch abgeschlossen werden. Startup
rekonstruiert ausschließlich vollständig historisch verifizierte Original-
Outcomes; ohne solchen Beleg bleibt `unknown` gesperrt. Konflikte überschreiben
keine vorhandenen Ergebnisse, und Server-/Sync-Unlockprüfungen bleiben streng.
Lokal 181 betroffene Tests sowie Linux-/Windows-Clippy bestanden. Im eigenen
Fall `08a9be72-dd7c-46b7-a2c6-7d17424533c2` danach zuerst 76 Linux- und
anschließend 54 Windows-Fixturen nativ ohne Skip bestanden. Geprüft wurden
beide Crashfenster, ein noch nicht journalisierter Grant, später gespeicherter
Outcome nach Unknown sowie verweigerte Manipulationen und atomarer Rollback.
Eigene Testdaten, kein tatsächlicher Jobabbruch oder neuer RMM-Job.
Private Profile/Artefakte: `devstate/{shared-core,windows-core}/durable-outcome-v1/`;
Rohbelege unter `devstate/shared-core/acceptance/<Fall>/`. Native Dienstintegration
und Windows-Ausführung bleiben separat offen.
## Windows-Plattformverträge auf endgültigem Server bereitgestellt — 2026-11-14 ## Windows-Plattformverträge auf endgültigem Server bereitgestellt — 2026-11-14
Servercandidate `9058f6a3-0832-400f-ba93-b3fb94faaba0` wurde ausschließlich aus Servercandidate `9058f6a3-0832-400f-ba93-b3fb94faaba0` wurde ausschließlich aus