//! Concrete durable Save/Publish fence against the ORIGINAL helper ledger. //! One live forward pass; construction cannot resume a partial ReplaceIntent. use crate::ledger::OwnedLedger; use anyhow::{Result, ensure}; use rmm_agent_core::update_handoff::{NativeEffect, NativeEffectClaim, NativeFileRole}; use rmm_updater_handoff::{Evidence, Phase}; use rmm_updater_linux::{DurableEffectFence, Effect, files::Role}; fn native_role(role: Role) -> NativeFileRole { match role { Role::Agent => NativeFileRole::AgentBinary, Role::Helper => NativeFileRole::HelperBinary, Role::FullConfig => NativeFileRole::FullConfig, Role::FullPin => NativeFileRole::FullPin, } } pub struct LedgerFence<'w, 'a, 's> { ledger: &'w mut OwnedLedger<'a, 's>, pending: Option<(Effect, NativeEffectClaim)>, saved: Option, poisoned: bool, } impl<'w, 'a, 's> LedgerFence<'w, 'a, 's> { pub fn new(ledger: &'w mut OwnedLedger<'a, 's>) -> Result { ledger.qualify_for_effects()?; ensure!( ledger.journal()?.phase() == Phase::UpdaterOwnsLedger, "UPDATE_NO_FENCE_RESUME" ); Ok(Self { ledger, pending: None, saved: None, poisoned: false, }) } /// A failed native call must poison/drop this fence. No reentry/retry API. pub fn finish(self) -> Result<()> { ensure!( !self.poisoned && self.pending.is_none() && self.saved.is_none() && self.ledger.journal()?.phase() == Phase::Replaced, "UPDATE_FENCE_INCOMPLETE" ); self.ledger.verify_pair()?; Ok(()) } fn claim(&mut self, effect: &Effect) -> Result<()> { ensure!( !self.poisoned && self.pending.is_none(), "UPDATE_FENCE_REENTRY" ); // Poison BEFORE a fallible commit or OS operation. Only a fully // observed matching callback can return the live pass to idle. self.poisoned = true; let native = match *effect { Effect::SavePredecessor { role } => { ensure!(self.saved.is_none(), "UPDATE_SAVE_ORDER"); self.ledger.append_observed(Evidence::ReplaceIntent { role: role.handoff_role(), })?; NativeEffect::SavePredecessor { role: native_role(role), } } Effect::PublishReplacement { role } => { ensure!(self.saved == Some(role), "UPDATE_PUBLISH_WITHOUT_SAVE"); NativeEffect::PublishReplacement { role: native_role(role), } } _ => anyhow::bail!("UPDATE_OWNED_FENCE_EFFECT_NOT_ALLOWED"), }; let claim = self.ledger.claim_native(&native)?; self.pending = Some((effect.clone(), claim)); Ok(()) } fn observe(&mut self, effect: &Effect, observation: &str) -> Result<()> { let Some((expected, claim)) = self.pending.take() else { anyhow::bail!("UPDATE_EFFECT_NOT_CLAIMED") }; ensure!( self.poisoned && expected == *effect, "UPDATE_EFFECT_CALLBACK_CHANGED" ); let (role, replaced) = match *effect { Effect::SavePredecessor { role } => (role, false), Effect::PublishReplacement { role } => (role, true), _ => anyhow::bail!("UPDATE_OWNED_FENCE_EFFECT_NOT_ALLOWED"), }; ensure!( self.ledger .native_observation_sha256(role.handoff_role(), replaced)? == observation, "UPDATE_NATIVE_OBSERVATION_CHANGED" ); self.ledger.observe_native(&claim, observation)?; if replaced { let observed_sha256 = self.ledger.target_sha256(role.handoff_role())?; self.ledger.append_observed(Evidence::Replaced { role: role.handoff_role(), observed_sha256, })?; self.saved = None; } else { self.saved = Some(role); } self.poisoned = false; Ok(()) } } impl DurableEffectFence for LedgerFence<'_, '_, '_> { fn before_effect(&mut self, effect: &Effect) -> Result<()> { self.claim(effect) } fn after_effect(&mut self, effect: &Effect, observation_sha256: &str) -> Result<()> { 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, poisoned: bool, } impl<'w, 'a, 's> RollbackFence<'w, 'a, 's> { pub fn new(ledger: &'w mut OwnedLedger<'a, 's>) -> Result { 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(()) } }