#![forbid(unsafe_code)]
#![deny(missing_docs)]
use crate::{
commit_engine::{
quiesce_for_rollback, remaining, restore_and_check, safe_inspect, safe_transition_to,
},
CommitEnginePolicy, LifecycleFailure, LifecycleSnapshot, LifecycleState, LifecycleUpdatePolicy,
Ownership, PostInstallCheck, PostInstallCheckError, ServiceManager, ServiceSpec,
TransitionResult,
};
use eggup_core::{
CommitOwnership, PostCommitFailurePolicy, TransactionDisposition, ValidatedTransaction,
};
use std::fmt;
use std::panic::{catch_unwind, AssertUnwindSafe};
use std::path::PathBuf;
use std::time::{Duration, Instant};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum UpdateRuntimeDisposition {
ManagedRunning,
ManagedStopped,
DirectRunning,
Stopped,
ForeignPreserved,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum KnownConfig {
Absent,
Present(PathBuf),
Unknown,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DirectState {
Running,
Stopped,
Unknown,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DirectObservation {
pub state: DirectState,
pub exact_ownership_proven: bool,
pub executable: Option<PathBuf>,
pub config: Option<PathBuf>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct UnixPlannerInput {
pub manager_ownership: Ownership,
pub manager_active: bool,
pub manager_state_known: bool,
pub registered_config: KnownConfig,
pub selected_config: Option<PathBuf>,
pub direct: DirectObservation,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum WindowsServiceState {
Running,
StartPending,
Stopped,
StopPending,
Unknown,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct WindowsPlannerInput {
pub installed: bool,
pub executable_known: bool,
pub ownership: Ownership,
pub state: WindowsServiceState,
}
pub fn plan_unix(
input: &UnixPlannerInput,
) -> Result<UpdateRuntimeDisposition, crate::ServiceError> {
if !input.manager_state_known {
if input.manager_ownership == Ownership::Unknown
&& !input.manager_active
&& input.direct.state == DirectState::Stopped
{
return Ok(UpdateRuntimeDisposition::Stopped);
}
return Err(crate::ServiceError::invalid(
"manager state is transitioning or unknown",
));
}
match input.manager_ownership {
Ownership::Owned => {
if input.manager_active {
Ok(UpdateRuntimeDisposition::ManagedRunning)
} else {
Ok(UpdateRuntimeDisposition::ManagedStopped)
}
}
Ownership::Foreign => {
if input.manager_active {
match &input.registered_config {
KnownConfig::Unknown => Err(crate::ServiceError::invalid(
"registered config is unknown; refusing to infer disposition",
)),
KnownConfig::Absent | KnownConfig::Present(_) => {
let same = match (&input.registered_config, &input.selected_config) {
(KnownConfig::Absent, None) => true,
(KnownConfig::Present(a), Some(b)) => a == b,
_ => false,
};
if same {
Ok(UpdateRuntimeDisposition::ForeignPreserved)
} else {
match input.direct.state {
DirectState::Running if input.direct.exact_ownership_proven => {
Ok(UpdateRuntimeDisposition::DirectRunning)
}
DirectState::Stopped => Ok(UpdateRuntimeDisposition::Stopped),
_ => Err(crate::ServiceError::invalid(
"direct runtime ownership/state unproven",
)),
}
}
}
}
} else {
match input.direct.state {
DirectState::Running if input.direct.exact_ownership_proven => {
Ok(UpdateRuntimeDisposition::DirectRunning)
}
DirectState::Stopped => Ok(UpdateRuntimeDisposition::Stopped),
_ => Err(crate::ServiceError::invalid(
"direct runtime ownership/state unproven",
)),
}
}
}
Ownership::Absent => {
if input.manager_active {
Err(crate::ServiceError::invalid(
"registration absent but manager reports active",
))
} else {
match input.direct.state {
DirectState::Running if input.direct.exact_ownership_proven => {
Ok(UpdateRuntimeDisposition::DirectRunning)
}
DirectState::Stopped => Ok(UpdateRuntimeDisposition::Stopped),
_ => Err(crate::ServiceError::invalid(
"direct runtime ownership/state unproven",
)),
}
}
}
Ownership::Unknown => {
if input.manager_active {
Err(crate::ServiceError::invalid(
"manager ownership unknown while active",
))
} else {
match input.direct.state {
DirectState::Running => Err(crate::ServiceError::invalid(
"manager ownership unknown; refusing direct mutation",
)),
DirectState::Stopped => Ok(UpdateRuntimeDisposition::Stopped),
DirectState::Unknown => Err(crate::ServiceError::invalid(
"manager and direct states unproven",
)),
}
}
}
}
}
pub fn plan_windows(
input: &WindowsPlannerInput,
) -> Result<UpdateRuntimeDisposition, crate::ServiceError> {
if !input.installed {
return Ok(UpdateRuntimeDisposition::Stopped);
}
if !input.executable_known {
return Err(crate::ServiceError::invalid(
"service executable absent or unparseable",
));
}
match input.ownership {
Ownership::Foreign => Ok(UpdateRuntimeDisposition::ForeignPreserved),
Ownership::Owned => match input.state {
WindowsServiceState::Running | WindowsServiceState::StartPending => {
Ok(UpdateRuntimeDisposition::ManagedRunning)
}
WindowsServiceState::Stopped | WindowsServiceState::StopPending => {
Ok(UpdateRuntimeDisposition::ManagedStopped)
}
WindowsServiceState::Unknown => Err(crate::ServiceError::invalid(
"windows service state unknown",
)),
},
Ownership::Absent => Err(crate::ServiceError::invalid(
"windows registration state contradictory",
)),
Ownership::Unknown => Err(crate::ServiceError::invalid("windows ownership unproven")),
}
}
pub trait DirectRuntimeControl: fmt::Debug {
fn inspect(&self) -> Result<DirectObservation, crate::ServiceError>;
fn stop(&mut self, timeout: Duration) -> Result<TransitionResult, crate::ServiceError>;
fn start(&mut self, timeout: Duration) -> Result<TransitionResult, crate::ServiceError>;
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DispositionBaseline {
pub manager_ownership: Ownership,
pub manager_state: LifecycleState,
pub direct: Option<DirectObservation>,
}
#[allow(clippy::too_many_arguments)]
pub fn commit_with_disposition<M, D, C>(
manager: &mut M,
spec: &ServiceSpec,
direct: Option<&mut D>,
transaction: ValidatedTransaction,
ownership: CommitOwnership<'_>,
policy: LifecycleUpdatePolicy,
check: &C,
planned: UpdateRuntimeDisposition,
baseline: &DispositionBaseline,
) -> Result<crate::LifecycleUpdateReceipt, crate::LifecycleUpdateError>
where
M: ServiceManager,
D: DirectRuntimeControl,
C: PostInstallCheck,
{
commit_with_disposition_with_engine_policy(
manager,
spec,
direct,
transaction,
ownership,
policy,
check,
planned,
baseline,
CommitEnginePolicy::default(),
)
}
#[allow(clippy::too_many_arguments)]
pub fn commit_with_disposition_with_engine_policy<M, D, C>(
manager: &mut M,
spec: &ServiceSpec,
direct: Option<&mut D>,
transaction: ValidatedTransaction,
ownership: CommitOwnership<'_>,
policy: LifecycleUpdatePolicy,
check: &C,
planned: UpdateRuntimeDisposition,
baseline: &DispositionBaseline,
engine: CommitEnginePolicy,
) -> Result<crate::LifecycleUpdateReceipt, crate::LifecycleUpdateError>
where
M: ServiceManager,
D: DirectRuntimeControl,
C: PostInstallCheck,
{
use crate::LifecycleUpdatePhase as Phase;
policy.validate()?;
let baseline_ok = match planned {
UpdateRuntimeDisposition::ManagedRunning => {
baseline.manager_ownership == Ownership::Owned
&& baseline.manager_state == LifecycleState::Running
}
UpdateRuntimeDisposition::ManagedStopped => {
baseline.manager_ownership == Ownership::Owned
&& baseline.manager_state == LifecycleState::Stopped
}
UpdateRuntimeDisposition::DirectRunning => matches!(
baseline.direct.as_ref(),
Some(o) if o.state == DirectState::Running && o.exact_ownership_proven
),
UpdateRuntimeDisposition::Stopped => true,
UpdateRuntimeDisposition::ForeignPreserved => matches!(
baseline.manager_ownership,
Ownership::Foreign | Ownership::Absent | Ownership::Unknown
),
};
if !baseline_ok {
return Err(crate::LifecycleUpdateError::Preflight {
failure: LifecycleFailure::new(
spec,
Phase::Inspect,
"planned disposition does not match baseline authority/state",
None,
),
});
}
let fresh_manager = safe_inspect(manager, spec, Phase::Inspect)
.map_err(|f| crate::LifecycleUpdateError::Preflight { failure: f })?;
if fresh_manager.ownership != baseline.manager_ownership
|| fresh_manager.state != baseline.manager_state
{
return Err(crate::LifecycleUpdateError::Preflight {
failure: LifecycleFailure::new(
spec,
Phase::Inspect,
"lifecycle authority/state changed before mutation",
Some(&fresh_manager),
),
});
}
if planned == UpdateRuntimeDisposition::DirectRunning {
let Some(d) = direct.as_ref() else {
return Err(crate::LifecycleUpdateError::Preflight {
failure: LifecycleFailure::new(
spec,
Phase::Inspect,
"direct control required but not provided",
Some(&fresh_manager),
),
});
};
let fresh_direct = match catch_unwind(AssertUnwindSafe(|| (*d).inspect())) {
Ok(Ok(o)) => o,
Ok(Err(e)) => {
return Err(crate::LifecycleUpdateError::Preflight {
failure: LifecycleFailure::new(spec, Phase::Inspect, e, Some(&fresh_manager)),
});
}
Err(_) => {
return Err(crate::LifecycleUpdateError::Preflight {
failure: LifecycleFailure::new(
spec,
Phase::Inspect,
"direct runtime panicked while inspecting",
Some(&fresh_manager),
),
});
}
};
let Some(base_direct) = baseline.direct.as_ref() else {
return Err(crate::LifecycleUpdateError::Preflight {
failure: LifecycleFailure::new(
spec,
Phase::Inspect,
"direct baseline missing for DirectRunning",
Some(&fresh_manager),
),
});
};
if fresh_direct != *base_direct
|| !fresh_direct.exact_ownership_proven
|| fresh_direct.state != DirectState::Running
{
return Err(crate::LifecycleUpdateError::Preflight {
failure: LifecycleFailure::new(
spec,
Phase::Inspect,
"direct runtime identity/state changed before mutation",
Some(&fresh_manager),
),
});
}
}
let before = fresh_manager;
let mut direct_slot: Option<&mut D> = direct;
let mut pre_commit_quiesced = false;
match planned {
UpdateRuntimeDisposition::ManagedRunning => {
let stop_failure = crate::commit_engine::quiesce_service(
manager,
spec,
&before,
policy.quiesce_timeout,
)
.err();
if let Some(f) = stop_failure {
let restore = safe_transition_to(
manager,
spec,
LifecycleState::Running,
policy.rollback_restore_timeout,
Phase::Quiesce,
&engine,
)
.err();
return Err(crate::LifecycleUpdateError::Quiesce {
failure: f,
restore_failure: restore,
});
}
pre_commit_quiesced = true;
commit_manager_path(
manager,
spec,
before,
transaction,
ownership,
policy,
check,
planned,
pre_commit_quiesced,
engine,
)
}
UpdateRuntimeDisposition::DirectRunning => {
let Some(d) = direct_slot.as_mut() else {
return Err(crate::LifecycleUpdateError::Preflight {
failure: LifecycleFailure::new(
spec,
Phase::Inspect,
"direct control required but not provided",
Some(&before),
),
});
};
let stop_result = catch_unwind(AssertUnwindSafe(|| (**d).stop(policy.quiesce_timeout)));
let stop_failure = match stop_result {
Ok(Err(e)) => Some(LifecycleFailure::new(
spec,
Phase::Quiesce,
e,
Some(&before),
)),
Err(_) => Some(LifecycleFailure::new(
spec,
Phase::Quiesce,
"direct runtime panicked while stopping",
Some(&before),
)),
Ok(Ok(r)) if !r.completed => Some(LifecycleFailure::new(
spec,
Phase::Quiesce,
"direct stop did not complete",
Some(&before),
)),
Ok(Ok(_)) => match catch_unwind(AssertUnwindSafe(|| (**d).inspect())) {
Ok(Ok(after))
if after.state == DirectState::Stopped && after.exact_ownership_proven =>
{
pre_commit_quiesced = true;
None
}
Ok(Ok(_)) => Some(LifecycleFailure::new(
spec,
Phase::Quiesce,
"direct runtime state changed after stop",
Some(&before),
)),
Ok(Err(e)) => Some(LifecycleFailure::new(
spec,
Phase::Quiesce,
e,
Some(&before),
)),
Err(_) => Some(LifecycleFailure::new(
spec,
Phase::Quiesce,
"direct runtime panicked while re-observing",
Some(&before),
)),
},
};
if let Some(f) = stop_failure {
if let Some(d2) = direct_slot.as_mut() {
let _ = catch_unwind(AssertUnwindSafe(|| {
let _ = (**d2).start(policy.rollback_restore_timeout);
}));
}
return Err(crate::LifecycleUpdateError::Quiesce {
failure: f,
restore_failure: None,
});
}
commit_direct_path(
manager,
spec,
direct_slot,
before,
transaction,
ownership,
policy,
check,
pre_commit_quiesced,
engine,
)
}
UpdateRuntimeDisposition::ManagedStopped
| UpdateRuntimeDisposition::Stopped
| UpdateRuntimeDisposition::ForeignPreserved => commit_manager_path(
manager,
spec,
before,
transaction,
ownership,
policy,
check,
planned,
pre_commit_quiesced,
engine,
),
}
}
#[allow(clippy::too_many_arguments)]
fn commit_manager_path<M, C>(
manager: &mut M,
spec: &ServiceSpec,
before: LifecycleSnapshot,
transaction: ValidatedTransaction,
ownership: CommitOwnership<'_>,
policy: LifecycleUpdatePolicy,
check: &C,
planned: UpdateRuntimeDisposition,
pre_commit_quiesced: bool,
engine: CommitEnginePolicy,
) -> Result<crate::LifecycleUpdateReceipt, crate::LifecycleUpdateError>
where
M: ServiceManager,
C: PostInstallCheck,
{
use crate::LifecycleUpdatePhase as Phase;
let mut post_commit_failure = None;
let mut rollback_quiesce_failure = None;
let planned_c = planned;
let before_c = before.clone();
let core_result =
transaction.commit_with_post_commit(ownership, policy.post_commit_failure, || {
let deadline = Instant::now() + policy.post_commit_timeout;
let work = catch_unwind(AssertUnwindSafe(|| {
restore_manager_success(
manager,
spec,
&before_c,
planned_c,
policy.restore,
check,
deadline,
&engine,
)
}));
let f = match work {
Ok(Ok(())) => return Ok(()),
Ok(Err(f)) => f,
Err(_) => LifecycleFailure::new(
spec,
Phase::PostInstallCheck,
"post-commit service work panicked",
None,
),
};
post_commit_failure = Some(f.clone());
if policy.post_commit_failure == PostCommitFailurePolicy::RollBack {
rollback_quiesce_failure = match catch_unwind(AssertUnwindSafe(|| {
quiesce_for_rollback(manager, spec, deadline)
})) {
Ok(v) => v,
Err(_) => Some(LifecycleFailure::new(
spec,
Phase::QuiesceForRollback,
"service manager panicked while quiescing before artifact rollback",
None,
)),
};
}
Err(PostInstallCheckError::new(f.detail))
});
let transaction = match core_result {
Ok(r) => r,
Err(core) => {
let restore = if pre_commit_quiesced {
safe_transition_to(
manager,
spec,
before.state,
policy.rollback_restore_timeout,
Phase::RestoreOld,
&engine,
)
.err()
} else {
None
};
return Err(crate::LifecycleUpdateError::CoreBeforeReceipt {
core,
restore_failure: restore,
});
}
};
let mut rollback_restore_failure = None;
let mut restoration = crate::LifecycleRestorationStatus::Restored;
match transaction.disposition() {
TransactionDisposition::Committed => {
if post_commit_failure
.as_ref()
.is_some_and(|f| f.phase == Phase::RestoreNew)
{
restoration = crate::LifecycleRestorationStatus::Failed;
}
}
TransactionDisposition::RolledBack => {
let should_restore = matches!(
planned,
UpdateRuntimeDisposition::ManagedRunning | UpdateRuntimeDisposition::ManagedStopped
);
if should_restore {
if let Err(f) = safe_transition_to(
manager,
spec,
before.state,
policy.rollback_restore_timeout,
Phase::RestoreOld,
&engine,
) {
rollback_restore_failure = Some(f);
restoration = crate::LifecycleRestorationStatus::Failed;
}
}
}
TransactionDisposition::RecoveryRequired => {
restoration = crate::LifecycleRestorationStatus::NotAttemptedRecoveryRequired;
}
}
let final_snapshot = match safe_inspect(manager, spec, Phase::FinalInspect) {
Ok(s) => Some(s),
Err(obs) => {
return Ok(crate::LifecycleUpdateReceipt {
before,
final_snapshot: None,
transaction,
pre_commit_quiesced,
restoration,
post_commit_failure,
rollback_quiesce_failure,
rollback_restore_failure,
observation_failure: Some(obs),
engine_policy: engine,
});
}
};
Ok(crate::LifecycleUpdateReceipt {
before,
final_snapshot,
transaction,
pre_commit_quiesced,
restoration,
post_commit_failure,
rollback_quiesce_failure,
rollback_restore_failure,
observation_failure: None,
engine_policy: engine,
})
}
#[allow(clippy::too_many_arguments)]
fn restore_manager_success<M, C>(
manager: &mut M,
spec: &ServiceSpec,
before: &LifecycleSnapshot,
planned: UpdateRuntimeDisposition,
intent: crate::RestoreIntent,
check: &C,
deadline: Instant,
engine: &CommitEnginePolicy,
) -> Result<(), crate::LifecycleFailure>
where
M: ServiceManager,
C: PostInstallCheck,
{
use crate::LifecycleUpdatePhase as Phase;
if planned == UpdateRuntimeDisposition::ForeignPreserved {
let snapshot = safe_inspect(manager, spec, Phase::RestoreNew)?;
let budget = remaining(deadline);
if budget.is_zero() {
return Err(LifecycleFailure::new(
spec,
Phase::PostInstallCheck,
"post-commit deadline exhausted before post-install check",
Some(&snapshot),
));
}
return check
.check(spec, &snapshot, budget)
.map_err(|e| LifecycleFailure::new(spec, Phase::PostInstallCheck, e, Some(&snapshot)));
}
let wanted = match planned {
UpdateRuntimeDisposition::Stopped => match intent {
crate::RestoreIntent::EnsureRunning => LifecycleState::Running,
_ => LifecycleState::Stopped,
},
_ => match intent {
crate::RestoreIntent::Preserve => before.state,
crate::RestoreIntent::EnsureRunning => LifecycleState::Running,
crate::RestoreIntent::EnsureStopped => LifecycleState::Stopped,
},
};
restore_and_check(manager, spec, wanted, check, deadline, engine)
}
#[allow(clippy::too_many_arguments)]
fn commit_direct_path<M, D, C>(
manager: &mut M,
spec: &ServiceSpec,
mut direct: Option<&mut D>,
before: LifecycleSnapshot,
transaction: ValidatedTransaction,
ownership: CommitOwnership<'_>,
policy: LifecycleUpdatePolicy,
check: &C,
pre_commit_quiesced: bool,
engine: CommitEnginePolicy,
) -> Result<crate::LifecycleUpdateReceipt, crate::LifecycleUpdateError>
where
M: ServiceManager,
D: DirectRuntimeControl,
C: PostInstallCheck,
{
use crate::LifecycleUpdatePhase as Phase;
let mut post_commit_failure = None;
let mut rollback_quiesce_failure = None;
let before_c = before.clone();
let core_result =
transaction.commit_with_post_commit(ownership, policy.post_commit_failure, || {
let deadline = Instant::now() + policy.post_commit_timeout;
let wanted = match policy.restore {
crate::RestoreIntent::EnsureStopped => DirectState::Stopped,
_ => DirectState::Running,
};
let work = catch_unwind(AssertUnwindSafe(|| {
let restored = catch_unwind(AssertUnwindSafe(
|| -> Result<LifecycleSnapshot, crate::LifecycleFailure> {
if wanted == DirectState::Running {
let budget = remaining(deadline);
if budget.is_zero() {
return Err(LifecycleFailure::new(
spec,
Phase::RestoreNew,
"lifecycle operation deadline exhausted",
Some(&before_c),
));
}
let Some(d) = direct.as_mut() else {
return Err(LifecycleFailure::new(
spec,
Phase::RestoreNew,
"direct control missing during restore",
Some(&before_c),
));
};
let r = (**d).start(budget).map_err(|e| {
LifecycleFailure::new(spec, Phase::RestoreNew, e, Some(&before_c))
})?;
if !r.completed {
return Err(LifecycleFailure::new(
spec,
Phase::RestoreNew,
"direct transition did not complete",
Some(&before_c),
));
}
}
safe_inspect(manager, spec, Phase::RestoreNew)
},
));
let snapshot = match restored {
Ok(Ok(snapshot)) => snapshot,
Ok(Err(failure)) => return Err(failure),
Err(_) => {
return Err(LifecycleFailure::new(
spec,
Phase::RestoreNew,
"direct runtime panicked while restoring",
Some(&before_c),
))
}
};
let budget = remaining(deadline);
if budget.is_zero() {
return Err(LifecycleFailure::new(
spec,
Phase::PostInstallCheck,
"post-commit deadline exhausted before post-install check",
Some(&snapshot),
));
}
check.check(spec, &snapshot, budget).map_err(|e| {
LifecycleFailure::new(spec, Phase::PostInstallCheck, e, Some(&snapshot))
})
}));
let f = match work {
Ok(Ok(())) => return Ok(()),
Ok(Err(f)) => f,
Err(_) => LifecycleFailure::new(
spec,
Phase::PostInstallCheck,
"post-commit direct work panicked",
None,
),
};
post_commit_failure = Some(f.clone());
if policy.post_commit_failure == PostCommitFailurePolicy::RollBack {
rollback_quiesce_failure = match catch_unwind(AssertUnwindSafe(|| {
quiesce_direct_for_rollback(direct.as_deref_mut(), spec, deadline)
})) {
Ok(v) => v,
Err(_) => Some(LifecycleFailure::new(
spec,
Phase::QuiesceForRollback,
"direct runtime panicked while quiescing before artifact rollback",
None,
)),
};
}
Err(PostInstallCheckError::new(f.detail))
});
let transaction = match core_result {
Ok(r) => r,
Err(core) => {
if pre_commit_quiesced {
if let Some(d) = direct.as_mut() {
let _ = catch_unwind(AssertUnwindSafe(|| {
let _ = (**d).start(policy.rollback_restore_timeout);
}));
}
}
return Err(crate::LifecycleUpdateError::CoreBeforeReceipt {
core,
restore_failure: None,
});
}
};
let mut rollback_restore_failure = None;
let mut restoration = crate::LifecycleRestorationStatus::Restored;
match transaction.disposition() {
TransactionDisposition::Committed => {
if post_commit_failure
.as_ref()
.is_some_and(|f| f.phase == Phase::RestoreNew)
{
restoration = crate::LifecycleRestorationStatus::Failed;
}
}
TransactionDisposition::RolledBack => {
if let Some(d) = direct.as_mut() {
let r = catch_unwind(AssertUnwindSafe(|| {
(**d).start(policy.rollback_restore_timeout)
}));
match r {
Ok(Ok(res)) if res.completed => {}
Ok(Ok(_)) => {
rollback_restore_failure = Some(LifecycleFailure::new(
spec,
Phase::RestoreOld,
"direct transition did not complete",
Some(&before),
));
restoration = crate::LifecycleRestorationStatus::Failed;
}
Ok(Err(e)) => {
rollback_restore_failure = Some(LifecycleFailure::new(
spec,
Phase::RestoreOld,
e,
Some(&before),
));
restoration = crate::LifecycleRestorationStatus::Failed;
}
Err(_) => {
rollback_restore_failure = Some(LifecycleFailure::new(
spec,
Phase::RestoreOld,
"direct runtime panicked while restoring",
Some(&before),
));
restoration = crate::LifecycleRestorationStatus::Failed;
}
}
}
}
TransactionDisposition::RecoveryRequired => {
restoration = crate::LifecycleRestorationStatus::NotAttemptedRecoveryRequired;
}
}
let final_snapshot = match safe_inspect(manager, spec, Phase::FinalInspect) {
Ok(s) => Some(s),
Err(obs) => {
return Ok(crate::LifecycleUpdateReceipt {
before,
final_snapshot: None,
transaction,
pre_commit_quiesced,
restoration,
post_commit_failure,
rollback_quiesce_failure,
rollback_restore_failure,
observation_failure: Some(obs),
engine_policy: engine,
});
}
};
Ok(crate::LifecycleUpdateReceipt {
before,
final_snapshot,
transaction,
pre_commit_quiesced,
restoration,
post_commit_failure,
rollback_quiesce_failure,
rollback_restore_failure,
observation_failure: None,
engine_policy: engine,
})
}
fn quiesce_direct_for_rollback<D: DirectRuntimeControl>(
direct: Option<&mut D>,
spec: &ServiceSpec,
deadline: Instant,
) -> Option<crate::LifecycleFailure> {
use crate::LifecycleUpdatePhase as Phase;
let budget = remaining(deadline);
if budget.is_zero() {
return Some(LifecycleFailure::new(
spec,
Phase::QuiesceForRollback,
"post-commit deadline exhausted before rollback quiescence",
None,
));
}
let Some(d) = direct else {
return Some(LifecycleFailure::new(
spec,
Phase::QuiesceForRollback,
"direct control missing before artifact rollback",
None,
));
};
match d.inspect() {
Ok(obs) => {
if obs.state == DirectState::Stopped && obs.exact_ownership_proven {
return None;
}
if !obs.exact_ownership_proven {
return Some(LifecycleFailure::new(
spec,
Phase::QuiesceForRollback,
"refusing to quiesce unproven direct runtime before rollback",
None,
));
}
}
Err(e) => {
return Some(LifecycleFailure::new(
spec,
Phase::QuiesceForRollback,
format!("refusing to quiesce unobservable direct runtime before rollback: {e}"),
None,
))
}
}
match d.stop(budget) {
Err(e) => Some(LifecycleFailure::new(
spec,
Phase::QuiesceForRollback,
e,
None,
)),
Ok(r) if !r.completed => Some(LifecycleFailure::new(
spec,
Phase::QuiesceForRollback,
"direct stop did not complete before artifact rollback",
None,
)),
Ok(_) => None,
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ManagerFailureKind;
use crate::{
NoPostInstallCheck, PostInstallCheckError, RestoreIntent, ServiceError, ServiceId,
TestDoubleManager, TransitionResult,
};
use eggup_core::{
AllValidators, ArtifactMember, ArtifactSet, InstallPlan, MemberId,
PostCommitFailurePolicy as CorePolicy,
};
use std::cell::RefCell;
use std::rc::Rc;
use std::sync::atomic::{AtomicU64, Ordering};
fn direct_obs(state: DirectState, proven: bool) -> DirectObservation {
DirectObservation {
state,
exact_ownership_proven: proven,
executable: Some(crate::absolute("/opt/app/service.bin")),
config: Some(crate::absolute("/etc/app/config.toml")),
}
}
fn unix_input(
ownership: Ownership,
active: bool,
known: bool,
registered: KnownConfig,
selected: Option<PathBuf>,
direct_state: DirectState,
proven: bool,
) -> UnixPlannerInput {
UnixPlannerInput {
manager_ownership: ownership,
manager_active: active,
manager_state_known: known,
registered_config: registered,
selected_config: selected,
direct: direct_obs(direct_state, proven),
}
}
#[test]
fn unix_reference_matrix() {
let cfg = crate::absolute("/etc/app/config.toml");
let other = crate::absolute("/etc/other/config.toml");
assert_eq!(
plan_unix(&unix_input(
Ownership::Owned,
true,
true,
KnownConfig::Absent,
None,
DirectState::Stopped,
false
))
.unwrap(),
UpdateRuntimeDisposition::ManagedRunning
);
assert_eq!(
plan_unix(&unix_input(
Ownership::Owned,
false,
true,
KnownConfig::Absent,
None,
DirectState::Stopped,
false
))
.unwrap(),
UpdateRuntimeDisposition::ManagedStopped
);
assert_eq!(
plan_unix(&unix_input(
Ownership::Foreign,
true,
true,
KnownConfig::Present(cfg.clone()),
Some(cfg.clone()),
DirectState::Stopped,
false
))
.unwrap(),
UpdateRuntimeDisposition::ForeignPreserved
);
assert_eq!(
plan_unix(&unix_input(
Ownership::Foreign,
true,
true,
KnownConfig::Present(cfg.clone()),
Some(other.clone()),
DirectState::Running,
true
))
.unwrap(),
UpdateRuntimeDisposition::DirectRunning
);
assert_eq!(
plan_unix(&unix_input(
Ownership::Foreign,
true,
true,
KnownConfig::Present(cfg.clone()),
Some(other.clone()),
DirectState::Stopped,
false
))
.unwrap(),
UpdateRuntimeDisposition::Stopped
);
assert!(plan_unix(&unix_input(
Ownership::Foreign,
true,
true,
KnownConfig::Unknown,
Some(cfg.clone()),
DirectState::Stopped,
false
))
.is_err());
assert_eq!(
plan_unix(&unix_input(
Ownership::Foreign,
false,
true,
KnownConfig::Present(cfg.clone()),
Some(other.clone()),
DirectState::Running,
true
))
.unwrap(),
UpdateRuntimeDisposition::DirectRunning
);
assert_eq!(
plan_unix(&unix_input(
Ownership::Foreign,
false,
true,
KnownConfig::Present(cfg.clone()),
Some(other.clone()),
DirectState::Stopped,
false
))
.unwrap(),
UpdateRuntimeDisposition::Stopped
);
assert!(plan_unix(&unix_input(
Ownership::Absent,
true,
true,
KnownConfig::Absent,
None,
DirectState::Stopped,
false
))
.is_err());
assert_eq!(
plan_unix(&unix_input(
Ownership::Absent,
false,
true,
KnownConfig::Absent,
None,
DirectState::Running,
true
))
.unwrap(),
UpdateRuntimeDisposition::DirectRunning
);
assert_eq!(
plan_unix(&unix_input(
Ownership::Absent,
false,
true,
KnownConfig::Absent,
None,
DirectState::Stopped,
false
))
.unwrap(),
UpdateRuntimeDisposition::Stopped
);
assert!(plan_unix(&unix_input(
Ownership::Unknown,
true,
true,
KnownConfig::Absent,
None,
DirectState::Stopped,
false
))
.is_err());
assert!(plan_unix(&unix_input(
Ownership::Unknown,
false,
true,
KnownConfig::Absent,
None,
DirectState::Running,
true
))
.is_err());
assert_eq!(
plan_unix(&unix_input(
Ownership::Unknown,
false,
true,
KnownConfig::Absent,
None,
DirectState::Stopped,
false
))
.unwrap(),
UpdateRuntimeDisposition::Stopped
);
let err = plan_unix(&unix_input(
Ownership::Absent,
true,
true,
KnownConfig::Absent,
None,
DirectState::Stopped,
false,
))
.unwrap_err();
let msg = format!("{err}").to_lowercase();
assert!(!msg.contains("gregg"));
assert!(!msg.contains("greggd"));
}
#[test]
fn windows_reference_matrix() {
let w = |installed: bool, known: bool, ownership: Ownership, state: WindowsServiceState| {
plan_windows(&WindowsPlannerInput {
installed,
executable_known: known,
ownership,
state,
})
};
assert_eq!(
w(
false,
false,
Ownership::Absent,
WindowsServiceState::Unknown
)
.unwrap(),
UpdateRuntimeDisposition::Stopped
);
assert!(w(
true,
false,
Ownership::Unknown,
WindowsServiceState::Running
)
.is_err());
assert_eq!(
w(true, true, Ownership::Foreign, WindowsServiceState::Running).unwrap(),
UpdateRuntimeDisposition::ForeignPreserved
);
assert_eq!(
w(true, true, Ownership::Owned, WindowsServiceState::Running).unwrap(),
UpdateRuntimeDisposition::ManagedRunning
);
assert_eq!(
w(
true,
true,
Ownership::Owned,
WindowsServiceState::StartPending
)
.unwrap(),
UpdateRuntimeDisposition::ManagedRunning
);
assert_eq!(
w(true, true, Ownership::Owned, WindowsServiceState::Stopped).unwrap(),
UpdateRuntimeDisposition::ManagedStopped
);
assert_eq!(
w(
true,
true,
Ownership::Owned,
WindowsServiceState::StopPending
)
.unwrap(),
UpdateRuntimeDisposition::ManagedStopped
);
}
#[derive(Debug)]
struct FakeDirect {
obs: DirectObservation,
events: Rc<RefCell<Vec<&'static str>>>,
fail_stop: bool,
fail_start: bool,
fail_inspect: bool,
drift_after_stop: bool,
}
impl FakeDirect {
fn running(events: Rc<RefCell<Vec<&'static str>>>) -> Self {
Self {
obs: direct_obs(DirectState::Running, true),
events,
fail_stop: false,
fail_start: false,
fail_inspect: false,
drift_after_stop: false,
}
}
}
impl DirectRuntimeControl for FakeDirect {
fn inspect(&self) -> Result<DirectObservation, ServiceError> {
self.events.borrow_mut().push("direct-inspect");
if self.fail_inspect {
return Err(ServiceError::manager(
ManagerFailureKind::Protocol,
"injected unobservable direct runtime",
));
}
Ok(self.obs.clone())
}
fn stop(&mut self, _timeout: Duration) -> Result<TransitionResult, ServiceError> {
self.events.borrow_mut().push("direct-stop");
if self.fail_stop {
return Err(ServiceError::manager(
ManagerFailureKind::Protocol,
"injected direct stop failure",
));
}
self.obs.state = DirectState::Stopped;
if self.drift_after_stop {
self.obs.executable = Some(crate::absolute("/different/service.bin"));
self.obs.exact_ownership_proven = false;
}
Ok(TransitionResult {
operation: crate::ServiceOperation::Stop,
completed: true,
detail: "direct stopped".into(),
})
}
fn start(&mut self, _timeout: Duration) -> Result<TransitionResult, ServiceError> {
self.events.borrow_mut().push("direct-start");
if self.fail_start {
return Err(ServiceError::manager(
ManagerFailureKind::Protocol,
"injected direct start failure",
));
}
self.obs.state = DirectState::Running;
self.obs.exact_ownership_proven = true;
Ok(TransitionResult {
operation: crate::ServiceOperation::Start,
completed: true,
detail: "direct started".into(),
})
}
}
static NEXT: AtomicU64 = AtomicU64::new(0);
#[derive(Debug)]
struct UnobservableManager {
inner: TestDoubleManager,
events: Rc<RefCell<Vec<&'static str>>>,
}
impl ServiceManager for UnobservableManager {
fn inspect(&self, _spec: &ServiceSpec) -> Result<LifecycleSnapshot, ServiceError> {
self.events.borrow_mut().push("inspect");
Err(ServiceError::manager(
ManagerFailureKind::Protocol,
"injected unobservable service",
))
}
fn install(&mut self, spec: &ServiceSpec) -> Result<TransitionResult, ServiceError> {
self.events.borrow_mut().push("install");
self.inner.install(spec)
}
fn start(
&mut self,
spec: &ServiceSpec,
timeout: Duration,
) -> Result<TransitionResult, ServiceError> {
self.events.borrow_mut().push("start");
self.inner.start(spec, timeout)
}
fn stop(
&mut self,
spec: &ServiceSpec,
timeout: Duration,
) -> Result<TransitionResult, ServiceError> {
self.events.borrow_mut().push("stop");
self.inner.stop(spec, timeout)
}
fn restart(
&mut self,
spec: &ServiceSpec,
timeout: Duration,
) -> Result<TransitionResult, ServiceError> {
self.events.borrow_mut().push("restart");
self.inner.restart(spec, timeout)
}
fn uninstall(&mut self, spec: &ServiceSpec) -> Result<TransitionResult, ServiceError> {
self.events.borrow_mut().push("uninstall");
self.inner.uninstall(spec)
}
}
#[test]
fn unobservable_direct_runtime_is_not_stopped_before_rollback() {
use crate::LifecycleUpdatePhase as Phase;
let events = Rc::new(RefCell::new(Vec::new()));
let mut direct = FakeDirect::running(events.clone());
direct.fail_inspect = true;
let spec = ServiceSpec::new(
crate::ServiceId::new("unobservable").unwrap(),
std::env::current_exe().unwrap(),
Vec::new(),
None,
)
.unwrap();
let failure = quiesce_direct_for_rollback(
Some(&mut direct),
&spec,
Instant::now() + Duration::from_secs(5),
)
.expect("an unobservable direct runtime must refuse to quiesce");
assert_eq!(failure.phase, Phase::QuiesceForRollback);
let events = events.borrow();
assert!(
events.iter().all(|e| *e != "direct-stop"),
"no destructive stop may be issued without proven ownership, got {events:?}"
);
}
#[test]
fn unobservable_service_is_not_stopped_before_rollback() {
use crate::LifecycleUpdatePhase as Phase;
let events = Rc::new(RefCell::new(Vec::new()));
let spec = ServiceSpec::new(
crate::ServiceId::new("unobservable").unwrap(),
std::env::current_exe().unwrap(),
Vec::new(),
None,
)
.unwrap();
let mut manager = UnobservableManager {
inner: TestDoubleManager::new(),
events: events.clone(),
};
let failure =
quiesce_for_rollback(&mut manager, &spec, Instant::now() + Duration::from_secs(5))
.expect("an unobservable service must refuse to quiesce");
assert_eq!(failure.phase, Phase::QuiesceForRollback);
let events = events.borrow();
assert!(
events.iter().all(|e| *e != "stop"),
"no destructive stop may be issued without proven ownership, got {events:?}"
);
}
fn setup() -> (TempfileGuard, std::path::PathBuf, ValidatedTransaction) {
let base = std::env::temp_dir().join(format!(
"eggup-disposition-{}-{}",
std::process::id(),
NEXT.fetch_add(1, Ordering::Relaxed)
));
let source_root = base.join("input");
let install_root = base.join("install");
std::fs::create_dir_all(&source_root).unwrap();
std::fs::create_dir_all(&install_root).unwrap();
let main = source_root.join("main");
let sidecar = source_root.join("sidecar");
std::fs::write(&main, b"new-main").unwrap();
std::fs::write(&sidecar, b"new-sidecar").unwrap();
std::fs::write(install_root.join("service.bin"), b"old-main").unwrap();
std::fs::write(install_root.join("sidecar.bin"), b"old-sidecar").unwrap();
let members = ArtifactSet::new(vec![
ArtifactMember::new(MemberId::new("main").unwrap(), &main, "service.bin")
.unwrap()
.with_permissions(eggup_core::PermissionsIntent::Executable)
.with_integrity(eggup_core::IntegrityRequirement::Sha256(
eggup_core::hash_file(&main).unwrap(),
)),
ArtifactMember::new(MemberId::new("sidecar").unwrap(), &sidecar, "sidecar.bin")
.unwrap()
.with_integrity(eggup_core::IntegrityRequirement::Sha256(
eggup_core::hash_file(&sidecar).unwrap(),
)),
])
.unwrap();
let validated = InstallPlan::new(
eggup_core::ProductId::new("disposition-test").unwrap(),
eggup_core::ReleaseId::new("r2").unwrap(),
&install_root,
members,
)
.unwrap()
.prepare()
.unwrap()
.verify_integrity()
.unwrap()
.validate(&AllValidators::new())
.unwrap();
(
TempfileGuard { path: base.clone() },
install_root,
validated,
)
}
struct TempfileGuard {
path: std::path::PathBuf,
}
impl Drop for TempfileGuard {
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.path);
}
}
fn service_spec(install_root: &std::path::Path) -> ServiceSpec {
ServiceSpec::new(
ServiceId::new("disposition-test").unwrap(),
install_root.join("service.bin"),
vec!["--worker".into()],
None,
)
.unwrap()
}
fn ownership_proof(_install_root: &std::path::Path) -> eggup_core::CommitOwnership<'static> {
use eggup_core::OwnershipVerifier;
struct Fixed(eggup_core::Ownership);
impl OwnershipVerifier for Fixed {
fn verify(
&self,
_member: &eggup_core::MemberId,
_destination: &std::path::Path,
) -> eggup_core::Ownership {
self.0
}
}
static VERIFIER: Fixed = Fixed(eggup_core::Ownership::Owned);
eggup_core::CommitOwnership::new(&VERIFIER, eggup_core::AbsentPolicy::AllowCreate)
}
fn policy() -> LifecycleUpdatePolicy {
LifecycleUpdatePolicy {
restore: RestoreIntent::Preserve,
post_commit_failure: CorePolicy::KeepInstalled,
quiesce_timeout: Duration::from_secs(2),
post_commit_timeout: Duration::from_secs(2),
rollback_restore_timeout: Duration::from_secs(2),
}
}
#[test]
fn managed_running_stop_commit_restart_ordering() {
let (_guard, install_root, validated) = setup();
let spec = service_spec(&install_root);
let mut manager = TestDoubleManager::new();
manager.put(spec.clone(), crate::LifecycleState::Running);
let baseline = DispositionBaseline {
manager_ownership: Ownership::Owned,
manager_state: crate::LifecycleState::Running,
direct: None,
};
let receipt = commit_with_disposition(
&mut manager,
&spec,
None::<&mut FakeDirect>,
validated,
ownership_proof(&install_root),
policy(),
&NoPostInstallCheck,
UpdateRuntimeDisposition::ManagedRunning,
&baseline,
)
.expect("managed running");
assert!(receipt.pre_commit_quiesced);
assert!(receipt.service_state_restored());
assert_eq!(
receipt.artifact_disposition(),
eggup_core::TransactionDisposition::Committed
);
}
#[test]
fn managed_stopped_stays_stopped_under_preserve() {
let (_guard, install_root, validated) = setup();
let spec = service_spec(&install_root);
let mut manager = TestDoubleManager::new();
manager.put(spec.clone(), crate::LifecycleState::Stopped);
let baseline = DispositionBaseline {
manager_ownership: Ownership::Owned,
manager_state: crate::LifecycleState::Stopped,
direct: None,
};
let receipt = commit_with_disposition(
&mut manager,
&spec,
None::<&mut FakeDirect>,
validated,
ownership_proof(&install_root),
policy(),
&NoPostInstallCheck,
UpdateRuntimeDisposition::ManagedStopped,
&baseline,
)
.unwrap();
assert!(!receipt.pre_commit_quiesced);
let final_state = receipt.final_snapshot.unwrap().state;
assert_eq!(final_state, crate::LifecycleState::Stopped);
}
#[test]
fn stopped_fabricates_no_restart() {
let (_guard, install_root, validated) = setup();
let spec = ServiceSpec::new(
ServiceId::new("absent-service").unwrap(),
install_root.join("service.bin"),
vec!["--worker".into()],
None,
)
.unwrap();
let mut manager = TestDoubleManager::new();
let baseline = DispositionBaseline {
manager_ownership: Ownership::Absent,
manager_state: crate::LifecycleState::Stopped,
direct: Some(direct_obs(DirectState::Stopped, true)),
};
let receipt = commit_with_disposition(
&mut manager,
&spec,
None::<&mut FakeDirect>,
validated,
ownership_proof(&install_root),
policy(),
&NoPostInstallCheck,
UpdateRuntimeDisposition::Stopped,
&baseline,
)
.unwrap();
assert!(!receipt.pre_commit_quiesced);
assert_eq!(
receipt.artifact_disposition(),
eggup_core::TransactionDisposition::Committed
);
}
#[test]
fn foreign_preserved_performs_zero_manager_mutation() {
let (_guard, install_root, validated) = setup();
let foreign_spec = ServiceSpec::new(
ServiceId::new("disposition-test").unwrap(),
crate::absolute("/foreign/service.bin"),
vec!["--worker".into()],
None,
)
.unwrap();
let mut manager = TestDoubleManager::new();
manager.put(foreign_spec.clone(), crate::LifecycleState::Running);
let spec = service_spec(&install_root);
let baseline = DispositionBaseline {
manager_ownership: Ownership::Foreign,
manager_state: crate::LifecycleState::Running,
direct: None,
};
let receipt = commit_with_disposition(
&mut manager,
&spec,
None::<&mut FakeDirect>,
validated,
ownership_proof(&install_root),
policy(),
&NoPostInstallCheck,
UpdateRuntimeDisposition::ForeignPreserved,
&baseline,
)
.unwrap();
assert!(!receipt.pre_commit_quiesced);
let after = manager.inspect(&spec).unwrap();
assert_eq!(after.ownership, Ownership::Foreign);
assert_eq!(
receipt.artifact_disposition(),
eggup_core::TransactionDisposition::Committed
);
}
#[test]
fn direct_running_uses_only_direct_seam() {
let (_guard, install_root, validated) = setup();
let spec = service_spec(&install_root);
let foreign = ServiceSpec::new(
spec.id().clone(),
crate::absolute("/foreign/service.bin"),
spec.args().to_vec(),
None,
)
.unwrap();
let mut manager = TestDoubleManager::new();
manager.put(foreign, crate::LifecycleState::Running);
let events = Rc::new(RefCell::new(Vec::new()));
let mut direct = FakeDirect::running(events.clone());
let baseline = DispositionBaseline {
manager_ownership: Ownership::Foreign,
manager_state: crate::LifecycleState::Running,
direct: Some(direct_obs(DirectState::Running, true)),
};
let receipt = commit_with_disposition(
&mut manager,
&spec,
Some(&mut direct),
validated,
ownership_proof(&install_root),
policy(),
&NoPostInstallCheck,
UpdateRuntimeDisposition::DirectRunning,
&baseline,
)
.unwrap();
assert!(receipt.pre_commit_quiesced);
let ev = events.borrow().clone();
assert!(ev.contains(&"direct-stop"));
assert!(ev.contains(&"direct-start"));
let after = manager.inspect(&spec).unwrap();
assert_eq!(after.ownership, Ownership::Foreign);
}
#[test]
fn owned_to_foreign_revalidation_fails_before_stop() {
let (_guard, install_root, validated) = setup();
let spec = service_spec(&install_root);
let mut manager = TestDoubleManager::new();
manager.put(spec.clone(), crate::LifecycleState::Running);
let foreign = ServiceSpec::new(
spec.id().clone(),
crate::absolute("/different/service-executable"),
spec.args().to_vec(),
None,
)
.unwrap();
manager.put(foreign, crate::LifecycleState::Running);
let baseline = DispositionBaseline {
manager_ownership: Ownership::Owned,
manager_state: crate::LifecycleState::Running,
direct: None,
};
let err = commit_with_disposition(
&mut manager,
&spec,
None::<&mut FakeDirect>,
validated,
ownership_proof(&install_root),
policy(),
&NoPostInstallCheck,
UpdateRuntimeDisposition::ManagedRunning,
&baseline,
)
.unwrap_err();
assert!(matches!(err, crate::LifecycleUpdateError::Preflight { .. }));
}
#[test]
fn direct_identity_change_fails_before_stop() {
let (_guard, install_root, validated) = setup();
let spec = service_spec(&install_root);
let mut manager = TestDoubleManager::new();
let baseline = DispositionBaseline {
manager_ownership: Ownership::Absent,
manager_state: crate::LifecycleState::Stopped,
direct: Some(direct_obs(DirectState::Running, true)),
};
let events = Rc::new(RefCell::new(Vec::new()));
let mut direct = FakeDirect {
obs: DirectObservation {
state: DirectState::Running,
exact_ownership_proven: false,
executable: Some(crate::absolute("/different/service.bin")),
config: Some(crate::absolute("/etc/app/config.toml")),
},
events,
fail_stop: false,
fail_start: false,
fail_inspect: false,
drift_after_stop: false,
};
let err = commit_with_disposition(
&mut manager,
&spec,
Some(&mut direct),
validated,
ownership_proof(&install_root),
policy(),
&NoPostInstallCheck,
UpdateRuntimeDisposition::DirectRunning,
&baseline,
)
.unwrap_err();
assert!(matches!(err, crate::LifecycleUpdateError::Preflight { .. }));
}
#[test]
fn keepinstalled_reports_committed_plus_lifecycle_failure() {
let (_guard, install_root, validated) = setup();
let spec = service_spec(&install_root);
let mut manager = TestDoubleManager::new();
manager.put(spec.clone(), crate::LifecycleState::Running);
struct FailCheck;
impl std::fmt::Debug for FailCheck {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("FailCheck")
}
}
impl crate::PostInstallCheck for FailCheck {
fn check(
&self,
_spec: &ServiceSpec,
_snap: &LifecycleSnapshot,
_remaining: Duration,
) -> Result<(), PostInstallCheckError> {
Err(PostInstallCheckError::new("injected check failure"))
}
}
let baseline = DispositionBaseline {
manager_ownership: Ownership::Owned,
manager_state: crate::LifecycleState::Running,
direct: None,
};
let mut pol = policy();
pol.post_commit_failure = CorePolicy::KeepInstalled;
let receipt = commit_with_disposition(
&mut manager,
&spec,
None::<&mut FakeDirect>,
validated,
ownership_proof(&install_root),
pol,
&FailCheck,
UpdateRuntimeDisposition::ManagedRunning,
&baseline,
)
.unwrap();
assert_eq!(
receipt.artifact_disposition(),
eggup_core::TransactionDisposition::Committed
);
assert!(receipt.post_commit_failure.is_some());
}
#[test]
fn recovery_required_suppresses_automatic_starts() {
let (_guard, install_root, validated) = setup();
let spec = service_spec(&install_root);
let mut manager = TestDoubleManager::new();
manager.put(spec.clone(), crate::LifecycleState::Stopped);
let baseline = DispositionBaseline {
manager_ownership: Ownership::Owned,
manager_state: crate::LifecycleState::Stopped,
direct: None,
};
let mut pol = policy();
pol.restore = RestoreIntent::EnsureStopped;
let receipt = commit_with_disposition(
&mut manager,
&spec,
None::<&mut FakeDirect>,
validated,
ownership_proof(&install_root),
pol,
&NoPostInstallCheck,
UpdateRuntimeDisposition::ManagedStopped,
&baseline,
)
.unwrap();
assert_eq!(
receipt.final_snapshot.unwrap().state,
crate::LifecycleState::Stopped
);
}
#[test]
fn no_gregg_strings_in_public_types() {
let debug = format!("{:?}", UpdateRuntimeDisposition::ManagedRunning);
assert!(!debug.to_lowercase().contains("gregg"));
let debug = format!("{:?}", WindowsServiceState::Running);
assert!(!debug.to_lowercase().contains("gregg"));
}
#[derive(Debug)]
struct EventManager {
inner: TestDoubleManager,
events: Rc<RefCell<Vec<&'static str>>>,
}
impl EventManager {
fn with_service(
spec: ServiceSpec,
state: crate::LifecycleState,
events: Rc<RefCell<Vec<&'static str>>>,
) -> Self {
let mut inner = TestDoubleManager::new();
inner.put(spec, state);
Self { inner, events }
}
}
impl ServiceManager for EventManager {
fn inspect(&self, spec: &ServiceSpec) -> Result<LifecycleSnapshot, ServiceError> {
self.events.borrow_mut().push("inspect");
self.inner.inspect(spec)
}
fn install(&mut self, spec: &ServiceSpec) -> Result<TransitionResult, ServiceError> {
self.events.borrow_mut().push("install");
self.inner.install(spec)
}
fn start(
&mut self,
spec: &ServiceSpec,
timeout: Duration,
) -> Result<TransitionResult, ServiceError> {
self.events.borrow_mut().push("start");
self.inner.start(spec, timeout)
}
fn stop(
&mut self,
spec: &ServiceSpec,
timeout: Duration,
) -> Result<TransitionResult, ServiceError> {
self.events.borrow_mut().push("stop");
self.inner.stop(spec, timeout)
}
fn restart(
&mut self,
spec: &ServiceSpec,
timeout: Duration,
) -> Result<TransitionResult, ServiceError> {
self.events.borrow_mut().push("restart");
self.inner.restart(spec, timeout)
}
fn uninstall(&mut self, spec: &ServiceSpec) -> Result<TransitionResult, ServiceError> {
self.events.borrow_mut().push("uninstall");
self.inner.uninstall(spec)
}
}
#[test]
fn preparation_completes_before_first_quiesce() {
let (_guard, install_root, validated) = setup();
let spec = service_spec(&install_root);
let events = Rc::new(RefCell::new(Vec::new()));
let mut manager = EventManager::with_service(
spec.clone(),
crate::LifecycleState::Running,
events.clone(),
);
let baseline = DispositionBaseline {
manager_ownership: Ownership::Owned,
manager_state: crate::LifecycleState::Running,
direct: None,
};
commit_with_disposition(
&mut manager,
&spec,
None::<&mut FakeDirect>,
validated,
ownership_proof(&install_root),
policy(),
&NoPostInstallCheck,
UpdateRuntimeDisposition::ManagedRunning,
&baseline,
)
.unwrap();
let ev = events.borrow().clone();
let first_inspect = ev.iter().position(|e| *e == "inspect").unwrap();
let first_stop = ev.iter().position(|e| *e == "stop").unwrap();
assert!(
first_inspect < first_stop,
"inspect must precede quiesce, got {ev:?}"
);
let (_guard2, install_root2, validated2) = setup();
let spec2 = service_spec(&install_root2);
let events2 = Rc::new(RefCell::new(Vec::new()));
let mut manager2 = EventManager::with_service(
spec2.clone(),
crate::LifecycleState::Running,
events2.clone(),
);
let mut bad = policy();
bad.quiesce_timeout = Duration::ZERO;
let err = commit_with_disposition(
&mut manager2,
&spec2,
None::<&mut FakeDirect>,
validated2,
ownership_proof(&install_root2),
bad,
&NoPostInstallCheck,
UpdateRuntimeDisposition::ManagedRunning,
&DispositionBaseline {
manager_ownership: Ownership::Owned,
manager_state: crate::LifecycleState::Running,
direct: None,
},
)
.unwrap_err();
assert!(matches!(
err,
crate::LifecycleUpdateError::InvalidPolicy { .. }
));
assert!(events2.borrow().is_empty());
}
#[derive(Debug)]
struct FailCheck;
impl crate::PostInstallCheck for FailCheck {
fn check(
&self,
_spec: &ServiceSpec,
_snap: &LifecycleSnapshot,
_remaining: Duration,
) -> Result<(), PostInstallCheckError> {
Err(PostInstallCheckError::new("injected check failure"))
}
}
#[derive(Debug)]
struct SabotageCheck(std::path::PathBuf);
impl crate::PostInstallCheck for SabotageCheck {
fn check(
&self,
_spec: &ServiceSpec,
_snap: &LifecycleSnapshot,
_remaining: Duration,
) -> Result<(), PostInstallCheckError> {
let dest = self.0.join("service.bin");
std::fs::remove_file(&dest).unwrap();
std::fs::create_dir(&dest).unwrap();
Err(PostInstallCheckError::new("injected rollback failure"))
}
}
#[test]
fn rollback_quiesces_new_generation_and_restores_old() {
let (_guard, install_root, validated) = setup();
let spec = service_spec(&install_root);
let events = Rc::new(RefCell::new(Vec::new()));
let mut manager = EventManager::with_service(
spec.clone(),
crate::LifecycleState::Running,
events.clone(),
);
let baseline = DispositionBaseline {
manager_ownership: Ownership::Owned,
manager_state: crate::LifecycleState::Running,
direct: None,
};
let mut pol = policy();
pol.post_commit_failure = CorePolicy::RollBack;
let receipt = commit_with_disposition(
&mut manager,
&spec,
None::<&mut FakeDirect>,
validated,
ownership_proof(&install_root),
pol,
&FailCheck,
UpdateRuntimeDisposition::ManagedRunning,
&baseline,
)
.unwrap();
assert_eq!(
receipt.artifact_disposition(),
eggup_core::TransactionDisposition::RolledBack
);
let ev = events.borrow().clone();
assert!(ev.iter().filter(|e| ***e == *"stop").count() >= 2);
assert!(ev.contains(&"start"));
assert_eq!(
receipt.final_snapshot.unwrap().state,
crate::LifecycleState::Running
);
}
#[test]
fn recovery_required_suppresses_all_automatic_starts() {
let (_guard, install_root, validated) = setup();
let spec = service_spec(&install_root);
let events = Rc::new(RefCell::new(Vec::new()));
let mut manager = EventManager::with_service(
spec.clone(),
crate::LifecycleState::Running,
events.clone(),
);
let baseline = DispositionBaseline {
manager_ownership: Ownership::Owned,
manager_state: crate::LifecycleState::Running,
direct: None,
};
let mut pol = policy();
pol.post_commit_failure = CorePolicy::RollBack;
let receipt = commit_with_disposition(
&mut manager,
&spec,
None::<&mut FakeDirect>,
validated,
ownership_proof(&install_root),
pol,
&SabotageCheck(install_root.clone()),
UpdateRuntimeDisposition::ManagedRunning,
&baseline,
)
.unwrap();
assert_eq!(
receipt.artifact_disposition(),
eggup_core::TransactionDisposition::RecoveryRequired
);
assert!(receipt.manual_artifact_recovery_required());
assert_eq!(
receipt.restoration,
crate::LifecycleRestorationStatus::NotAttemptedRecoveryRequired
);
assert_eq!(
events.borrow().iter().filter(|e| ***e == *"start").count(),
1
);
assert_eq!(
receipt.final_snapshot.as_ref().unwrap().state,
crate::LifecycleState::Stopped
);
}
}