Skip to main content

eggup_service/
disposition.rs

1#![forbid(unsafe_code)]
2#![deny(missing_docs)]
3//! Generic daemon update disposition and reference qualification.
4//!
5//! Separates artifact mutation authority from service-manager mutation
6//! authority. [`UpdateRuntimeDisposition`] describes what lifecycle authority
7//! Eggup may exercise around an already validated transaction. Pure planners
8//! reproduce the reference matrix without native managers, and
9//! [`commit_with_disposition`] enforces prepare-before-quiesce plus a
10//! post-preparation, pre-mutation revalidation barrier.
11//!
12//! Reference behavior only: greggd at `eggstack/gregg@8b18f9ee` is a behavioral
13//! oracle. No Gregg code, dependency, or product terminology is used here.
14
15use crate::{
16    commit_engine::{
17        quiesce_for_rollback, remaining, restore_and_check, safe_inspect, safe_transition_to,
18    },
19    CommitEnginePolicy, LifecycleFailure, LifecycleSnapshot, LifecycleState, LifecycleUpdatePolicy,
20    Ownership, PostInstallCheck, PostInstallCheckError, ServiceManager, ServiceSpec,
21    TransitionResult,
22};
23use eggup_core::{
24    CommitOwnership, PostCommitFailurePolicy, TransactionDisposition, ValidatedTransaction,
25};
26use std::fmt;
27use std::panic::{catch_unwind, AssertUnwindSafe};
28use std::path::PathBuf;
29use std::time::{Duration, Instant};
30
31/// Product-neutral update runtime disposition.
32///
33/// Artifact commit authority and manager mutation authority are separate facts.
34#[derive(Debug, Clone, Copy, PartialEq, Eq)]
35pub enum UpdateRuntimeDisposition {
36    /// Owned manager, running: quiesce via manager, commit, restore/start per policy.
37    ManagedRunning,
38    /// Owned manager, stopped: commit and preserve stopped unless explicitly requested otherwise.
39    ManagedStopped,
40    /// Selected direct runtime running: quiesce/restore only via caller-owned direct seam.
41    DirectRunning,
42    /// No running runtime: commit with no fabricated restart.
43    Stopped,
44    /// Foreign manager preserved: zero manager mutation.
45    ForeignPreserved,
46}
47
48/// Known vs unknown registered config identity for Unix-like planning.
49#[derive(Debug, Clone, PartialEq, Eq)]
50pub enum KnownConfig {
51    /// No config participates in identity.
52    Absent,
53    /// Exact registered config path.
54    Present(PathBuf),
55    /// Registered config could not be determined.
56    Unknown,
57}
58
59/// Selected direct-runtime state.
60#[derive(Debug, Clone, Copy, PartialEq, Eq)]
61pub enum DirectState {
62    /// Selected instance is running.
63    Running,
64    /// Selected instance is stopped.
65    Stopped,
66    /// Selected runtime state cannot be proven.
67    Unknown,
68}
69
70/// Caller-supplied selected direct-runtime observation.
71#[derive(Debug, Clone, PartialEq, Eq)]
72pub struct DirectObservation {
73    /// Runtime state of the selected instance.
74    pub state: DirectState,
75    /// Whether exact instance/config ownership is proven.
76    pub exact_ownership_proven: bool,
77    /// Exact selected executable identity, when known.
78    pub executable: Option<PathBuf>,
79    /// Exact selected config identity, when relevant.
80    pub config: Option<PathBuf>,
81}
82
83/// Unix-like planner inputs.
84#[derive(Debug, Clone, PartialEq, Eq)]
85pub struct UnixPlannerInput {
86    /// Manager registration ownership.
87    pub manager_ownership: Ownership,
88    /// Whether the manager reports active (running).
89    pub manager_active: bool,
90    /// Whether the manager state is known (false = transitioning/unknown).
91    pub manager_state_known: bool,
92    /// Known registered config identity, when relevant.
93    pub registered_config: KnownConfig,
94    /// Selected artifact config identity, when relevant.
95    pub selected_config: Option<PathBuf>,
96    /// Caller-supplied selected direct-runtime observation.
97    pub direct: DirectObservation,
98}
99
100/// Windows SCM state classes.
101#[derive(Debug, Clone, Copy, PartialEq, Eq)]
102pub enum WindowsServiceState {
103    /// Running.
104    Running,
105    /// Start-pending.
106    StartPending,
107    /// Stopped.
108    Stopped,
109    /// Stop-pending.
110    StopPending,
111    /// Unknown or contradictory.
112    Unknown,
113}
114
115/// Windows-like planner inputs.
116#[derive(Debug, Clone, PartialEq, Eq)]
117pub struct WindowsPlannerInput {
118    /// Whether an SCM registration exists.
119    pub installed: bool,
120    /// Whether the registration executable is present and parseable.
121    pub executable_known: bool,
122    /// Ownership from exact executable-path equivalence.
123    pub ownership: Ownership,
124    /// SCM state class.
125    pub state: WindowsServiceState,
126}
127
128/// Pure Unix-like manager/direct decision logic.
129///
130/// # Errors
131///
132/// [`crate::ServiceError::InvalidInput`] when the inputs do not prove a
133/// decidable outcome: the manager state is unknown while the manager
134/// ownership is unknown and the manager is not active, or the manager and
135/// direct states are both unproven.
136pub fn plan_unix(
137    input: &UnixPlannerInput,
138) -> Result<UpdateRuntimeDisposition, crate::ServiceError> {
139    if !input.manager_state_known {
140        if input.manager_ownership == Ownership::Unknown
141            && !input.manager_active
142            && input.direct.state == DirectState::Stopped
143        {
144            return Ok(UpdateRuntimeDisposition::Stopped);
145        }
146        return Err(crate::ServiceError::invalid(
147            "manager state is transitioning or unknown",
148        ));
149    }
150    match input.manager_ownership {
151        Ownership::Owned => {
152            if input.manager_active {
153                Ok(UpdateRuntimeDisposition::ManagedRunning)
154            } else {
155                Ok(UpdateRuntimeDisposition::ManagedStopped)
156            }
157        }
158        Ownership::Foreign => {
159            if input.manager_active {
160                match &input.registered_config {
161                    KnownConfig::Unknown => Err(crate::ServiceError::invalid(
162                        "registered config is unknown; refusing to infer disposition",
163                    )),
164                    KnownConfig::Absent | KnownConfig::Present(_) => {
165                        let same = match (&input.registered_config, &input.selected_config) {
166                            (KnownConfig::Absent, None) => true,
167                            (KnownConfig::Present(a), Some(b)) => a == b,
168                            _ => false,
169                        };
170                        if same {
171                            Ok(UpdateRuntimeDisposition::ForeignPreserved)
172                        } else {
173                            match input.direct.state {
174                                DirectState::Running if input.direct.exact_ownership_proven => {
175                                    Ok(UpdateRuntimeDisposition::DirectRunning)
176                                }
177                                DirectState::Stopped => Ok(UpdateRuntimeDisposition::Stopped),
178                                _ => Err(crate::ServiceError::invalid(
179                                    "direct runtime ownership/state unproven",
180                                )),
181                            }
182                        }
183                    }
184                }
185            } else {
186                match input.direct.state {
187                    DirectState::Running if input.direct.exact_ownership_proven => {
188                        Ok(UpdateRuntimeDisposition::DirectRunning)
189                    }
190                    DirectState::Stopped => Ok(UpdateRuntimeDisposition::Stopped),
191                    _ => Err(crate::ServiceError::invalid(
192                        "direct runtime ownership/state unproven",
193                    )),
194                }
195            }
196        }
197        Ownership::Absent => {
198            if input.manager_active {
199                Err(crate::ServiceError::invalid(
200                    "registration absent but manager reports active",
201                ))
202            } else {
203                match input.direct.state {
204                    DirectState::Running if input.direct.exact_ownership_proven => {
205                        Ok(UpdateRuntimeDisposition::DirectRunning)
206                    }
207                    DirectState::Stopped => Ok(UpdateRuntimeDisposition::Stopped),
208                    _ => Err(crate::ServiceError::invalid(
209                        "direct runtime ownership/state unproven",
210                    )),
211                }
212            }
213        }
214        Ownership::Unknown => {
215            if input.manager_active {
216                Err(crate::ServiceError::invalid(
217                    "manager ownership unknown while active",
218                ))
219            } else {
220                match input.direct.state {
221                    DirectState::Running => Err(crate::ServiceError::invalid(
222                        "manager ownership unknown; refusing direct mutation",
223                    )),
224                    DirectState::Stopped => Ok(UpdateRuntimeDisposition::Stopped),
225                    DirectState::Unknown => Err(crate::ServiceError::invalid(
226                        "manager and direct states unproven",
227                    )),
228                }
229            }
230        }
231    }
232}
233
234/// Pure Windows SCM/executable decision logic including pending states.
235///
236/// # Errors
237///
238/// [`crate::ServiceError::InvalidInput`] when the service is installed but
239/// its executable is absent or unparseable, so the ownership of the
240/// registration cannot be decided.
241pub fn plan_windows(
242    input: &WindowsPlannerInput,
243) -> Result<UpdateRuntimeDisposition, crate::ServiceError> {
244    if !input.installed {
245        return Ok(UpdateRuntimeDisposition::Stopped);
246    }
247    if !input.executable_known {
248        return Err(crate::ServiceError::invalid(
249            "service executable absent or unparseable",
250        ));
251    }
252    match input.ownership {
253        Ownership::Foreign => Ok(UpdateRuntimeDisposition::ForeignPreserved),
254        Ownership::Owned => match input.state {
255            WindowsServiceState::Running | WindowsServiceState::StartPending => {
256                Ok(UpdateRuntimeDisposition::ManagedRunning)
257            }
258            WindowsServiceState::Stopped | WindowsServiceState::StopPending => {
259                Ok(UpdateRuntimeDisposition::ManagedStopped)
260            }
261            WindowsServiceState::Unknown => Err(crate::ServiceError::invalid(
262                "windows service state unknown",
263            )),
264        },
265        Ownership::Absent => Err(crate::ServiceError::invalid(
266            "windows registration state contradictory",
267        )),
268        Ownership::Unknown => Err(crate::ServiceError::invalid("windows ownership unproven")),
269    }
270}
271
272/// Minimum caller-owned direct-runtime control seam.
273pub trait DirectRuntimeControl: fmt::Debug {
274    /// Re-observe the selected instance.
275    fn inspect(&self) -> Result<DirectObservation, crate::ServiceError>;
276    /// Stop/quiesce the selected instance within the deadline.
277    fn stop(&mut self, timeout: Duration) -> Result<TransitionResult, crate::ServiceError>;
278    /// Start/restore the selected instance within the deadline.
279    fn start(&mut self, timeout: Duration) -> Result<TransitionResult, crate::ServiceError>;
280}
281
282/// Baseline authority/state observed after preparation.
283#[derive(Debug, Clone, PartialEq, Eq)]
284pub struct DispositionBaseline {
285    /// Manager ownership observed after preparation.
286    pub manager_ownership: Ownership,
287    /// Manager state observed after preparation.
288    pub manager_state: LifecycleState,
289    /// Direct observation observed after preparation, when relevant.
290    pub direct: Option<DirectObservation>,
291}
292
293/// Disposition-aware orchestration over an existing `ValidatedTransaction`.
294///
295/// See module docs for ordering and revalidation rules.
296///
297/// This entry point runs the unified commit engine under
298/// [`CommitEnginePolicy::default`], the stricter of the two former engine
299/// copies' behaviours. Use [`commit_with_disposition_with_engine_policy`] to
300/// select the named policy inputs explicitly.
301///
302/// # Errors
303///
304/// [`crate::LifecycleUpdateError`] when the update cannot be completed
305/// safely: the commit engine could not commit, roll back, or restore the
306/// service to its pre-update state. The error carries the transaction
307/// disposition, the observed lifecycle state, and whether manual artifact
308/// recovery is required.
309#[allow(clippy::too_many_arguments)]
310pub fn commit_with_disposition<M, D, C>(
311    manager: &mut M,
312    spec: &ServiceSpec,
313    direct: Option<&mut D>,
314    transaction: ValidatedTransaction,
315    ownership: CommitOwnership<'_>,
316    policy: LifecycleUpdatePolicy,
317    check: &C,
318    planned: UpdateRuntimeDisposition,
319    baseline: &DispositionBaseline,
320) -> Result<crate::LifecycleUpdateReceipt, crate::LifecycleUpdateError>
321where
322    M: ServiceManager,
323    D: DirectRuntimeControl,
324    C: PostInstallCheck,
325{
326    commit_with_disposition_with_engine_policy(
327        manager,
328        spec,
329        direct,
330        transaction,
331        ownership,
332        policy,
333        check,
334        planned,
335        baseline,
336        CommitEnginePolicy::default(),
337    )
338}
339
340/// Disposition-aware orchestration under an explicitly selected commit-engine
341/// policy.
342///
343/// Identical to [`commit_with_disposition`] except that the two named
344/// commit-engine inputs — post-transition verification and ownership-loss
345/// tolerance — are chosen by the caller instead of taking their stricter
346/// defaults. The selected policy is observable in the returned receipt's
347/// `engine_policy` field.
348///
349/// # Errors
350///
351/// [`crate::LifecycleUpdateError`] when the update cannot be completed
352/// safely: the commit engine could not commit, roll back, or restore the
353/// service to its pre-update state. The error carries the transaction
354/// disposition, the observed lifecycle state, and whether manual artifact
355/// recovery is required.
356#[allow(clippy::too_many_arguments)]
357pub fn commit_with_disposition_with_engine_policy<M, D, C>(
358    manager: &mut M,
359    spec: &ServiceSpec,
360    direct: Option<&mut D>,
361    transaction: ValidatedTransaction,
362    ownership: CommitOwnership<'_>,
363    policy: LifecycleUpdatePolicy,
364    check: &C,
365    planned: UpdateRuntimeDisposition,
366    baseline: &DispositionBaseline,
367    engine: CommitEnginePolicy,
368) -> Result<crate::LifecycleUpdateReceipt, crate::LifecycleUpdateError>
369where
370    M: ServiceManager,
371    D: DirectRuntimeControl,
372    C: PostInstallCheck,
373{
374    use crate::LifecycleUpdatePhase as Phase;
375    policy.validate()?;
376
377    let baseline_ok = match planned {
378        UpdateRuntimeDisposition::ManagedRunning => {
379            baseline.manager_ownership == Ownership::Owned
380                && baseline.manager_state == LifecycleState::Running
381        }
382        UpdateRuntimeDisposition::ManagedStopped => {
383            baseline.manager_ownership == Ownership::Owned
384                && baseline.manager_state == LifecycleState::Stopped
385        }
386        UpdateRuntimeDisposition::DirectRunning => matches!(
387            baseline.direct.as_ref(),
388            Some(o) if o.state == DirectState::Running && o.exact_ownership_proven
389        ),
390        UpdateRuntimeDisposition::Stopped => true,
391        UpdateRuntimeDisposition::ForeignPreserved => matches!(
392            baseline.manager_ownership,
393            Ownership::Foreign | Ownership::Absent | Ownership::Unknown
394        ),
395    };
396    if !baseline_ok {
397        return Err(crate::LifecycleUpdateError::Preflight {
398            failure: LifecycleFailure::new(
399                spec,
400                Phase::Inspect,
401                "planned disposition does not match baseline authority/state",
402                None,
403            ),
404        });
405    }
406
407    let fresh_manager = safe_inspect(manager, spec, Phase::Inspect)
408        .map_err(|f| crate::LifecycleUpdateError::Preflight { failure: f })?;
409    if fresh_manager.ownership != baseline.manager_ownership
410        || fresh_manager.state != baseline.manager_state
411    {
412        return Err(crate::LifecycleUpdateError::Preflight {
413            failure: LifecycleFailure::new(
414                spec,
415                Phase::Inspect,
416                "lifecycle authority/state changed before mutation",
417                Some(&fresh_manager),
418            ),
419        });
420    }
421
422    // Direct revalidation when the plan exercises direct control.
423    if planned == UpdateRuntimeDisposition::DirectRunning {
424        let Some(d) = direct.as_ref() else {
425            return Err(crate::LifecycleUpdateError::Preflight {
426                failure: LifecycleFailure::new(
427                    spec,
428                    Phase::Inspect,
429                    "direct control required but not provided",
430                    Some(&fresh_manager),
431                ),
432            });
433        };
434        let fresh_direct = match catch_unwind(AssertUnwindSafe(|| (*d).inspect())) {
435            Ok(Ok(o)) => o,
436            Ok(Err(e)) => {
437                return Err(crate::LifecycleUpdateError::Preflight {
438                    failure: LifecycleFailure::new(spec, Phase::Inspect, e, Some(&fresh_manager)),
439                });
440            }
441            Err(_) => {
442                return Err(crate::LifecycleUpdateError::Preflight {
443                    failure: LifecycleFailure::new(
444                        spec,
445                        Phase::Inspect,
446                        "direct runtime panicked while inspecting",
447                        Some(&fresh_manager),
448                    ),
449                });
450            }
451        };
452        let Some(base_direct) = baseline.direct.as_ref() else {
453            return Err(crate::LifecycleUpdateError::Preflight {
454                failure: LifecycleFailure::new(
455                    spec,
456                    Phase::Inspect,
457                    "direct baseline missing for DirectRunning",
458                    Some(&fresh_manager),
459                ),
460            });
461        };
462        if fresh_direct != *base_direct
463            || !fresh_direct.exact_ownership_proven
464            || fresh_direct.state != DirectState::Running
465        {
466            return Err(crate::LifecycleUpdateError::Preflight {
467                failure: LifecycleFailure::new(
468                    spec,
469                    Phase::Inspect,
470                    "direct runtime identity/state changed before mutation",
471                    Some(&fresh_manager),
472                ),
473            });
474        }
475    }
476
477    let before = fresh_manager;
478    // Keep the direct reference alive across commit via an Option slot that is
479    // reborrowed (never moved) for quiesce, post-commit restore, and rollback.
480    let mut direct_slot: Option<&mut D> = direct;
481    let mut pre_commit_quiesced = false;
482
483    match planned {
484        UpdateRuntimeDisposition::ManagedRunning => {
485            let stop_failure = crate::commit_engine::quiesce_service(
486                manager,
487                spec,
488                &before,
489                policy.quiesce_timeout,
490            )
491            .err();
492            if let Some(f) = stop_failure {
493                let restore = safe_transition_to(
494                    manager,
495                    spec,
496                    LifecycleState::Running,
497                    policy.rollback_restore_timeout,
498                    Phase::Quiesce,
499                    &engine,
500                )
501                .err();
502                return Err(crate::LifecycleUpdateError::Quiesce {
503                    failure: f,
504                    restore_failure: restore,
505                });
506            }
507            pre_commit_quiesced = true;
508            commit_manager_path(
509                manager,
510                spec,
511                before,
512                transaction,
513                ownership,
514                policy,
515                check,
516                planned,
517                pre_commit_quiesced,
518                engine,
519            )
520        }
521        UpdateRuntimeDisposition::DirectRunning => {
522            let Some(d) = direct_slot.as_mut() else {
523                return Err(crate::LifecycleUpdateError::Preflight {
524                    failure: LifecycleFailure::new(
525                        spec,
526                        Phase::Inspect,
527                        "direct control required but not provided",
528                        Some(&before),
529                    ),
530                });
531            };
532            let stop_result = catch_unwind(AssertUnwindSafe(|| (**d).stop(policy.quiesce_timeout)));
533            let stop_failure = match stop_result {
534                Ok(Err(e)) => Some(LifecycleFailure::new(
535                    spec,
536                    Phase::Quiesce,
537                    e,
538                    Some(&before),
539                )),
540                Err(_) => Some(LifecycleFailure::new(
541                    spec,
542                    Phase::Quiesce,
543                    "direct runtime panicked while stopping",
544                    Some(&before),
545                )),
546                Ok(Ok(r)) if !r.completed => Some(LifecycleFailure::new(
547                    spec,
548                    Phase::Quiesce,
549                    "direct stop did not complete",
550                    Some(&before),
551                )),
552                Ok(Ok(_)) => match catch_unwind(AssertUnwindSafe(|| (**d).inspect())) {
553                    Ok(Ok(after))
554                        if after.state == DirectState::Stopped && after.exact_ownership_proven =>
555                    {
556                        pre_commit_quiesced = true;
557                        None
558                    }
559                    Ok(Ok(_)) => Some(LifecycleFailure::new(
560                        spec,
561                        Phase::Quiesce,
562                        "direct runtime state changed after stop",
563                        Some(&before),
564                    )),
565                    Ok(Err(e)) => Some(LifecycleFailure::new(
566                        spec,
567                        Phase::Quiesce,
568                        e,
569                        Some(&before),
570                    )),
571                    Err(_) => Some(LifecycleFailure::new(
572                        spec,
573                        Phase::Quiesce,
574                        "direct runtime panicked while re-observing",
575                        Some(&before),
576                    )),
577                },
578            };
579            if let Some(f) = stop_failure {
580                // Best-effort restore of the prior direct generation.
581                if let Some(d2) = direct_slot.as_mut() {
582                    let _ = catch_unwind(AssertUnwindSafe(|| {
583                        let _ = (**d2).start(policy.rollback_restore_timeout);
584                    }));
585                }
586                return Err(crate::LifecycleUpdateError::Quiesce {
587                    failure: f,
588                    restore_failure: None,
589                });
590            }
591            commit_direct_path(
592                manager,
593                spec,
594                direct_slot,
595                before,
596                transaction,
597                ownership,
598                policy,
599                check,
600                pre_commit_quiesced,
601                engine,
602            )
603        }
604        UpdateRuntimeDisposition::ManagedStopped
605        | UpdateRuntimeDisposition::Stopped
606        | UpdateRuntimeDisposition::ForeignPreserved => commit_manager_path(
607            manager,
608            spec,
609            before,
610            transaction,
611            ownership,
612            policy,
613            check,
614            planned,
615            pre_commit_quiesced,
616            engine,
617        ),
618    }
619}
620
621#[allow(clippy::too_many_arguments)]
622fn commit_manager_path<M, C>(
623    manager: &mut M,
624    spec: &ServiceSpec,
625    before: LifecycleSnapshot,
626    transaction: ValidatedTransaction,
627    ownership: CommitOwnership<'_>,
628    policy: LifecycleUpdatePolicy,
629    check: &C,
630    planned: UpdateRuntimeDisposition,
631    pre_commit_quiesced: bool,
632    engine: CommitEnginePolicy,
633) -> Result<crate::LifecycleUpdateReceipt, crate::LifecycleUpdateError>
634where
635    M: ServiceManager,
636    C: PostInstallCheck,
637{
638    use crate::LifecycleUpdatePhase as Phase;
639    let mut post_commit_failure = None;
640    let mut rollback_quiesce_failure = None;
641    let planned_c = planned;
642    let before_c = before.clone();
643    let core_result =
644        transaction.commit_with_post_commit(ownership, policy.post_commit_failure, || {
645            let deadline = Instant::now() + policy.post_commit_timeout;
646            let work = catch_unwind(AssertUnwindSafe(|| {
647                restore_manager_success(
648                    manager,
649                    spec,
650                    &before_c,
651                    planned_c,
652                    policy.restore,
653                    check,
654                    deadline,
655                    &engine,
656                )
657            }));
658            let f = match work {
659                Ok(Ok(())) => return Ok(()),
660                Ok(Err(f)) => f,
661                Err(_) => LifecycleFailure::new(
662                    spec,
663                    Phase::PostInstallCheck,
664                    "post-commit service work panicked",
665                    None,
666                ),
667            };
668            post_commit_failure = Some(f.clone());
669            if policy.post_commit_failure == PostCommitFailurePolicy::RollBack {
670                rollback_quiesce_failure = match catch_unwind(AssertUnwindSafe(|| {
671                    quiesce_for_rollback(manager, spec, deadline)
672                })) {
673                    Ok(v) => v,
674                    Err(_) => Some(LifecycleFailure::new(
675                        spec,
676                        Phase::QuiesceForRollback,
677                        "service manager panicked while quiescing before artifact rollback",
678                        None,
679                    )),
680                };
681            }
682            Err(PostInstallCheckError::new(f.detail))
683        });
684    let transaction = match core_result {
685        Ok(r) => r,
686        Err(core) => {
687            let restore = if pre_commit_quiesced {
688                safe_transition_to(
689                    manager,
690                    spec,
691                    before.state,
692                    policy.rollback_restore_timeout,
693                    Phase::RestoreOld,
694                    &engine,
695                )
696                .err()
697            } else {
698                None
699            };
700            return Err(crate::LifecycleUpdateError::CoreBeforeReceipt {
701                core,
702                restore_failure: restore,
703            });
704        }
705    };
706    let mut rollback_restore_failure = None;
707    let mut restoration = crate::LifecycleRestorationStatus::Restored;
708    match transaction.disposition() {
709        TransactionDisposition::Committed => {
710            if post_commit_failure
711                .as_ref()
712                .is_some_and(|f| f.phase == Phase::RestoreNew)
713            {
714                restoration = crate::LifecycleRestorationStatus::Failed;
715            }
716        }
717        TransactionDisposition::RolledBack => {
718            let should_restore = matches!(
719                planned,
720                UpdateRuntimeDisposition::ManagedRunning | UpdateRuntimeDisposition::ManagedStopped
721            );
722            if should_restore {
723                if let Err(f) = safe_transition_to(
724                    manager,
725                    spec,
726                    before.state,
727                    policy.rollback_restore_timeout,
728                    Phase::RestoreOld,
729                    &engine,
730                ) {
731                    rollback_restore_failure = Some(f);
732                    restoration = crate::LifecycleRestorationStatus::Failed;
733                }
734            }
735        }
736        TransactionDisposition::RecoveryRequired => {
737            restoration = crate::LifecycleRestorationStatus::NotAttemptedRecoveryRequired;
738        }
739    }
740    let final_snapshot = match safe_inspect(manager, spec, Phase::FinalInspect) {
741        Ok(s) => Some(s),
742        Err(obs) => {
743            return Ok(crate::LifecycleUpdateReceipt {
744                before,
745                final_snapshot: None,
746                transaction,
747                pre_commit_quiesced,
748                restoration,
749                post_commit_failure,
750                rollback_quiesce_failure,
751                rollback_restore_failure,
752                observation_failure: Some(obs),
753                engine_policy: engine,
754            });
755        }
756    };
757    Ok(crate::LifecycleUpdateReceipt {
758        before,
759        final_snapshot,
760        transaction,
761        pre_commit_quiesced,
762        restoration,
763        post_commit_failure,
764        rollback_quiesce_failure,
765        rollback_restore_failure,
766        observation_failure: None,
767        engine_policy: engine,
768    })
769}
770
771#[allow(clippy::too_many_arguments)]
772fn restore_manager_success<M, C>(
773    manager: &mut M,
774    spec: &ServiceSpec,
775    before: &LifecycleSnapshot,
776    planned: UpdateRuntimeDisposition,
777    intent: crate::RestoreIntent,
778    check: &C,
779    deadline: Instant,
780    engine: &CommitEnginePolicy,
781) -> Result<(), crate::LifecycleFailure>
782where
783    M: ServiceManager,
784    C: PostInstallCheck,
785{
786    use crate::LifecycleUpdatePhase as Phase;
787    if planned == UpdateRuntimeDisposition::ForeignPreserved {
788        let snapshot = safe_inspect(manager, spec, Phase::RestoreNew)?;
789        let budget = remaining(deadline);
790        if budget.is_zero() {
791            return Err(LifecycleFailure::new(
792                spec,
793                Phase::PostInstallCheck,
794                "post-commit deadline exhausted before post-install check",
795                Some(&snapshot),
796            ));
797        }
798        return check
799            .check(spec, &snapshot, budget)
800            .map_err(|e| LifecycleFailure::new(spec, Phase::PostInstallCheck, e, Some(&snapshot)));
801    }
802    let wanted = match planned {
803        UpdateRuntimeDisposition::Stopped => match intent {
804            crate::RestoreIntent::EnsureRunning => LifecycleState::Running,
805            _ => LifecycleState::Stopped,
806        },
807        _ => match intent {
808            crate::RestoreIntent::Preserve => before.state,
809            crate::RestoreIntent::EnsureRunning => LifecycleState::Running,
810            crate::RestoreIntent::EnsureStopped => LifecycleState::Stopped,
811        },
812    };
813    restore_and_check(manager, spec, wanted, check, deadline, engine)
814}
815
816#[allow(clippy::too_many_arguments)]
817fn commit_direct_path<M, D, C>(
818    manager: &mut M,
819    spec: &ServiceSpec,
820    mut direct: Option<&mut D>,
821    before: LifecycleSnapshot,
822    transaction: ValidatedTransaction,
823    ownership: CommitOwnership<'_>,
824    policy: LifecycleUpdatePolicy,
825    check: &C,
826    pre_commit_quiesced: bool,
827    engine: CommitEnginePolicy,
828) -> Result<crate::LifecycleUpdateReceipt, crate::LifecycleUpdateError>
829where
830    M: ServiceManager,
831    D: DirectRuntimeControl,
832    C: PostInstallCheck,
833{
834    use crate::LifecycleUpdatePhase as Phase;
835    let mut post_commit_failure = None;
836    let mut rollback_quiesce_failure = None;
837    let before_c = before.clone();
838    let core_result =
839        transaction.commit_with_post_commit(ownership, policy.post_commit_failure, || {
840            let deadline = Instant::now() + policy.post_commit_timeout;
841            // Restore the direct generation per Preserve/Ensure policy, then check.
842            let wanted = match policy.restore {
843                crate::RestoreIntent::EnsureStopped => DirectState::Stopped,
844                _ => DirectState::Running,
845            };
846            let work = catch_unwind(AssertUnwindSafe(|| {
847                // The `RestoreNew` work is caught separately from the check, so a
848                // panicking direct `start` is recorded under the phase that was
849                // actually executing. The outer panic arm can then only be
850                // reached by the check itself.
851                let restored = catch_unwind(AssertUnwindSafe(
852                    || -> Result<LifecycleSnapshot, crate::LifecycleFailure> {
853                        if wanted == DirectState::Running {
854                            let budget = remaining(deadline);
855                            if budget.is_zero() {
856                                return Err(LifecycleFailure::new(
857                                    spec,
858                                    Phase::RestoreNew,
859                                    "lifecycle operation deadline exhausted",
860                                    Some(&before_c),
861                                ));
862                            }
863                            let Some(d) = direct.as_mut() else {
864                                return Err(LifecycleFailure::new(
865                                    spec,
866                                    Phase::RestoreNew,
867                                    "direct control missing during restore",
868                                    Some(&before_c),
869                                ));
870                            };
871                            let r = (**d).start(budget).map_err(|e| {
872                                LifecycleFailure::new(spec, Phase::RestoreNew, e, Some(&before_c))
873                            })?;
874                            if !r.completed {
875                                return Err(LifecycleFailure::new(
876                                    spec,
877                                    Phase::RestoreNew,
878                                    "direct transition did not complete",
879                                    Some(&before_c),
880                                ));
881                            }
882                        }
883                        // Read-only manager observation for the check snapshot; direct
884                        // state is caller-owned and not part of LifecycleSnapshot.
885                        safe_inspect(manager, spec, Phase::RestoreNew)
886                    },
887                ));
888                let snapshot = match restored {
889                    Ok(Ok(snapshot)) => snapshot,
890                    Ok(Err(failure)) => return Err(failure),
891                    Err(_) => {
892                        return Err(LifecycleFailure::new(
893                            spec,
894                            Phase::RestoreNew,
895                            "direct runtime panicked while restoring",
896                            Some(&before_c),
897                        ))
898                    }
899                };
900                let budget = remaining(deadline);
901                if budget.is_zero() {
902                    return Err(LifecycleFailure::new(
903                        spec,
904                        Phase::PostInstallCheck,
905                        "post-commit deadline exhausted before post-install check",
906                        Some(&snapshot),
907                    ));
908                }
909                check.check(spec, &snapshot, budget).map_err(|e| {
910                    LifecycleFailure::new(spec, Phase::PostInstallCheck, e, Some(&snapshot))
911                })
912            }));
913            let f = match work {
914                Ok(Ok(())) => return Ok(()),
915                Ok(Err(f)) => f,
916                Err(_) => LifecycleFailure::new(
917                    spec,
918                    Phase::PostInstallCheck,
919                    "post-commit direct work panicked",
920                    None,
921                ),
922            };
923            post_commit_failure = Some(f.clone());
924            if policy.post_commit_failure == PostCommitFailurePolicy::RollBack {
925                rollback_quiesce_failure = match catch_unwind(AssertUnwindSafe(|| {
926                    quiesce_direct_for_rollback(direct.as_deref_mut(), spec, deadline)
927                })) {
928                    Ok(v) => v,
929                    Err(_) => Some(LifecycleFailure::new(
930                        spec,
931                        Phase::QuiesceForRollback,
932                        "direct runtime panicked while quiescing before artifact rollback",
933                        None,
934                    )),
935                };
936            }
937            Err(PostInstallCheckError::new(f.detail))
938        });
939    let transaction = match core_result {
940        Ok(r) => r,
941        Err(core) => {
942            // Best-effort restore of the prior direct generation on pre-receipt Core error.
943            if pre_commit_quiesced {
944                if let Some(d) = direct.as_mut() {
945                    let _ = catch_unwind(AssertUnwindSafe(|| {
946                        let _ = (**d).start(policy.rollback_restore_timeout);
947                    }));
948                }
949            }
950            return Err(crate::LifecycleUpdateError::CoreBeforeReceipt {
951                core,
952                restore_failure: None,
953            });
954        }
955    };
956    let mut rollback_restore_failure = None;
957    let mut restoration = crate::LifecycleRestorationStatus::Restored;
958    match transaction.disposition() {
959        TransactionDisposition::Committed => {
960            if post_commit_failure
961                .as_ref()
962                .is_some_and(|f| f.phase == Phase::RestoreNew)
963            {
964                restoration = crate::LifecycleRestorationStatus::Failed;
965            }
966        }
967        TransactionDisposition::RolledBack => {
968            // Restore the prior direct generation (was Running).
969            if let Some(d) = direct.as_mut() {
970                let r = catch_unwind(AssertUnwindSafe(|| {
971                    (**d).start(policy.rollback_restore_timeout)
972                }));
973                match r {
974                    Ok(Ok(res)) if res.completed => {}
975                    Ok(Ok(_)) => {
976                        rollback_restore_failure = Some(LifecycleFailure::new(
977                            spec,
978                            Phase::RestoreOld,
979                            "direct transition did not complete",
980                            Some(&before),
981                        ));
982                        restoration = crate::LifecycleRestorationStatus::Failed;
983                    }
984                    Ok(Err(e)) => {
985                        rollback_restore_failure = Some(LifecycleFailure::new(
986                            spec,
987                            Phase::RestoreOld,
988                            e,
989                            Some(&before),
990                        ));
991                        restoration = crate::LifecycleRestorationStatus::Failed;
992                    }
993                    Err(_) => {
994                        rollback_restore_failure = Some(LifecycleFailure::new(
995                            spec,
996                            Phase::RestoreOld,
997                            "direct runtime panicked while restoring",
998                            Some(&before),
999                        ));
1000                        restoration = crate::LifecycleRestorationStatus::Failed;
1001                    }
1002                }
1003            }
1004        }
1005        TransactionDisposition::RecoveryRequired => {
1006            restoration = crate::LifecycleRestorationStatus::NotAttemptedRecoveryRequired;
1007        }
1008    }
1009    // Final manager observation is read-only and nonessential; direct final
1010    // state is caller-observed and not part of the neutral receipt.
1011    let final_snapshot = match safe_inspect(manager, spec, Phase::FinalInspect) {
1012        Ok(s) => Some(s),
1013        Err(obs) => {
1014            return Ok(crate::LifecycleUpdateReceipt {
1015                before,
1016                final_snapshot: None,
1017                transaction,
1018                pre_commit_quiesced,
1019                restoration,
1020                post_commit_failure,
1021                rollback_quiesce_failure,
1022                rollback_restore_failure,
1023                observation_failure: Some(obs),
1024                engine_policy: engine,
1025            });
1026        }
1027    };
1028    Ok(crate::LifecycleUpdateReceipt {
1029        before,
1030        final_snapshot,
1031        transaction,
1032        pre_commit_quiesced,
1033        restoration,
1034        post_commit_failure,
1035        rollback_quiesce_failure,
1036        rollback_restore_failure,
1037        observation_failure: None,
1038        engine_policy: engine,
1039    })
1040}
1041
1042fn quiesce_direct_for_rollback<D: DirectRuntimeControl>(
1043    direct: Option<&mut D>,
1044    spec: &ServiceSpec,
1045    deadline: Instant,
1046) -> Option<crate::LifecycleFailure> {
1047    use crate::LifecycleUpdatePhase as Phase;
1048    let budget = remaining(deadline);
1049    if budget.is_zero() {
1050        return Some(LifecycleFailure::new(
1051            spec,
1052            Phase::QuiesceForRollback,
1053            "post-commit deadline exhausted before rollback quiescence",
1054            None,
1055        ));
1056    }
1057    let Some(d) = direct else {
1058        return Some(LifecycleFailure::new(
1059            spec,
1060            Phase::QuiesceForRollback,
1061            "direct control missing before artifact rollback",
1062            None,
1063        ));
1064    };
1065    // If already stopped with proven ownership, nothing to do. An inspect
1066    // failure is not "no information, proceed": `DirectRuntimeControl` is a
1067    // caller-supplied seam with no second ownership check inside `stop`, so an
1068    // unobservable runtime must fail closed rather than be stopped blind.
1069    match d.inspect() {
1070        Ok(obs) => {
1071            if obs.state == DirectState::Stopped && obs.exact_ownership_proven {
1072                return None;
1073            }
1074            if !obs.exact_ownership_proven {
1075                return Some(LifecycleFailure::new(
1076                    spec,
1077                    Phase::QuiesceForRollback,
1078                    "refusing to quiesce unproven direct runtime before rollback",
1079                    None,
1080                ));
1081            }
1082        }
1083        Err(e) => {
1084            return Some(LifecycleFailure::new(
1085                spec,
1086                Phase::QuiesceForRollback,
1087                format!("refusing to quiesce unobservable direct runtime before rollback: {e}"),
1088                None,
1089            ))
1090        }
1091    }
1092    match d.stop(budget) {
1093        Err(e) => Some(LifecycleFailure::new(
1094            spec,
1095            Phase::QuiesceForRollback,
1096            e,
1097            None,
1098        )),
1099        Ok(r) if !r.completed => Some(LifecycleFailure::new(
1100            spec,
1101            Phase::QuiesceForRollback,
1102            "direct stop did not complete before artifact rollback",
1103            None,
1104        )),
1105        Ok(_) => None,
1106    }
1107}
1108
1109#[cfg(test)]
1110mod tests {
1111    use super::*;
1112    use crate::ManagerFailureKind;
1113    use crate::{
1114        NoPostInstallCheck, PostInstallCheckError, RestoreIntent, ServiceError, ServiceId,
1115        TestDoubleManager, TransitionResult,
1116    };
1117    use eggup_core::{
1118        AllValidators, ArtifactMember, ArtifactSet, InstallPlan, MemberId,
1119        PostCommitFailurePolicy as CorePolicy,
1120    };
1121    use std::cell::RefCell;
1122    use std::rc::Rc;
1123    use std::sync::atomic::{AtomicU64, Ordering};
1124
1125    fn direct_obs(state: DirectState, proven: bool) -> DirectObservation {
1126        DirectObservation {
1127            state,
1128            exact_ownership_proven: proven,
1129            executable: Some(crate::absolute("/opt/app/service.bin")),
1130            config: Some(crate::absolute("/etc/app/config.toml")),
1131        }
1132    }
1133
1134    fn unix_input(
1135        ownership: Ownership,
1136        active: bool,
1137        known: bool,
1138        registered: KnownConfig,
1139        selected: Option<PathBuf>,
1140        direct_state: DirectState,
1141        proven: bool,
1142    ) -> UnixPlannerInput {
1143        UnixPlannerInput {
1144            manager_ownership: ownership,
1145            manager_active: active,
1146            manager_state_known: known,
1147            registered_config: registered,
1148            selected_config: selected,
1149            direct: direct_obs(direct_state, proven),
1150        }
1151    }
1152
1153    #[test]
1154    fn unix_reference_matrix() {
1155        let cfg = crate::absolute("/etc/app/config.toml");
1156        let other = crate::absolute("/etc/other/config.toml");
1157        // Owned + active -> ManagedRunning.
1158        assert_eq!(
1159            plan_unix(&unix_input(
1160                Ownership::Owned,
1161                true,
1162                true,
1163                KnownConfig::Absent,
1164                None,
1165                DirectState::Stopped,
1166                false
1167            ))
1168            .unwrap(),
1169            UpdateRuntimeDisposition::ManagedRunning
1170        );
1171        // Owned + inactive -> ManagedStopped.
1172        assert_eq!(
1173            plan_unix(&unix_input(
1174                Ownership::Owned,
1175                false,
1176                true,
1177                KnownConfig::Absent,
1178                None,
1179                DirectState::Stopped,
1180                false
1181            ))
1182            .unwrap(),
1183            UpdateRuntimeDisposition::ManagedStopped
1184        );
1185        // Foreign + active + registered == selected -> ForeignPreserved.
1186        assert_eq!(
1187            plan_unix(&unix_input(
1188                Ownership::Foreign,
1189                true,
1190                true,
1191                KnownConfig::Present(cfg.clone()),
1192                Some(cfg.clone()),
1193                DirectState::Stopped,
1194                false
1195            ))
1196            .unwrap(),
1197            UpdateRuntimeDisposition::ForeignPreserved
1198        );
1199        // Foreign + active + different + direct running -> DirectRunning.
1200        assert_eq!(
1201            plan_unix(&unix_input(
1202                Ownership::Foreign,
1203                true,
1204                true,
1205                KnownConfig::Present(cfg.clone()),
1206                Some(other.clone()),
1207                DirectState::Running,
1208                true
1209            ))
1210            .unwrap(),
1211            UpdateRuntimeDisposition::DirectRunning
1212        );
1213        // Foreign + active + different + direct stopped -> Stopped.
1214        assert_eq!(
1215            plan_unix(&unix_input(
1216                Ownership::Foreign,
1217                true,
1218                true,
1219                KnownConfig::Present(cfg.clone()),
1220                Some(other.clone()),
1221                DirectState::Stopped,
1222                false
1223            ))
1224            .unwrap(),
1225            UpdateRuntimeDisposition::Stopped
1226        );
1227        // Foreign + active + unknown registered -> error.
1228        assert!(plan_unix(&unix_input(
1229            Ownership::Foreign,
1230            true,
1231            true,
1232            KnownConfig::Unknown,
1233            Some(cfg.clone()),
1234            DirectState::Stopped,
1235            false
1236        ))
1237        .is_err());
1238        // Foreign + inactive + direct running -> DirectRunning.
1239        assert_eq!(
1240            plan_unix(&unix_input(
1241                Ownership::Foreign,
1242                false,
1243                true,
1244                KnownConfig::Present(cfg.clone()),
1245                Some(other.clone()),
1246                DirectState::Running,
1247                true
1248            ))
1249            .unwrap(),
1250            UpdateRuntimeDisposition::DirectRunning
1251        );
1252        // Foreign + inactive + direct stopped -> Stopped.
1253        assert_eq!(
1254            plan_unix(&unix_input(
1255                Ownership::Foreign,
1256                false,
1257                true,
1258                KnownConfig::Present(cfg.clone()),
1259                Some(other.clone()),
1260                DirectState::Stopped,
1261                false
1262            ))
1263            .unwrap(),
1264            UpdateRuntimeDisposition::Stopped
1265        );
1266        // Absent + active -> error.
1267        assert!(plan_unix(&unix_input(
1268            Ownership::Absent,
1269            true,
1270            true,
1271            KnownConfig::Absent,
1272            None,
1273            DirectState::Stopped,
1274            false
1275        ))
1276        .is_err());
1277        // Absent + inactive + direct running -> DirectRunning.
1278        assert_eq!(
1279            plan_unix(&unix_input(
1280                Ownership::Absent,
1281                false,
1282                true,
1283                KnownConfig::Absent,
1284                None,
1285                DirectState::Running,
1286                true
1287            ))
1288            .unwrap(),
1289            UpdateRuntimeDisposition::DirectRunning
1290        );
1291        // Absent + inactive + direct stopped -> Stopped.
1292        assert_eq!(
1293            plan_unix(&unix_input(
1294                Ownership::Absent,
1295                false,
1296                true,
1297                KnownConfig::Absent,
1298                None,
1299                DirectState::Stopped,
1300                false
1301            ))
1302            .unwrap(),
1303            UpdateRuntimeDisposition::Stopped
1304        );
1305        // Unknown + active -> error.
1306        assert!(plan_unix(&unix_input(
1307            Ownership::Unknown,
1308            true,
1309            true,
1310            KnownConfig::Absent,
1311            None,
1312            DirectState::Stopped,
1313            false
1314        ))
1315        .is_err());
1316        // Unknown + inactive + direct running -> error.
1317        assert!(plan_unix(&unix_input(
1318            Ownership::Unknown,
1319            false,
1320            true,
1321            KnownConfig::Absent,
1322            None,
1323            DirectState::Running,
1324            true
1325        ))
1326        .is_err());
1327        // Unknown + inactive + direct stopped -> Stopped.
1328        assert_eq!(
1329            plan_unix(&unix_input(
1330                Ownership::Unknown,
1331                false,
1332                true,
1333                KnownConfig::Absent,
1334                None,
1335                DirectState::Stopped,
1336                false
1337            ))
1338            .unwrap(),
1339            UpdateRuntimeDisposition::Stopped
1340        );
1341        // No Gregg product strings in errors.
1342        let err = plan_unix(&unix_input(
1343            Ownership::Absent,
1344            true,
1345            true,
1346            KnownConfig::Absent,
1347            None,
1348            DirectState::Stopped,
1349            false,
1350        ))
1351        .unwrap_err();
1352        let msg = format!("{err}").to_lowercase();
1353        assert!(!msg.contains("gregg"));
1354        assert!(!msg.contains("greggd"));
1355    }
1356
1357    #[test]
1358    fn windows_reference_matrix() {
1359        let w = |installed: bool, known: bool, ownership: Ownership, state: WindowsServiceState| {
1360            plan_windows(&WindowsPlannerInput {
1361                installed,
1362                executable_known: known,
1363                ownership,
1364                state,
1365            })
1366        };
1367        // Not installed -> Stopped.
1368        assert_eq!(
1369            w(
1370                false,
1371                false,
1372                Ownership::Absent,
1373                WindowsServiceState::Unknown
1374            )
1375            .unwrap(),
1376            UpdateRuntimeDisposition::Stopped
1377        );
1378        // Registration executable absent/unparseable -> error.
1379        assert!(w(
1380            true,
1381            false,
1382            Ownership::Unknown,
1383            WindowsServiceState::Running
1384        )
1385        .is_err());
1386        // Foreign executable -> ForeignPreserved.
1387        assert_eq!(
1388            w(true, true, Ownership::Foreign, WindowsServiceState::Running).unwrap(),
1389            UpdateRuntimeDisposition::ForeignPreserved
1390        );
1391        // Owned Running/StartPending -> ManagedRunning.
1392        assert_eq!(
1393            w(true, true, Ownership::Owned, WindowsServiceState::Running).unwrap(),
1394            UpdateRuntimeDisposition::ManagedRunning
1395        );
1396        assert_eq!(
1397            w(
1398                true,
1399                true,
1400                Ownership::Owned,
1401                WindowsServiceState::StartPending
1402            )
1403            .unwrap(),
1404            UpdateRuntimeDisposition::ManagedRunning
1405        );
1406        // Owned Stopped/StopPending -> ManagedStopped.
1407        assert_eq!(
1408            w(true, true, Ownership::Owned, WindowsServiceState::Stopped).unwrap(),
1409            UpdateRuntimeDisposition::ManagedStopped
1410        );
1411        assert_eq!(
1412            w(
1413                true,
1414                true,
1415                Ownership::Owned,
1416                WindowsServiceState::StopPending
1417            )
1418            .unwrap(),
1419            UpdateRuntimeDisposition::ManagedStopped
1420        );
1421    }
1422
1423    #[derive(Debug)]
1424    struct FakeDirect {
1425        obs: DirectObservation,
1426        events: Rc<RefCell<Vec<&'static str>>>,
1427        fail_stop: bool,
1428        fail_start: bool,
1429        fail_inspect: bool,
1430        drift_after_stop: bool,
1431    }
1432
1433    impl FakeDirect {
1434        fn running(events: Rc<RefCell<Vec<&'static str>>>) -> Self {
1435            Self {
1436                obs: direct_obs(DirectState::Running, true),
1437                events,
1438                fail_stop: false,
1439                fail_start: false,
1440                fail_inspect: false,
1441                drift_after_stop: false,
1442            }
1443        }
1444    }
1445
1446    impl DirectRuntimeControl for FakeDirect {
1447        fn inspect(&self) -> Result<DirectObservation, ServiceError> {
1448            self.events.borrow_mut().push("direct-inspect");
1449            if self.fail_inspect {
1450                return Err(ServiceError::manager(
1451                    ManagerFailureKind::Protocol,
1452                    "injected unobservable direct runtime",
1453                ));
1454            }
1455            Ok(self.obs.clone())
1456        }
1457
1458        fn stop(&mut self, _timeout: Duration) -> Result<TransitionResult, ServiceError> {
1459            self.events.borrow_mut().push("direct-stop");
1460            if self.fail_stop {
1461                return Err(ServiceError::manager(
1462                    ManagerFailureKind::Protocol,
1463                    "injected direct stop failure",
1464                ));
1465            }
1466            self.obs.state = DirectState::Stopped;
1467            if self.drift_after_stop {
1468                self.obs.executable = Some(crate::absolute("/different/service.bin"));
1469                self.obs.exact_ownership_proven = false;
1470            }
1471            Ok(TransitionResult {
1472                operation: crate::ServiceOperation::Stop,
1473                completed: true,
1474                detail: "direct stopped".into(),
1475            })
1476        }
1477
1478        fn start(&mut self, _timeout: Duration) -> Result<TransitionResult, ServiceError> {
1479            self.events.borrow_mut().push("direct-start");
1480            if self.fail_start {
1481                return Err(ServiceError::manager(
1482                    ManagerFailureKind::Protocol,
1483                    "injected direct start failure",
1484                ));
1485            }
1486            self.obs.state = DirectState::Running;
1487            self.obs.exact_ownership_proven = true;
1488            Ok(TransitionResult {
1489                operation: crate::ServiceOperation::Start,
1490                completed: true,
1491                detail: "direct started".into(),
1492            })
1493        }
1494    }
1495
1496    static NEXT: AtomicU64 = AtomicU64::new(0);
1497
1498    /// A manager that cannot be observed, so ownership can never be proven.
1499    #[derive(Debug)]
1500    struct UnobservableManager {
1501        inner: TestDoubleManager,
1502        events: Rc<RefCell<Vec<&'static str>>>,
1503    }
1504
1505    impl ServiceManager for UnobservableManager {
1506        fn inspect(&self, _spec: &ServiceSpec) -> Result<LifecycleSnapshot, ServiceError> {
1507            self.events.borrow_mut().push("inspect");
1508            Err(ServiceError::manager(
1509                ManagerFailureKind::Protocol,
1510                "injected unobservable service",
1511            ))
1512        }
1513
1514        fn install(&mut self, spec: &ServiceSpec) -> Result<TransitionResult, ServiceError> {
1515            self.events.borrow_mut().push("install");
1516            self.inner.install(spec)
1517        }
1518
1519        fn start(
1520            &mut self,
1521            spec: &ServiceSpec,
1522            timeout: Duration,
1523        ) -> Result<TransitionResult, ServiceError> {
1524            self.events.borrow_mut().push("start");
1525            self.inner.start(spec, timeout)
1526        }
1527
1528        fn stop(
1529            &mut self,
1530            spec: &ServiceSpec,
1531            timeout: Duration,
1532        ) -> Result<TransitionResult, ServiceError> {
1533            self.events.borrow_mut().push("stop");
1534            self.inner.stop(spec, timeout)
1535        }
1536
1537        fn restart(
1538            &mut self,
1539            spec: &ServiceSpec,
1540            timeout: Duration,
1541        ) -> Result<TransitionResult, ServiceError> {
1542            self.events.borrow_mut().push("restart");
1543            self.inner.restart(spec, timeout)
1544        }
1545
1546        fn uninstall(&mut self, spec: &ServiceSpec) -> Result<TransitionResult, ServiceError> {
1547            self.events.borrow_mut().push("uninstall");
1548            self.inner.uninstall(spec)
1549        }
1550    }
1551
1552    #[test]
1553    fn unobservable_direct_runtime_is_not_stopped_before_rollback() {
1554        use crate::LifecycleUpdatePhase as Phase;
1555
1556        let events = Rc::new(RefCell::new(Vec::new()));
1557        let mut direct = FakeDirect::running(events.clone());
1558        direct.fail_inspect = true;
1559        let spec = ServiceSpec::new(
1560            crate::ServiceId::new("unobservable").unwrap(),
1561            std::env::current_exe().unwrap(),
1562            Vec::new(),
1563            None,
1564        )
1565        .unwrap();
1566
1567        let failure = quiesce_direct_for_rollback(
1568            Some(&mut direct),
1569            &spec,
1570            Instant::now() + Duration::from_secs(5),
1571        )
1572        .expect("an unobservable direct runtime must refuse to quiesce");
1573        assert_eq!(failure.phase, Phase::QuiesceForRollback);
1574        let events = events.borrow();
1575        assert!(
1576            events.iter().all(|e| *e != "direct-stop"),
1577            "no destructive stop may be issued without proven ownership, got {events:?}"
1578        );
1579    }
1580
1581    #[test]
1582    fn unobservable_service_is_not_stopped_before_rollback() {
1583        use crate::LifecycleUpdatePhase as Phase;
1584
1585        let events = Rc::new(RefCell::new(Vec::new()));
1586        let spec = ServiceSpec::new(
1587            crate::ServiceId::new("unobservable").unwrap(),
1588            std::env::current_exe().unwrap(),
1589            Vec::new(),
1590            None,
1591        )
1592        .unwrap();
1593        let mut manager = UnobservableManager {
1594            inner: TestDoubleManager::new(),
1595            events: events.clone(),
1596        };
1597
1598        let failure =
1599            quiesce_for_rollback(&mut manager, &spec, Instant::now() + Duration::from_secs(5))
1600                .expect("an unobservable service must refuse to quiesce");
1601        assert_eq!(failure.phase, Phase::QuiesceForRollback);
1602        let events = events.borrow();
1603        assert!(
1604            events.iter().all(|e| *e != "stop"),
1605            "no destructive stop may be issued without proven ownership, got {events:?}"
1606        );
1607    }
1608
1609    fn setup() -> (TempfileGuard, std::path::PathBuf, ValidatedTransaction) {
1610        let base = std::env::temp_dir().join(format!(
1611            "eggup-disposition-{}-{}",
1612            std::process::id(),
1613            NEXT.fetch_add(1, Ordering::Relaxed)
1614        ));
1615        let source_root = base.join("input");
1616        let install_root = base.join("install");
1617        std::fs::create_dir_all(&source_root).unwrap();
1618        std::fs::create_dir_all(&install_root).unwrap();
1619        let main = source_root.join("main");
1620        let sidecar = source_root.join("sidecar");
1621        std::fs::write(&main, b"new-main").unwrap();
1622        std::fs::write(&sidecar, b"new-sidecar").unwrap();
1623        std::fs::write(install_root.join("service.bin"), b"old-main").unwrap();
1624        std::fs::write(install_root.join("sidecar.bin"), b"old-sidecar").unwrap();
1625        let members = ArtifactSet::new(vec![
1626            ArtifactMember::new(MemberId::new("main").unwrap(), &main, "service.bin")
1627                .unwrap()
1628                .with_permissions(eggup_core::PermissionsIntent::Executable)
1629                .with_integrity(eggup_core::IntegrityRequirement::Sha256(
1630                    eggup_core::hash_file(&main).unwrap(),
1631                )),
1632            ArtifactMember::new(MemberId::new("sidecar").unwrap(), &sidecar, "sidecar.bin")
1633                .unwrap()
1634                .with_integrity(eggup_core::IntegrityRequirement::Sha256(
1635                    eggup_core::hash_file(&sidecar).unwrap(),
1636                )),
1637        ])
1638        .unwrap();
1639        let validated = InstallPlan::new(
1640            eggup_core::ProductId::new("disposition-test").unwrap(),
1641            eggup_core::ReleaseId::new("r2").unwrap(),
1642            &install_root,
1643            members,
1644        )
1645        .unwrap()
1646        .prepare()
1647        .unwrap()
1648        .verify_integrity()
1649        .unwrap()
1650        .validate(&AllValidators::new())
1651        .unwrap();
1652        (
1653            TempfileGuard { path: base.clone() },
1654            install_root,
1655            validated,
1656        )
1657    }
1658
1659    struct TempfileGuard {
1660        path: std::path::PathBuf,
1661    }
1662
1663    impl Drop for TempfileGuard {
1664        fn drop(&mut self) {
1665            let _ = std::fs::remove_dir_all(&self.path);
1666        }
1667    }
1668
1669    fn service_spec(install_root: &std::path::Path) -> ServiceSpec {
1670        ServiceSpec::new(
1671            ServiceId::new("disposition-test").unwrap(),
1672            install_root.join("service.bin"),
1673            vec!["--worker".into()],
1674            None,
1675        )
1676        .unwrap()
1677    }
1678
1679    fn ownership_proof(_install_root: &std::path::Path) -> eggup_core::CommitOwnership<'static> {
1680        use eggup_core::OwnershipVerifier;
1681        struct Fixed(eggup_core::Ownership);
1682        impl OwnershipVerifier for Fixed {
1683            fn verify(
1684                &self,
1685                _member: &eggup_core::MemberId,
1686                _destination: &std::path::Path,
1687            ) -> eggup_core::Ownership {
1688                self.0
1689            }
1690        }
1691        static VERIFIER: Fixed = Fixed(eggup_core::Ownership::Owned);
1692        eggup_core::CommitOwnership::new(&VERIFIER, eggup_core::AbsentPolicy::AllowCreate)
1693    }
1694
1695    fn policy() -> LifecycleUpdatePolicy {
1696        LifecycleUpdatePolicy {
1697            restore: RestoreIntent::Preserve,
1698            post_commit_failure: CorePolicy::KeepInstalled,
1699            quiesce_timeout: Duration::from_secs(2),
1700            post_commit_timeout: Duration::from_secs(2),
1701            rollback_restore_timeout: Duration::from_secs(2),
1702        }
1703    }
1704
1705    #[test]
1706    fn managed_running_stop_commit_restart_ordering() {
1707        let (_guard, install_root, validated) = setup();
1708        let spec = service_spec(&install_root);
1709        let mut manager = TestDoubleManager::new();
1710        manager.put(spec.clone(), crate::LifecycleState::Running);
1711        let baseline = DispositionBaseline {
1712            manager_ownership: Ownership::Owned,
1713            manager_state: crate::LifecycleState::Running,
1714            direct: None,
1715        };
1716        let receipt = commit_with_disposition(
1717            &mut manager,
1718            &spec,
1719            None::<&mut FakeDirect>,
1720            validated,
1721            ownership_proof(&install_root),
1722            policy(),
1723            &NoPostInstallCheck,
1724            UpdateRuntimeDisposition::ManagedRunning,
1725            &baseline,
1726        )
1727        .expect("managed running");
1728        assert!(receipt.pre_commit_quiesced);
1729        assert!(receipt.service_state_restored());
1730        assert_eq!(
1731            receipt.artifact_disposition(),
1732            eggup_core::TransactionDisposition::Committed
1733        );
1734    }
1735
1736    #[test]
1737    fn managed_stopped_stays_stopped_under_preserve() {
1738        let (_guard, install_root, validated) = setup();
1739        let spec = service_spec(&install_root);
1740        let mut manager = TestDoubleManager::new();
1741        manager.put(spec.clone(), crate::LifecycleState::Stopped);
1742        let baseline = DispositionBaseline {
1743            manager_ownership: Ownership::Owned,
1744            manager_state: crate::LifecycleState::Stopped,
1745            direct: None,
1746        };
1747        let receipt = commit_with_disposition(
1748            &mut manager,
1749            &spec,
1750            None::<&mut FakeDirect>,
1751            validated,
1752            ownership_proof(&install_root),
1753            policy(),
1754            &NoPostInstallCheck,
1755            UpdateRuntimeDisposition::ManagedStopped,
1756            &baseline,
1757        )
1758        .unwrap();
1759        assert!(!receipt.pre_commit_quiesced);
1760        let final_state = receipt.final_snapshot.unwrap().state;
1761        assert_eq!(final_state, crate::LifecycleState::Stopped);
1762    }
1763
1764    #[test]
1765    fn stopped_fabricates_no_restart() {
1766        let (_guard, install_root, validated) = setup();
1767        let spec = ServiceSpec::new(
1768            ServiceId::new("absent-service").unwrap(),
1769            install_root.join("service.bin"),
1770            vec!["--worker".into()],
1771            None,
1772        )
1773        .unwrap();
1774        let mut manager = TestDoubleManager::new();
1775        let baseline = DispositionBaseline {
1776            manager_ownership: Ownership::Absent,
1777            manager_state: crate::LifecycleState::Stopped,
1778            direct: Some(direct_obs(DirectState::Stopped, true)),
1779        };
1780        let receipt = commit_with_disposition(
1781            &mut manager,
1782            &spec,
1783            None::<&mut FakeDirect>,
1784            validated,
1785            ownership_proof(&install_root),
1786            policy(),
1787            &NoPostInstallCheck,
1788            UpdateRuntimeDisposition::Stopped,
1789            &baseline,
1790        )
1791        .unwrap();
1792        assert!(!receipt.pre_commit_quiesced);
1793        assert_eq!(
1794            receipt.artifact_disposition(),
1795            eggup_core::TransactionDisposition::Committed
1796        );
1797    }
1798
1799    #[test]
1800    fn foreign_preserved_performs_zero_manager_mutation() {
1801        let (_guard, install_root, validated) = setup();
1802        // Foreign registration: same id, different executable.
1803        let foreign_spec = ServiceSpec::new(
1804            ServiceId::new("disposition-test").unwrap(),
1805            crate::absolute("/foreign/service.bin"),
1806            vec!["--worker".into()],
1807            None,
1808        )
1809        .unwrap();
1810        let mut manager = TestDoubleManager::new();
1811        manager.put(foreign_spec.clone(), crate::LifecycleState::Running);
1812        // Our spec expects the test executable, so ownership is Foreign.
1813        let spec = service_spec(&install_root);
1814        let baseline = DispositionBaseline {
1815            manager_ownership: Ownership::Foreign,
1816            manager_state: crate::LifecycleState::Running,
1817            direct: None,
1818        };
1819        let receipt = commit_with_disposition(
1820            &mut manager,
1821            &spec,
1822            None::<&mut FakeDirect>,
1823            validated,
1824            ownership_proof(&install_root),
1825            policy(),
1826            &NoPostInstallCheck,
1827            UpdateRuntimeDisposition::ForeignPreserved,
1828            &baseline,
1829        )
1830        .unwrap();
1831        assert!(!receipt.pre_commit_quiesced);
1832        // Manager registration unchanged (still foreign, still running).
1833        let after = manager.inspect(&spec).unwrap();
1834        assert_eq!(after.ownership, Ownership::Foreign);
1835        assert_eq!(
1836            receipt.artifact_disposition(),
1837            eggup_core::TransactionDisposition::Committed
1838        );
1839    }
1840
1841    #[test]
1842    fn direct_running_uses_only_direct_seam() {
1843        let (_guard, install_root, validated) = setup();
1844        let spec = service_spec(&install_root);
1845        // Manager is Foreign and untouched; direct is Running.
1846        let foreign = ServiceSpec::new(
1847            spec.id().clone(),
1848            crate::absolute("/foreign/service.bin"),
1849            spec.args().to_vec(),
1850            None,
1851        )
1852        .unwrap();
1853        let mut manager = TestDoubleManager::new();
1854        manager.put(foreign, crate::LifecycleState::Running);
1855        let events = Rc::new(RefCell::new(Vec::new()));
1856        let mut direct = FakeDirect::running(events.clone());
1857        let baseline = DispositionBaseline {
1858            manager_ownership: Ownership::Foreign,
1859            manager_state: crate::LifecycleState::Running,
1860            direct: Some(direct_obs(DirectState::Running, true)),
1861        };
1862        let receipt = commit_with_disposition(
1863            &mut manager,
1864            &spec,
1865            Some(&mut direct),
1866            validated,
1867            ownership_proof(&install_root),
1868            policy(),
1869            &NoPostInstallCheck,
1870            UpdateRuntimeDisposition::DirectRunning,
1871            &baseline,
1872        )
1873        .unwrap();
1874        assert!(receipt.pre_commit_quiesced);
1875        let ev = events.borrow().clone();
1876        assert!(ev.contains(&"direct-stop"));
1877        assert!(ev.contains(&"direct-start"));
1878        // Manager still foreign (zero manager mutation).
1879        let after = manager.inspect(&spec).unwrap();
1880        assert_eq!(after.ownership, Ownership::Foreign);
1881    }
1882
1883    #[test]
1884    fn owned_to_foreign_revalidation_fails_before_stop() {
1885        let (_guard, install_root, validated) = setup();
1886        let spec = service_spec(&install_root);
1887        let mut manager = TestDoubleManager::new();
1888        manager.put(spec.clone(), crate::LifecycleState::Running);
1889        // Baseline says Owned+Running, but manager drifts to Foreign before
1890        // orchestration observes (simulated by replacing the registration).
1891        let foreign = ServiceSpec::new(
1892            spec.id().clone(),
1893            crate::absolute("/different/service-executable"),
1894            spec.args().to_vec(),
1895            None,
1896        )
1897        .unwrap();
1898        manager.put(foreign, crate::LifecycleState::Running);
1899        let baseline = DispositionBaseline {
1900            manager_ownership: Ownership::Owned,
1901            manager_state: crate::LifecycleState::Running,
1902            direct: None,
1903        };
1904        let err = commit_with_disposition(
1905            &mut manager,
1906            &spec,
1907            None::<&mut FakeDirect>,
1908            validated,
1909            ownership_proof(&install_root),
1910            policy(),
1911            &NoPostInstallCheck,
1912            UpdateRuntimeDisposition::ManagedRunning,
1913            &baseline,
1914        )
1915        .unwrap_err();
1916        assert!(matches!(err, crate::LifecycleUpdateError::Preflight { .. }));
1917    }
1918
1919    #[test]
1920    fn direct_identity_change_fails_before_stop() {
1921        let (_guard, install_root, validated) = setup();
1922        let spec = service_spec(&install_root);
1923        let mut manager = TestDoubleManager::new();
1924        let baseline = DispositionBaseline {
1925            manager_ownership: Ownership::Absent,
1926            manager_state: crate::LifecycleState::Stopped,
1927            direct: Some(direct_obs(DirectState::Running, true)),
1928        };
1929        let events = Rc::new(RefCell::new(Vec::new()));
1930        let mut direct = FakeDirect {
1931            obs: DirectObservation {
1932                state: DirectState::Running,
1933                exact_ownership_proven: false,
1934                executable: Some(crate::absolute("/different/service.bin")),
1935                config: Some(crate::absolute("/etc/app/config.toml")),
1936            },
1937            events,
1938            fail_stop: false,
1939            fail_start: false,
1940            fail_inspect: false,
1941            drift_after_stop: false,
1942        };
1943        let err = commit_with_disposition(
1944            &mut manager,
1945            &spec,
1946            Some(&mut direct),
1947            validated,
1948            ownership_proof(&install_root),
1949            policy(),
1950            &NoPostInstallCheck,
1951            UpdateRuntimeDisposition::DirectRunning,
1952            &baseline,
1953        )
1954        .unwrap_err();
1955        assert!(matches!(err, crate::LifecycleUpdateError::Preflight { .. }));
1956    }
1957
1958    #[test]
1959    fn keepinstalled_reports_committed_plus_lifecycle_failure() {
1960        let (_guard, install_root, validated) = setup();
1961        let spec = service_spec(&install_root);
1962        let mut manager = TestDoubleManager::new();
1963        manager.put(spec.clone(), crate::LifecycleState::Running);
1964        // Break restoration by making start fail: use a manager wrapper that
1965        // fails the post-commit start. Simplest: use EnsureRunning with a
1966        // stopped baseline? Instead, use a failing check with RollBack disabled
1967        // (KeepInstalled) and assert Committed + post_commit_failure.
1968        struct FailCheck;
1969        impl std::fmt::Debug for FailCheck {
1970            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1971                f.write_str("FailCheck")
1972            }
1973        }
1974        impl crate::PostInstallCheck for FailCheck {
1975            fn check(
1976                &self,
1977                _spec: &ServiceSpec,
1978                _snap: &LifecycleSnapshot,
1979                _remaining: Duration,
1980            ) -> Result<(), PostInstallCheckError> {
1981                Err(PostInstallCheckError::new("injected check failure"))
1982            }
1983        }
1984        let baseline = DispositionBaseline {
1985            manager_ownership: Ownership::Owned,
1986            manager_state: crate::LifecycleState::Running,
1987            direct: None,
1988        };
1989        let mut pol = policy();
1990        pol.post_commit_failure = CorePolicy::KeepInstalled;
1991        let receipt = commit_with_disposition(
1992            &mut manager,
1993            &spec,
1994            None::<&mut FakeDirect>,
1995            validated,
1996            ownership_proof(&install_root),
1997            pol,
1998            &FailCheck,
1999            UpdateRuntimeDisposition::ManagedRunning,
2000            &baseline,
2001        )
2002        .unwrap();
2003        assert_eq!(
2004            receipt.artifact_disposition(),
2005            eggup_core::TransactionDisposition::Committed
2006        );
2007        assert!(receipt.post_commit_failure.is_some());
2008    }
2009
2010    #[test]
2011    fn recovery_required_suppresses_automatic_starts() {
2012        // RecoveryRequired arises from Core when artifact state is uncertain.
2013        // Directly assert the restoration mapping used by orchestration: with a
2014        // failing check under RollBack that still cannot produce a receipt?
2015        // Instead, verify the planner never fabricates starts for Stopped and
2016        // that a RollBack check failure quiesces before rollback (covered by
2017        // M005 machinery). Here assert Stopped + EnsureStopped stays stopped.
2018        let (_guard, install_root, validated) = setup();
2019        let spec = service_spec(&install_root);
2020        let mut manager = TestDoubleManager::new();
2021        manager.put(spec.clone(), crate::LifecycleState::Stopped);
2022        let baseline = DispositionBaseline {
2023            manager_ownership: Ownership::Owned,
2024            manager_state: crate::LifecycleState::Stopped,
2025            direct: None,
2026        };
2027        let mut pol = policy();
2028        pol.restore = RestoreIntent::EnsureStopped;
2029        let receipt = commit_with_disposition(
2030            &mut manager,
2031            &spec,
2032            None::<&mut FakeDirect>,
2033            validated,
2034            ownership_proof(&install_root),
2035            pol,
2036            &NoPostInstallCheck,
2037            UpdateRuntimeDisposition::ManagedStopped,
2038            &baseline,
2039        )
2040        .unwrap();
2041        assert_eq!(
2042            receipt.final_snapshot.unwrap().state,
2043            crate::LifecycleState::Stopped
2044        );
2045    }
2046
2047    #[test]
2048    fn no_gregg_strings_in_public_types() {
2049        let debug = format!("{:?}", UpdateRuntimeDisposition::ManagedRunning);
2050        assert!(!debug.to_lowercase().contains("gregg"));
2051        let debug = format!("{:?}", WindowsServiceState::Running);
2052        assert!(!debug.to_lowercase().contains("gregg"));
2053    }
2054
2055    #[derive(Debug)]
2056    struct EventManager {
2057        inner: TestDoubleManager,
2058        events: Rc<RefCell<Vec<&'static str>>>,
2059    }
2060
2061    impl EventManager {
2062        fn with_service(
2063            spec: ServiceSpec,
2064            state: crate::LifecycleState,
2065            events: Rc<RefCell<Vec<&'static str>>>,
2066        ) -> Self {
2067            let mut inner = TestDoubleManager::new();
2068            inner.put(spec, state);
2069            Self { inner, events }
2070        }
2071    }
2072
2073    impl ServiceManager for EventManager {
2074        fn inspect(&self, spec: &ServiceSpec) -> Result<LifecycleSnapshot, ServiceError> {
2075            self.events.borrow_mut().push("inspect");
2076            self.inner.inspect(spec)
2077        }
2078
2079        fn install(&mut self, spec: &ServiceSpec) -> Result<TransitionResult, ServiceError> {
2080            self.events.borrow_mut().push("install");
2081            self.inner.install(spec)
2082        }
2083
2084        fn start(
2085            &mut self,
2086            spec: &ServiceSpec,
2087            timeout: Duration,
2088        ) -> Result<TransitionResult, ServiceError> {
2089            self.events.borrow_mut().push("start");
2090            self.inner.start(spec, timeout)
2091        }
2092
2093        fn stop(
2094            &mut self,
2095            spec: &ServiceSpec,
2096            timeout: Duration,
2097        ) -> Result<TransitionResult, ServiceError> {
2098            self.events.borrow_mut().push("stop");
2099            self.inner.stop(spec, timeout)
2100        }
2101
2102        fn restart(
2103            &mut self,
2104            spec: &ServiceSpec,
2105            timeout: Duration,
2106        ) -> Result<TransitionResult, ServiceError> {
2107            self.events.borrow_mut().push("restart");
2108            self.inner.restart(spec, timeout)
2109        }
2110
2111        fn uninstall(&mut self, spec: &ServiceSpec) -> Result<TransitionResult, ServiceError> {
2112            self.events.borrow_mut().push("uninstall");
2113            self.inner.uninstall(spec)
2114        }
2115    }
2116
2117    #[test]
2118    fn preparation_completes_before_first_quiesce() {
2119        let (_guard, install_root, validated) = setup();
2120        let spec = service_spec(&install_root);
2121        let events = Rc::new(RefCell::new(Vec::new()));
2122        let mut manager = EventManager::with_service(
2123            spec.clone(),
2124            crate::LifecycleState::Running,
2125            events.clone(),
2126        );
2127        let baseline = DispositionBaseline {
2128            manager_ownership: Ownership::Owned,
2129            manager_state: crate::LifecycleState::Running,
2130            direct: None,
2131        };
2132        commit_with_disposition(
2133            &mut manager,
2134            &spec,
2135            None::<&mut FakeDirect>,
2136            validated,
2137            ownership_proof(&install_root),
2138            policy(),
2139            &NoPostInstallCheck,
2140            UpdateRuntimeDisposition::ManagedRunning,
2141            &baseline,
2142        )
2143        .unwrap();
2144        let ev = events.borrow().clone();
2145        let first_inspect = ev.iter().position(|e| *e == "inspect").unwrap();
2146        let first_stop = ev.iter().position(|e| *e == "stop").unwrap();
2147        assert!(
2148            first_inspect < first_stop,
2149            "inspect must precede quiesce, got {ev:?}"
2150        );
2151        // Invalid policy performs zero lifecycle mutation.
2152        let (_guard2, install_root2, validated2) = setup();
2153        let spec2 = service_spec(&install_root2);
2154        let events2 = Rc::new(RefCell::new(Vec::new()));
2155        let mut manager2 = EventManager::with_service(
2156            spec2.clone(),
2157            crate::LifecycleState::Running,
2158            events2.clone(),
2159        );
2160        let mut bad = policy();
2161        bad.quiesce_timeout = Duration::ZERO;
2162        let err = commit_with_disposition(
2163            &mut manager2,
2164            &spec2,
2165            None::<&mut FakeDirect>,
2166            validated2,
2167            ownership_proof(&install_root2),
2168            bad,
2169            &NoPostInstallCheck,
2170            UpdateRuntimeDisposition::ManagedRunning,
2171            &DispositionBaseline {
2172                manager_ownership: Ownership::Owned,
2173                manager_state: crate::LifecycleState::Running,
2174                direct: None,
2175            },
2176        )
2177        .unwrap_err();
2178        assert!(matches!(
2179            err,
2180            crate::LifecycleUpdateError::InvalidPolicy { .. }
2181        ));
2182        assert!(events2.borrow().is_empty());
2183    }
2184
2185    #[derive(Debug)]
2186    struct FailCheck;
2187    impl crate::PostInstallCheck for FailCheck {
2188        fn check(
2189            &self,
2190            _spec: &ServiceSpec,
2191            _snap: &LifecycleSnapshot,
2192            _remaining: Duration,
2193        ) -> Result<(), PostInstallCheckError> {
2194            Err(PostInstallCheckError::new("injected check failure"))
2195        }
2196    }
2197
2198    #[derive(Debug)]
2199    struct SabotageCheck(std::path::PathBuf);
2200    impl crate::PostInstallCheck for SabotageCheck {
2201        fn check(
2202            &self,
2203            _spec: &ServiceSpec,
2204            _snap: &LifecycleSnapshot,
2205            _remaining: Duration,
2206        ) -> Result<(), PostInstallCheckError> {
2207            let dest = self.0.join("service.bin");
2208            std::fs::remove_file(&dest).unwrap();
2209            std::fs::create_dir(&dest).unwrap();
2210            Err(PostInstallCheckError::new("injected rollback failure"))
2211        }
2212    }
2213
2214    #[test]
2215    fn rollback_quiesces_new_generation_and_restores_old() {
2216        let (_guard, install_root, validated) = setup();
2217        let spec = service_spec(&install_root);
2218        let events = Rc::new(RefCell::new(Vec::new()));
2219        let mut manager = EventManager::with_service(
2220            spec.clone(),
2221            crate::LifecycleState::Running,
2222            events.clone(),
2223        );
2224        let baseline = DispositionBaseline {
2225            manager_ownership: Ownership::Owned,
2226            manager_state: crate::LifecycleState::Running,
2227            direct: None,
2228        };
2229        let mut pol = policy();
2230        pol.post_commit_failure = CorePolicy::RollBack;
2231        let receipt = commit_with_disposition(
2232            &mut manager,
2233            &spec,
2234            None::<&mut FakeDirect>,
2235            validated,
2236            ownership_proof(&install_root),
2237            pol,
2238            &FailCheck,
2239            UpdateRuntimeDisposition::ManagedRunning,
2240            &baseline,
2241        )
2242        .unwrap();
2243        assert_eq!(
2244            receipt.artifact_disposition(),
2245            eggup_core::TransactionDisposition::RolledBack
2246        );
2247        // New generation was quiesced before artifact rollback (at least two
2248        // stops: pre-commit quiesce + rollback quiesce) and old state restored.
2249        let ev = events.borrow().clone();
2250        assert!(ev.iter().filter(|e| ***e == *"stop").count() >= 2);
2251        assert!(ev.contains(&"start"));
2252        assert_eq!(
2253            receipt.final_snapshot.unwrap().state,
2254            crate::LifecycleState::Running
2255        );
2256    }
2257
2258    #[test]
2259    fn recovery_required_suppresses_all_automatic_starts() {
2260        let (_guard, install_root, validated) = setup();
2261        let spec = service_spec(&install_root);
2262        let events = Rc::new(RefCell::new(Vec::new()));
2263        let mut manager = EventManager::with_service(
2264            spec.clone(),
2265            crate::LifecycleState::Running,
2266            events.clone(),
2267        );
2268        let baseline = DispositionBaseline {
2269            manager_ownership: Ownership::Owned,
2270            manager_state: crate::LifecycleState::Running,
2271            direct: None,
2272        };
2273        let mut pol = policy();
2274        pol.post_commit_failure = CorePolicy::RollBack;
2275        let receipt = commit_with_disposition(
2276            &mut manager,
2277            &spec,
2278            None::<&mut FakeDirect>,
2279            validated,
2280            ownership_proof(&install_root),
2281            pol,
2282            &SabotageCheck(install_root.clone()),
2283            UpdateRuntimeDisposition::ManagedRunning,
2284            &baseline,
2285        )
2286        .unwrap();
2287        assert_eq!(
2288            receipt.artifact_disposition(),
2289            eggup_core::TransactionDisposition::RecoveryRequired
2290        );
2291        assert!(receipt.manual_artifact_recovery_required());
2292        assert_eq!(
2293            receipt.restoration,
2294            crate::LifecycleRestorationStatus::NotAttemptedRecoveryRequired
2295        );
2296        // Only the new generation may have been started; no old-generation
2297        // restart occurs against uncertain artifacts.
2298        assert_eq!(
2299            events.borrow().iter().filter(|e| ***e == *"start").count(),
2300            1
2301        );
2302        assert_eq!(
2303            receipt.final_snapshot.as_ref().unwrap().state,
2304            crate::LifecycleState::Stopped
2305        );
2306    }
2307}