bring back mount_media, remove_media (#62)

Functions `mount_media` and `remove_media` were removed in
#57.
To parse a ovf_env file, however, both mount_media and remove_media are
necessary.
Bring back the functions.

Adjust return types according to the new LibError interface as well.

Co-authored-by: Jeremy Cline <jeremycline@microsoft.com>

Author: dongsupark

libazureinit/src/media.rs

@@ -6,6 +6,8 @@ use std::fs::create_dir_all;
 use std::fs::File;
 use std::io::Read;
 use std::os::unix::fs::PermissionsExt;
+use std::path::PathBuf;
+use std::process::Command;
 
 use serde::Deserialize;
 use serde_xml_rs::from_str;
@@ -66,27 +68,92 @@ fn default_preprov_type() -> String {
     "None".to_owned()
 }
 
-pub fn make_temp_directory() -> Result<(), Box<dyn std::error::Error>> {
-    let file_path = "/run/azure-init/tmp/";
+pub const PATH_MOUNT_DEVICE: &str = "/dev/sr0";
+pub const PATH_MOUNT_POINT: &str = "/run/azure-init/media/";
 
-    create_dir_all(file_path)?;
+// Some zero-sized structs that just provide states for our state machine
+pub struct Mounted;
+pub struct Unmounted;
 
-    let metadata = fs::metadata(file_path)?;
-    let permissions = metadata.permissions();
-    let mut new_permissions = permissions.clone();
-    new_permissions.set_mode(0o700);
-    fs::set_permissions(file_path, new_permissions)?;
+pub struct Media<State = Unmounted> {
+    device_path: PathBuf,
+    mount_path: PathBuf,
+    state: std::marker::PhantomData<State>,
+}
+
+impl Media<Unmounted> {
+    pub fn new(device_path: PathBuf, mount_path: PathBuf) -> Media<Unmounted> {
+        Media {
+            device_path,
+            mount_path,
+            state: std::marker::PhantomData,
+        }
+    }
+
+    pub fn mount(self) -> Result<Media<Mounted>, Error> {
+        create_dir_all(&self.mount_path)?;
+
+        let metadata = fs::metadata(&self.mount_path)?;
+        let permissions = metadata.permissions();
+        let mut new_permissions = permissions.clone();
+        new_permissions.set_mode(0o700);
+        fs::set_permissions(&self.mount_path, new_permissions)?;
+
+        let mount_status = Command::new("mount")
+            .arg("-o")
+            .arg("ro")
+            .arg(&self.device_path)
+            .arg(&self.mount_path)
+            .status()?;
 
-    Ok(())
+        if !mount_status.success() {
+            Err(Error::SubprocessFailed {
+                command: "mount".to_string(),
+                status: mount_status,
+            })
+        } else {
+            Ok(Media {
+                device_path: self.device_path,
+                mount_path: self.mount_path,
+                state: std::marker::PhantomData,
+            })
+        }
+    }
 }
 
-pub fn read_ovf_env_to_string() -> Result<String, Error> {
-    let file_path = "/run/azure-init/tmp/ovf-env.xml";
-    let mut file = File::open(file_path)?;
-    let mut contents = String::new();
-    file.read_to_string(&mut contents)?;
+impl Media<Mounted> {
+    pub fn unmount(self) -> Result<(), Error> {
+        let umount_status =
+            Command::new("umount").arg(self.mount_path).status()?;
+        if !umount_status.success() {
+            return Err(Error::SubprocessFailed {
+                command: "umount".to_string(),
+                status: umount_status,
+            });
+        }
+
+        let eject_status =
+            Command::new("eject").arg(self.device_path).status()?;
+        if !eject_status.success() {
+            Err(Error::SubprocessFailed {
+                command: "eject".to_string(),
+                status: eject_status,
+            })
+        } else {
+            Ok(())
+        }
+    }
 
-    Ok(contents)
+    pub fn read_ovf_env_to_string(&self) -> Result<String, Error> {
+        let mut file_path = self.mount_path.clone();
+        file_path.push("ovf-env.xml");
+        let mut file =
+            File::open(file_path.to_str().unwrap_or(PATH_MOUNT_POINT))?;
+        let mut contents = String::new();
+        file.read_to_string(&mut contents)?;
+
+        Ok(contents)
+    }
 }
 
 pub fn parse_ovf_env(ovf_body: &str) -> Result<Environment, Error> {

src/main.rs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+use std::path::PathBuf;
 use std::process::ExitCode;
 
 use anyhow::Context;
@@ -9,21 +10,34 @@ use libazureinit::distro::{Distribution, Distributions};
 use libazureinit::{
     error::Error as LibError,
     goalstate, imds, media,
+    media::Media,
     reqwest::{header, Client},
     user,
 };
 
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 
-fn get_username(imds_body: String) -> Result<String, LibError> {
+fn get_username(imds_body: String) -> Result<String, anyhow::Error> {
     if imds::is_password_authentication_disabled(&imds_body)? {
         // password authentication is disabled
-        imds::get_username(imds_body.clone())
+        Ok(imds::get_username(imds_body.clone())?)
     } else {
         // password authentication is enabled
-        let ovf_body = media::read_ovf_env_to_string()?;
+        let mount_media = Media::new(
+            PathBuf::from(media::PATH_MOUNT_DEVICE),
+            PathBuf::from(media::PATH_MOUNT_POINT),
+        );
+        let mounted = mount_media
+            .mount()
+            .with_context(|| "Failed to mount media.")?;
+
+        let ovf_body = mounted.read_ovf_env_to_string()?;
         let environment = media::parse_ovf_env(ovf_body.as_str())?;
 
+        mounted
+            .unmount()
+            .with_context(|| "Failed to remove media.")?;
+
         Ok(environment
             .provisioning_section
             .linux_prov_conf_set