feat: parse configuration domain

Author: zeishr

docs/docs/explanations/architecture/_index.md

@@ -39,7 +39,7 @@ This is the only service that uses the `/xenith` directory. The directory is str
                 /snapshots
                     # contains all disk snapshots
             /templates
-                debian-default.hcl # packer image template
+                debian-default.pkr.hcl # packer image template
                 template-variables.hcl # generated image variables
 
         /windows11-default

xenith-domain-management/src/configuration/disk.rs

@@ -88,17 +88,12 @@ impl Display for Disk {
     }
 }
 
-impl TryFrom<PathBuf> for Disk {
+impl TryFrom<&PathBuf> for Disk {
     type Error = std::io::Error;
 
-    fn try_from(path: PathBuf) -> Result<Self, Self::Error> {
+    fn try_from(path: &PathBuf) -> Result<Self, Self::Error> {
         // Check if the file exists
-        if !path.exists() {
-            return Err(std::io::Error::new(
-                std::io::ErrorKind::NotFound,
-                format!("File not found: {}", path.display()),
-            ));
-        }
+        path.try_exists()?;
 
         // Check if the file is a regular file
         if !path.is_file() {
@@ -136,7 +131,7 @@ impl TryFrom<PathBuf> for Disk {
 
         Ok(Self {
             name,
-            path,
+            path: path.clone(),
             size,
             format,
         })

xenith-domain-management/src/configuration/domain.rs

@@ -17,12 +17,14 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
 use std::fmt::Display;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use serde::{Deserialize, Serialize};
 
-use crate::configuration::Disk;
-use crate::configuration::Template;
+use crate::error::ConfigurationError;
+
+use super::Disk;
+use super::Template;
 
 /// Domain configuration
 #[derive(Debug, Clone, Default, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
@@ -40,6 +42,8 @@ pub struct Domain {
     /// List of disks for the domain
     /// This is the list of disks that are used by the domain.
     disks: Vec<Disk>,
+    /// List of disk snapshots for the domain
+    snapshots: Vec<Disk>,
     /// Packer templates for the domain
     templates: Option<Template>,
 }
@@ -50,17 +54,96 @@ impl Domain {
         path: PathBuf,
         configuration_file: Option<PathBuf>,
         disks: Vec<Disk>,
+        disks_snapshots: Vec<Disk>,
         templates: Option<Template>,
     ) -> Self {
         Self {
             name,
             path,
             configuration_file,
             disks,
+            snapshots: disks_snapshots,
             templates,
         }
     }
 
+    pub fn new_empty(name: String, path: PathBuf) -> Self {
+        Self {
+            name,
+            path,
+            configuration_file: None,
+            disks: vec![],
+            snapshots: vec![],
+            templates: None,
+        }
+    }
+
+    fn parse_configuration_file(&self) -> Result<Option<PathBuf>, ConfigurationError> {
+        let path = self.get_configuration_file_path();
+
+        // check if the file exists and is not empty
+        if path.exists() && path.is_file() {
+            let metadata = path.metadata().map_err(ConfigurationError::Parsing)?;
+
+            if metadata.len() > 0 {
+                return Ok(Some(path));
+            }
+        }
+
+        Ok(None)
+    }
+
+    fn parse_disks_in_directory(&self, path: &Path) -> Result<Vec<Disk>, ConfigurationError> {
+        let mut disks = vec![];
+
+        if !path.exists() {
+            return Ok(disks);
+        }
+
+        // iterate over the disks directory, and parse each disk
+        for entry in path.read_dir().map_err(ConfigurationError::Parsing)? {
+            let entry = entry.map_err(ConfigurationError::Parsing)?;
+            let path = entry.path();
+
+            if path.is_file() {
+                let disk = Disk::try_from(&path).map_err(ConfigurationError::Parsing)?;
+                disks.push(disk);
+            }
+        }
+
+        Ok(disks)
+    }
+
+    fn parse_templates_in_directory(
+        &self,
+        path: &PathBuf,
+    ) -> Result<Option<Template>, ConfigurationError> {
+        if path.exists() {
+            let template = Template::try_from(path).map_err(ConfigurationError::Parsing)?;
+            return Ok(Some(template));
+        }
+
+        Ok(None)
+    }
+
+    fn parse_disks(&self) -> Result<Vec<Disk>, ConfigurationError> {
+        let disks_path = self.get_disks_path();
+
+        self.parse_disks_in_directory(&disks_path)
+    }
+
+    fn parse_snapshots(&self) -> Result<Vec<Disk>, ConfigurationError> {
+        let snapshots_path = self.get_snapshots_path();
+
+        self.parse_disks_in_directory(&snapshots_path)
+    }
+
+    fn parse_templates(&self) -> Result<Option<Template>, ConfigurationError> {
+        let templates_path = self.get_templates_path();
+
+        self.parse_templates_in_directory(&templates_path)
+    }
+
     /// Get the domain name
     /// This is the name of the domain that is used to create
     /// the domain in libvirt.
@@ -98,6 +181,10 @@ impl Domain {
         self.configuration_file.as_ref()
     }
 
+    pub fn get_configuration_file_path(&self) -> PathBuf {
+        self.path.join("config.xml")
+    }
+
     /// Get the disks for the domain
     /// This is the list of disks that are used by the domain.
     /// It is used to create the domain in libvirt.
@@ -109,6 +196,24 @@ impl Domain {
         &self.disks
     }
 
+    pub fn get_disks_path(&self) -> PathBuf {
+        self.path.join("disks")
+    }
+
+    /// Get the disk snapshots for the domain
+    /// This is the list of disk snapshots that are used by the domain.
+    ///
+    /// # Returns
+    ///
+    /// * `&Vec<Disk>` - The list of disk snapshots for the domain.
+    pub fn get_snapshots(&self) -> &Vec<Disk> {
+        &self.snapshots
+    }
+
+    pub fn get_snapshots_path(&self) -> PathBuf {
+        self.get_disks_path().join("snapshots")
+    }
+
     /// Get the Packer templates for the domain
     /// It is used to create the domain disk image.
     ///
@@ -120,20 +225,85 @@ impl Domain {
     pub fn get_templates(&self) -> Option<&Template> {
         self.templates.as_ref()
     }
+
+    pub fn get_templates_path(&self) -> PathBuf {
+        self.path.join("templates")
+    }
 }
 
 impl Display for Domain {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
-            "Domain({{ name: {}, path: {}, disks: {:?} }})",
+            "Domain({{ name: {}, path: {}, disks: {:?}, snapshots: {:?} }})",
             self.name,
             self.path.display(),
-            self.disks
+            self.disks,
+            self.snapshots,
         )
     }
 }
 
+impl TryFrom<&PathBuf> for Domain {
+    type Error = ConfigurationError;
+
+    /// Try to create a Domain from a path.
+    ///
+    /// The given path should be the path to the domain directory configuration.
+    fn try_from(path: &PathBuf) -> Result<Self, Self::Error> {
+        // Check if the file exists
+        path.try_exists().map_err(ConfigurationError::Parsing)?;
+
+        // Check if the file is a regular file
+        if path.is_file() {
+            return Err(ConfigurationError::Parsing(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                format!("Not a directory: {}", path.display()),
+            )));
+        }
+
+        // Check if the file is not empty
+        let metadata = path.metadata().map_err(ConfigurationError::Parsing)?;
+        metadata.len().eq(&0).then(|| {
+            ConfigurationError::Parsing(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                format!("File is empty: {}", path.display()),
+            ))
+        });
+
+        let name = path
+            .file_name()
+            .ok_or_else(|| {
+                std::io::Error::new(
+                    std::io::ErrorKind::InvalidData,
+                    format!("No file name for path: {}", path.display()),
+                )
+            })
+            .map_err(ConfigurationError::Parsing)?
+            .to_string_lossy()
+            .to_string();
+
+        let domain = Domain::new_empty(name.clone(), path.clone());
+
+        let config_file = domain.parse_configuration_file()?;
+
+        let disks = domain.parse_disks()?;
+
+        let snapshots = domain.parse_snapshots()?;
+
+        let templates = domain.parse_templates()?;
+
+        Ok(Domain {
+            name,
+            path: path.clone(),
+            configuration_file: config_file,
+            disks,
+            snapshots,
+            templates,
+        })
+    }
+}
+
 #[cfg(test)]
 mod tests {
 
@@ -153,6 +323,7 @@ mod tests {
             PathBuf::from("/xenith/domains/test_domain"),
             Some(PathBuf::from("/xenith/domains/test_domain/config.xml")),
             vec![disk.clone()],
+            vec![],
             None,
         );
 
@@ -166,6 +337,7 @@ mod tests {
             Some(&PathBuf::from("/xenith/domains/test_domain/config.xml"))
         );
         assert_eq!(domain.get_disks(), &vec![disk]);
+        assert_eq!(domain.get_snapshots(), &vec![]);
         assert!(domain.get_templates().is_none());
     }
 }

xenith-domain-management/src/configuration/template.rs

@@ -57,6 +57,82 @@ impl Display for Template {
     }
 }
 
+impl TryFrom<&PathBuf> for Template {
+    type Error = std::io::Error;
+
+    /// Creates a new Template from a directory path.
+    /// The directory must contain a file with the extension `.pkr.hcl` for the image template
+    /// and an optional file with the extension `.hcl` for the variables.
+    fn try_from(path: &PathBuf) -> Result<Self, Self::Error> {
+        // Check if the file exists
+        path.try_exists()?;
+
+        // Check if the file is a directory
+        if path.is_file() {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                format!("Not a regular file: {}", path.display()),
+            ));
+        }
+
+        // Check if the directory is empty
+        if path.read_dir()?.next().is_none() {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                format!("Directory is empty: {}", path.display()),
+            ));
+        }
+
+        let mut image_template = None;
+        let mut variables = None;
+
+        let mut hcl_files = vec![];
+        for entry in path.read_dir()? {
+            let entry = entry?;
+            let path = entry.path();
+            let extension = path.extension().and_then(|s| s.to_str());
+
+            // Check if the file is a regular file
+            if !path.is_file() {
+                continue;
+            }
+
+            if extension != Some("hcl") {
+                continue;
+            }
+
+            hcl_files.push(path);
+        }
+
+        // If `.pkr.hcl` file is found, set it as the image template
+        for file in hcl_files.iter() {
+            let file_name = file
+                .file_name()
+                .and_then(|s| s.to_str())
+                .unwrap_or_default();
+
+            if file_name.contains(".pkr.hcl") {
+                image_template = Some(file.clone());
+            } else if file_name.contains(".hcl") {
+                variables = Some(file.clone());
+            }
+        }
+
+        if image_template.is_none() {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::NotFound,
+                format!("No image template found in directory: {}", path.display()),
+            ));
+        }
+        let image_template = image_template.unwrap();
+
+        Ok(Template {
+            image_template,
+            variables,
+        })
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;