Decouple client contracts and close private role registries

crates/lazaret-host-coordinator/tests/client-control-face.rs

@@ -0,0 +1,164 @@
+use std::fs::OpenOptions;
+use std::os::unix::fs::PermissionsExt;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use lazaret_client::{ControlEndpoint, execute_over_control_face};
+use lazaret_core::identity::{
+    ConfigurationFingerprint, CoordinatorId, DomainId, GenerationId, HostPath, NetworkSidecarId,
+    SandboxId,
+};
+use lazaret_core::records::{
+    Domain, DurableDecision, Generation, GenerationIdentity, NonInteractiveOutput,
+    NonInteractiveSessionMessage, NonInteractiveSessionRequest, SessionExit,
+};
+use lazaret_host_coordinator::control::{
+    ControlError, NonInteractiveSessionExecutor, PublishedControlFace, TrustAnchor,
+};
+use lazaret_host_coordinator::domain_store::{DomainStoreMutation, HostCoordinatorDomainStore};
+use lazaret_linux::filesystem::try_exclusive_flock;
+
+struct TestDirectory(PathBuf);
+
+impl TestDirectory {
+    fn new() -> Self {
+        let path = std::env::temp_dir().join(format!(
+            "lazaret-client-control-{}-{}",
+            std::process::id(),
+            random_suffix()
+        ));
+        std::fs::create_dir(&path).unwrap();
+        std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o700)).unwrap();
+        Self(path)
+    }
+}
+
+impl Drop for TestDirectory {
+    fn drop(&mut self) {
+        std::fs::remove_dir_all(&self.0).unwrap();
+    }
+}
+
+struct Executor;
+
+impl NonInteractiveSessionExecutor for Executor {
+    fn execute(
+        &self,
+        request: &NonInteractiveSessionRequest,
+        emit: &mut dyn FnMut(NonInteractiveSessionMessage) -> Result<(), ControlError>,
+    ) -> Result<SessionExit, ControlError> {
+        assert_eq!(request.argv, [b"tool".to_vec(), b"argument".to_vec()]);
+        emit(NonInteractiveSessionMessage::Stdout(NonInteractiveOutput {
+            session_id: request.session_id,
+            bytes: b"first".to_vec(),
+        }))?;
+        emit(NonInteractiveSessionMessage::Stderr(NonInteractiveOutput {
+            session_id: request.session_id,
+            bytes: b"second".to_vec(),
+        }))?;
+        Ok(SessionExit::exited(request.session_id, 19))
+    }
+}
+
+#[test]
+fn client_enrolls_registers_forwards_both_streams_and_returns_guest_status() {
+    let directory = TestDirectory::new();
+    let identity = generation_identity();
+    let store = open_store(&directory, &identity);
+    let face = Arc::new(
+        PublishedControlFace::publish_with_executor(
+            &directory.0,
+            rustix::process::getuid().as_raw(),
+            TrustAnchor::create(identity).unwrap(),
+            store,
+            Arc::new(Executor),
+        )
+        .unwrap(),
+    );
+    let endpoint = ControlEndpoint::new(
+        face.socket_path().to_path_buf(),
+        face.publication_identity().clone(),
+    );
+    let server = {
+        let face = Arc::clone(&face);
+        std::thread::spawn(move || {
+            face.serve_next().unwrap();
+            face.serve_next().unwrap();
+        })
+    };
+    let mut stdout = Vec::new();
+    let mut stderr = Vec::new();
+
+    let status = execute_over_control_face(
+        &endpoint,
+        &[b"tool".to_vec(), b"argument".to_vec()],
+        &mut stdout,
+        &mut stderr,
+    )
+    .unwrap();
+
+    server.join().unwrap();
+    assert_eq!(status, 19);
+    assert_eq!(stdout, b"first");
+    assert_eq!(stderr, b"second");
+}
+
+fn generation_identity() -> GenerationIdentity {
+    GenerationIdentity {
+        agent_profile: "trusted".into(),
+        domain_id: DomainId::new([1; 32]),
+        generation_id: GenerationId::new(1),
+        configuration_fingerprint: ConfigurationFingerprint::new([2; 32]),
+        coordinator_id: CoordinatorId::new([3; 32]),
+        sandbox_id: SandboxId::new([4; 32]),
+    }
+}
+
+fn open_store(
+    directory: &TestDirectory,
+    identity: &GenerationIdentity,
+) -> Arc<HostCoordinatorDomainStore> {
+    let lock = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create_new(true)
+        .open(directory.0.join("domain.lock"))
+        .unwrap();
+    let domain = Domain {
+        domain_id: identity.domain_id,
+        profile_name: identity.agent_profile.clone(),
+        canonical_workspace: HostPath::new(b"/workspace/project".to_vec()),
+    };
+    let store = Arc::new(
+        HostCoordinatorDomainStore::open(
+            try_exclusive_flock(lock).unwrap(),
+            &directory.0.join("domain.redb"),
+            &domain,
+        )
+        .unwrap(),
+    );
+    for durable_decision in [
+        DurableDecision::None,
+        DurableDecision::Preparing,
+        DurableDecision::Published,
+    ] {
+        store
+            .apply(&[DomainStoreMutation::PutGeneration(Generation {
+                domain_id: identity.domain_id,
+                generation_id: identity.generation_id,
+                configuration_fingerprint: identity.configuration_fingerprint,
+                coordinator_id: identity.coordinator_id,
+                network_sidecar_id: NetworkSidecarId::new([5; 32]),
+                sandbox_id: identity.sandbox_id,
+                durable_decision,
+            })])
+            .unwrap();
+    }
+    store
+}
+
+fn random_suffix() -> u64 {
+    let mut bytes = [0_u8; 8];
+    getrandom::fill(&mut bytes).unwrap();
+    u64::from_ne_bytes(bytes)
+}

crates/lazaret-host-coordinator/tests/escalation.rs

@@ -28,9 +28,7 @@ use lazaret_host_coordinator::escalation::{
     GenerationMailbox,
 };
 use lazaret_linux::filesystem::RegularFileMailbox;
-use lazaret_linux::process::{
-    ProcessOwnershipContext, dispatch_private_process_role, recover_process,
-};
+use lazaret_linux::process::{ProcessOwnershipContext, recover_process};
 use sha2::{Digest, Sha256};
 
 type TestResult<T = ()> = Result<T, Box<dyn Error>>;
@@ -882,9 +880,9 @@ fn run() -> TestResult {
 
 fn main() {
     let arguments = std::env::args_os().skip(1).collect::<Vec<_>>();
-    if let Some(result) = dispatch_private_process_role(&arguments) {
-        if let Err(error) = result {
-            eprintln!("private process role failed: {error}");
+    if let Some(outcome) = lazaret_host_coordinator::private_roles::REGISTRY.dispatch(&arguments) {
+        if let Err(error) = outcome.result {
+            eprintln!("private role {} failed: {error}", outcome.name);
             std::process::exit(1);
         }
         return;

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

@@ -17,13 +17,13 @@ use lazaret_core::records::{
 use lazaret_host_coordinator::recovery::{
     delete_runsc_container, prove_runtime_owners_absent, runtime_recovery_ownership,
 };
-use lazaret_linux::process::{TargetCommand, child_broker, dispatch_private_process_role};
+use lazaret_linux::process::{TargetCommand, child_broker};
 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);
+    if let Some(outcome) = lazaret_host_coordinator::private_roles::REGISTRY.dispatch(&arguments) {
+        return exit(outcome.result);
     }
     exit(run())
 }

crates/lazaret-host-coordinator/tests/runtime-composition.rs

@@ -46,7 +46,6 @@ use lazaret_runtime_supervisor::sandbox::{
 };
 use lazaret_runtime_supervisor::supervision::{
     AttachedRunscSignal, RuntimeNetworkLaunch, RuntimeSupervisorLaunch,
-    dispatch_private_runtime_role,
 };
 use rustix::process::Signal;
 use tempfile::TempDir;
@@ -64,16 +63,8 @@ const BENCHMARK_ERROR: &str = "benchmark-error";
 
 fn main() -> ExitCode {
     let arguments = std::env::args_os().skip(1).collect::<Vec<_>>();
-    if let Some(result) = lazaret_linux::process::dispatch_private_process_role(&arguments) {
-        return exit(result);
-    }
-    if let Some(result) = dispatch_private_runtime_role(&arguments) {
-        return exit(result);
-    }
-    if let Some(result) =
-        lazaret_host_coordinator::sandbox_init::dispatch_private_sandbox_init(&arguments)
-    {
-        return exit(result);
+    if let Some(outcome) = lazaret_host_coordinator::private_roles::REGISTRY.dispatch(&arguments) {
+        return exit(outcome.result);
     }
     if arguments.first().and_then(|argument| argument.to_str()) == Some(BENCHMARK_GUEST) {
         return exit(run_benchmark_guest(&arguments[1..]));