1#![forbid(unsafe_code)]
2#![deny(missing_docs)]
3use 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#[derive(Debug, Clone, Copy, PartialEq, Eq)]
35pub enum UpdateRuntimeDisposition {
36 ManagedRunning,
38 ManagedStopped,
40 DirectRunning,
42 Stopped,
44 ForeignPreserved,
46}
47
48#[derive(Debug, Clone, PartialEq, Eq)]
50pub enum KnownConfig {
51 Absent,
53 Present(PathBuf),
55 Unknown,
57}
58
59#[derive(Debug, Clone, Copy, PartialEq, Eq)]
61pub enum DirectState {
62 Running,
64 Stopped,
66 Unknown,
68}
69
70#[derive(Debug, Clone, PartialEq, Eq)]
72pub struct DirectObservation {
73 pub state: DirectState,
75 pub exact_ownership_proven: bool,
77 pub executable: Option<PathBuf>,
79 pub config: Option<PathBuf>,
81}
82
83#[derive(Debug, Clone, PartialEq, Eq)]
85pub struct UnixPlannerInput {
86 pub manager_ownership: Ownership,
88 pub manager_active: bool,
90 pub manager_state_known: bool,
92 pub registered_config: KnownConfig,
94 pub selected_config: Option<PathBuf>,
96 pub direct: DirectObservation,
98}
99
100#[derive(Debug, Clone, Copy, PartialEq, Eq)]
102pub enum WindowsServiceState {
103 Running,
105 StartPending,
107 Stopped,
109 StopPending,
111 Unknown,
113}
114
115#[derive(Debug, Clone, PartialEq, Eq)]
117pub struct WindowsPlannerInput {
118 pub installed: bool,
120 pub executable_known: bool,
122 pub ownership: Ownership,
124 pub state: WindowsServiceState,
126}
127
128pub 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
234pub 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
272pub trait DirectRuntimeControl: fmt::Debug {
274 fn inspect(&self) -> Result<DirectObservation, crate::ServiceError>;
276 fn stop(&mut self, timeout: Duration) -> Result<TransitionResult, crate::ServiceError>;
278 fn start(&mut self, timeout: Duration) -> Result<TransitionResult, crate::ServiceError>;
280}
281
282#[derive(Debug, Clone, PartialEq, Eq)]
284pub struct DispositionBaseline {
285 pub manager_ownership: Ownership,
287 pub manager_state: LifecycleState,
289 pub direct: Option<DirectObservation>,
291}
292
293#[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#[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 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 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 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 let wanted = match policy.restore {
843 crate::RestoreIntent::EnsureStopped => DirectState::Stopped,
844 _ => DirectState::Running,
845 };
846 let work = catch_unwind(AssertUnwindSafe(|| {
847 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 assert_eq!(
1369 w(
1370 false,
1371 false,
1372 Ownership::Absent,
1373 WindowsServiceState::Unknown
1374 )
1375 .unwrap(),
1376 UpdateRuntimeDisposition::Stopped
1377 );
1378 assert!(w(
1380 true,
1381 false,
1382 Ownership::Unknown,
1383 WindowsServiceState::Running
1384 )
1385 .is_err());
1386 assert_eq!(
1388 w(true, true, Ownership::Foreign, WindowsServiceState::Running).unwrap(),
1389 UpdateRuntimeDisposition::ForeignPreserved
1390 );
1391 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 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 #[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 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 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 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 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 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 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 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 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 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 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 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}