Integrate exact production recovery before cold start

crates/lazaret-host-coordinator/tests/recovery-process.rs

@@ -0,0 +1,81 @@
+use std::io;
+use std::process::ExitCode;
+
+use lazaret_core::identity::{
+    ConfigurationFingerprint, CoordinatorId, DomainId, GenerationId, NetworkSidecarId, SandboxId,
+};
+use lazaret_core::records::{
+    DurableDecision, Generation, Participant, ParticipantOwnership, ParticipantRole,
+    ParticipantState, PersistedHostProcessOwnership, StateAnchorOwnership,
+};
+use lazaret_host_coordinator::recovery::{prove_runtime_owners_absent, runtime_recovery_ownership};
+use lazaret_linux::process::{TargetCommand, child_broker, dispatch_private_process_role};
+use rustix::process::Signal;
+
+fn main() -> ExitCode {
+    let arguments = std::env::args_os().skip(1).collect::<Vec<_>>();
+    if let Some(result) = dispatch_private_process_role(&arguments) {
+        return exit(result);
+    }
+    exit(run())
+}
+
+fn exit(result: io::Result<()>) -> ExitCode {
+    match result {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(error) => {
+            eprintln!("recovery process test failed: {error}");
+            ExitCode::FAILURE
+        }
+    }
+}
+
+fn run() -> io::Result<()> {
+    verify_exact_action(None)?;
+    verify_exact_action(Some(Signal::STOP))
+}
+
+fn verify_exact_action(signal: Option<Signal>) -> io::Result<()> {
+    let captured =
+        child_broker().run_transient_captured(&TargetCommand::new("/bin/sleep").argument("60"))?;
+    if let Some(signal) = signal {
+        captured.process().send_signal(signal)?;
+    }
+    let process = captured.into_process();
+    let generation = generation();
+    let participants = [
+        Participant::bare_intent(generation.generation_id, ParticipantRole::PreparedLower),
+        Participant::snapshot(
+            generation.generation_id,
+            ParticipantRole::StateAnchor,
+            ParticipantState::Intent,
+            Some(ParticipantOwnership::StateAnchor(StateAnchorOwnership {
+                lower_artifact_id: None,
+                upper_path: None,
+                work_path: None,
+                merged_path: None,
+                daemon: PersistedHostProcessOwnership::staged(process.identity()),
+                user_namespace: None,
+                mount_namespace: None,
+                mount: None,
+            })),
+        )
+        .map_err(|_| io::Error::other("State Anchor participant is invalid"))?,
+    ];
+    let ownership =
+        runtime_recovery_ownership(&participants, &generation).map_err(io::Error::other)?;
+    prove_runtime_owners_absent(&ownership)?;
+    child_broker().reap(process)
+}
+
+fn generation() -> Generation {
+    Generation {
+        domain_id: DomainId::new([1; 32]),
+        generation_id: GenerationId::new(1),
+        configuration_fingerprint: ConfigurationFingerprint::new([2; 32]),
+        coordinator_id: CoordinatorId::new([3; 32]),
+        network_sidecar_id: NetworkSidecarId::new([4; 32]),
+        sandbox_id: SandboxId::new([5; 32]),
+        durable_decision: DurableDecision::Preparing,
+    }
+}