Files
rust-discovery/crates/updater-worker/src/fence.rs
T
2026-11-14 23:51:59 +01:00

121 lines
4.4 KiB
Rust

//! 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<Role>,
poisoned: bool,
}
impl<'w, 'a, 's> LedgerFence<'w, 'a, 's> {
pub fn new(ledger: &'w mut OwnedLedger<'a, 's>) -> Result<Self> {
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)
}
}