Implement guarded Linux updater runtime and compatible baseline tooling
Rust development slice / linux (push) Failing after 8s

This commit is contained in:
2026-11-16 15:25:46 +01:00
parent 6497c79a91
commit 96a2b6e5ae
44 changed files with 6986 additions and 1024 deletions
+104
View File
@@ -118,3 +118,107 @@ impl DurableEffectFence for LedgerFence<'_, '_, '_> {
self.observe(effect, observation_sha256)
}
}
/// Reverse only a completely verified forward pair after the original
/// guarded journal entered known-failure RollbackStopped. A partial rename or
/// lost reply poisons this fence; it never resumes/restores an Unknown.
pub struct RollbackFence<'w, 'a, 's> {
ledger: &'w mut OwnedLedger<'a, 's>,
pending: Option<(Effect, NativeEffectClaim)>,
preserved: Option<Role>,
poisoned: bool,
}
impl<'w, 'a, 's> RollbackFence<'w, 'a, 's> {
pub fn new(ledger: &'w mut OwnedLedger<'a, 's>) -> Result<Self> {
ledger.qualify_for_effects()?;
ensure!(
ledger.journal()?.phase() == Phase::RollbackStopped,
"UPDATE_ROLLBACK_NO_RESUME"
);
Ok(Self {
ledger,
pending: None,
preserved: None,
poisoned: false,
})
}
pub fn finish(self) -> Result<()> {
ensure!(
!self.poisoned
&& self.pending.is_none()
&& self.preserved.is_none()
&& self.ledger.journal()?.phase() == Phase::PredecessorRestored,
"UPDATE_ROLLBACK_FENCE_INCOMPLETE"
);
self.ledger.verify_predecessor_pair()
}
}
impl DurableEffectFence for RollbackFence<'_, '_, '_> {
fn before_effect(&mut self, effect: &Effect) -> Result<()> {
ensure!(
!self.poisoned && self.pending.is_none(),
"UPDATE_ROLLBACK_NO_RETRY"
);
self.poisoned = true;
let native = match *effect {
Effect::SaveRejectedCandidate { role } => {
ensure!(self.preserved.is_none(), "UPDATE_ROLLBACK_SAVE_ORDER");
self.ledger.append_observed(Evidence::RestoreIntent {
role: role.handoff_role(),
})?;
NativeEffect::SaveRejectedCandidate {
role: native_role(role),
}
}
Effect::RestorePredecessor { role } => {
ensure!(
self.preserved == Some(role),
"UPDATE_ROLLBACK_RESTORE_WITHOUT_SAVE"
);
NativeEffect::RestorePredecessor {
role: native_role(role),
}
}
_ => anyhow::bail!("UPDATE_ROLLBACK_EFFECT_DENIED"),
};
self.pending = Some((effect.clone(), self.ledger.claim_native(&native)?));
Ok(())
}
fn after_effect(&mut self, effect: &Effect, observation: &str) -> Result<()> {
let (expected, claim) = self
.pending
.take()
.ok_or_else(|| anyhow::anyhow!("UPDATE_ROLLBACK_NOT_CLAIMED"))?;
ensure!(
self.poisoned && *effect == expected,
"UPDATE_ROLLBACK_CALLBACK_CHANGED"
);
let (role, preserved) = match *effect {
Effect::SaveRejectedCandidate { role } => (role, true),
Effect::RestorePredecessor { role } => (role, false),
_ => anyhow::bail!("UPDATE_ROLLBACK_EFFECT_DENIED"),
};
ensure!(
self.ledger
.native_observation_sha256(role.handoff_role(), preserved)?
== observation,
"UPDATE_ROLLBACK_OBSERVATION_CHANGED"
);
self.ledger.observe_native(&claim, observation)?;
if preserved {
self.ledger.append_observed(Evidence::CandidatePreserved {
role: role.handoff_role(),
observation_sha256: observation.into(),
})?;
self.preserved = Some(role);
} else {
self.ledger.append_observed(Evidence::PredecessorRestored {
role: role.handoff_role(),
observed_sha256: self.ledger.predecessor_sha256(role.handoff_role())?,
})?;
self.preserved = None;
}
self.poisoned = false;
Ok(())
}
}