121 lines
4.4 KiB
Rust
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)
|
|
}
|
|
}
|