Replace lexical Rust fragments with real modules

crates/lazaret-host-coordinator/src/control/execution.rs

@@ -1,15 +1,26 @@
-struct ControlPaths {
-    root: PathBuf,
-    root_file: File,
-    root_identity: FileIdentity,
-    socket: PathBuf,
-    identity: PathBuf,
-    staged_socket: PathBuf,
-    staged_identity: PathBuf,
+use super::{
+    Arc, AsFd, CONTROL_SOCKET_NAME, ContainerId, ControlError, File, FileIdentity,
+    InteractiveSessionBatch, InteractiveSessionEvent, InteractiveSessionRequest, MetadataExt, Mode,
+    NonInteractiveSessionMessage, NonInteractiveSessionRequest, OFlags, OpenOptions, OsStr,
+    OsString, OsStringExt, PUBLICATION_IDENTITY_NAME, Path, PathBuf, ProcessExit,
+    ProtocolPublicationIdentity, Read, RunscCommand, STAGED_CONTROL_SOCKET_NAME,
+    STAGED_PUBLICATION_IDENTITY_NAME, ServerConfig, SessionExit, SessionId, SessionRegistry,
+    TargetCommand, TrustAnchor, Write, child_broker, fchmod, fmt, io, openat,
+    remove_if_identity_matches,
+};
+
+pub(super) struct ControlPaths {
+    pub(super) root: PathBuf,
+    pub(super) root_file: File,
+    pub(super) root_identity: FileIdentity,
+    pub(super) socket: PathBuf,
+    pub(super) identity: PathBuf,
+    pub(super) staged_socket: PathBuf,
+    pub(super) staged_identity: PathBuf,
 }
 
 impl ControlPaths {
-    fn open(root: &Path, uid: u32) -> Result<Self, ControlError> {
+    pub(super) fn open(root: &Path, uid: u32) -> Result<Self, ControlError> {
         if !root.is_absolute() {
             return Err(ControlError::InvalidPath(
                 "runtime Domain root is not absolute",
@@ -43,7 +54,7 @@ impl ControlPaths {
         })
     }
 
-    fn validate_root(&self, uid: u32) -> Result<(), ControlError> {
+    pub(super) fn validate_root(&self, uid: u32) -> Result<(), ControlError> {
         let descriptor = self.root_file.metadata()?;
         let current = std::fs::symlink_metadata(&self.root)?;
         if FileIdentity::from_metadata(&descriptor) != self.root_identity
@@ -57,7 +68,7 @@ impl ControlPaths {
         Ok(())
     }
 
-    fn create_named_identity(
+    pub(super) fn create_named_identity(
         &self,
         name: &str,
         bytes: &[u8],
@@ -90,7 +101,7 @@ impl ControlPaths {
         Ok((file, identity))
     }
 
-    fn validate_identity(
+    pub(super) fn validate_identity(
         &self,
         file: &File,
         expected: FileIdentity,
@@ -100,7 +111,7 @@ impl ControlPaths {
         self.validate_identity_at(&self.identity, file, expected, uid, expected_length)
     }
 
-    fn validate_identity_at(
+    pub(super) fn validate_identity_at(
         &self,
         path: &Path,
         file: &File,
@@ -131,23 +142,23 @@ impl ControlPaths {
 }
 
 pub struct PublishedControlFace {
-    listener: std::os::unix::net::UnixListener,
-    paths: ControlPaths,
-    socket_identity: FileIdentity,
-    identity_file: File,
-    identity_file_identity: FileIdentity,
-    publication_identity: ProtocolPublicationIdentity,
-    publication_bytes: Vec<u8>,
-    uid: u32,
-    anchor: TrustAnchor,
-    server_config: Arc<ServerConfig>,
-    registry: Arc<SessionRegistry>,
-    executor: Arc<dyn NonInteractiveSessionExecutor>,
-    interactive_executor: Arc<dyn InteractiveSessionExecutor>,
+    pub(super) listener: std::os::unix::net::UnixListener,
+    pub(super) paths: ControlPaths,
+    pub(super) socket_identity: FileIdentity,
+    pub(super) identity_file: File,
+    pub(super) identity_file_identity: FileIdentity,
+    pub(super) publication_identity: ProtocolPublicationIdentity,
+    pub(super) publication_bytes: Vec<u8>,
+    pub(super) uid: u32,
+    pub(super) anchor: TrustAnchor,
+    pub(super) server_config: Arc<ServerConfig>,
+    pub(super) registry: Arc<SessionRegistry>,
+    pub(super) executor: Arc<dyn NonInteractiveSessionExecutor>,
+    pub(super) interactive_executor: Arc<dyn InteractiveSessionExecutor>,
 }
 
 pub(crate) struct AcceptedControlConnection {
-    socket: std::os::unix::net::UnixStream,
+    pub(super) socket: std::os::unix::net::UnixStream,
 }
 
 impl AcceptedControlConnection {
@@ -166,7 +177,7 @@ pub trait NonInteractiveSessionExecutor: Send + Sync {
     ) -> Result<SessionExit, ControlError>;
 }
 
-struct ExecutionUnavailable;
+pub(super) struct ExecutionUnavailable;
 
 impl NonInteractiveSessionExecutor for ExecutionUnavailable {
     fn execute(
@@ -196,7 +207,7 @@ pub trait InteractiveSessionExecutor: Send + Sync {
     ) -> Result<Box<dyn InteractiveControlSession>, ControlError>;
 }
 
-struct InteractiveExecutionUnavailable;
+pub(super) struct InteractiveExecutionUnavailable;
 
 impl InteractiveSessionExecutor for InteractiveExecutionUnavailable {
     fn start(
@@ -208,13 +219,13 @@ impl InteractiveSessionExecutor for InteractiveExecutionUnavailable {
 }
 
 pub struct RunscNonInteractiveExecutor {
-    program: OsString,
-    global_arguments: Vec<OsString>,
-    container: OsString,
-    runner: Arc<dyn NonInteractiveCommandRunner>,
+    pub(super) program: OsString,
+    pub(super) global_arguments: Vec<OsString>,
+    pub(super) container: OsString,
+    pub(super) runner: Arc<dyn NonInteractiveCommandRunner>,
 }
 
-trait NonInteractiveCommandRunner: Send + Sync {
+pub(super) trait NonInteractiveCommandRunner: Send + Sync {
     fn run(
         &self,
         target: &TargetCommand,
@@ -343,7 +354,7 @@ fn emit_available(
     }
 }
 
-fn hex_lower(bytes: &[u8]) -> String {
+pub(super) fn hex_lower(bytes: &[u8]) -> String {
     use fmt::Write as _;
 
     bytes.iter().fold(String::new(), |mut output, byte| {
@@ -351,4 +362,3 @@ fn hex_lower(bytes: &[u8]) -> String {
         output
     })
 }
-