wip: fix build

Author: cilki

goldboot/src/builder/mod.rs

@@ -3,6 +3,7 @@ use self::{fabricators::Fabricator, os::Os};
 use crate::builder::os::BuildImage;
 use crate::cli::cmd::Commands;
 use crate::library::ImageLibrary;
+use crate::size;
 
 use anyhow::{Result, anyhow, bail};
 use byte_unit::Byte;
@@ -90,7 +91,11 @@ impl Builder {
     pub fn run(&mut self, cli: Commands) -> Result<()> {
         self.start_time = Some(SystemTime::now());
 
-        let qcow_size: u64 = self.elements.iter().map(|element| 0 /*TODO*/).sum();
+        let qcow_size: u64 = self
+            .elements
+            .iter()
+            .map(|element| -> u64 { size!(element).into() })
+            .sum();
 
         match cli {
             Commands::Build {

goldboot/src/builder/options/size.rs

@@ -48,6 +48,16 @@ impl Validate for Size {
     }
 }
 
+impl Into<u64> for Size {
+    fn into(self) -> u64 {
+        // Assume Size was validated previously
+        self.0
+            .parse::<Byte>()
+            .expect("Size was not validated")
+            .as_u64()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -56,19 +66,8 @@ mod tests {
     fn test_valid_sizes() {
         // Test various valid size formats
         let sizes = vec![
-            "16G",
-            "16GB",
-            "512M",
-            "512MB",
-            "1T",
-            "1TB",
-            "2048K",
-            "2048KB",
-            "1024",
-            "1 GB",
-            "1.5 GB",
-            "100 MiB",
-            "16GiB",
+            "16G", "16GB", "512M", "512MB", "1T", "1TB", "2048K", "2048KB", "1024", "1 GB",
+            "1.5 GB", "100 MiB", "16GiB",
         ];
 
         for size_str in sizes {
@@ -85,10 +84,10 @@ mod tests {
     fn test_invalid_sizes() {
         // Test various invalid size formats
         let invalid_sizes = vec![
-            "",           // Empty string
-            "abc",        // No numbers
-            "G16",        // Unit before number
-            "16X",        // Invalid unit
+            "",            // Empty string
+            "abc",         // No numbers
+            "G16",         // Unit before number
+            "16X",         // Invalid unit
             "hello world", // Completely invalid
         ];
 
@@ -106,16 +105,10 @@ mod tests {
     fn test_zero_size() {
         // Test that zero size is rejected
         let size = Size("0".to_string());
-        assert!(
-            size.validate().is_err(),
-            "Expected zero size to be invalid"
-        );
+        assert!(size.validate().is_err(), "Expected zero size to be invalid");
 
         let size = Size("0GB".to_string());
-        assert!(
-            size.validate().is_err(),
-            "Expected zero size to be invalid"
-        );
+        assert!(size.validate().is_err(), "Expected zero size to be invalid");
     }
 
     #[test]
@@ -132,12 +125,7 @@ mod tests {
     #[test]
     fn test_large_sizes() {
         // Test large sizes
-        let sizes = vec![
-            "1000T",
-            "1000TB",
-            "1PB",
-            "100000GB",
-        ];
+        let sizes = vec!["1000T", "1000TB", "1PB", "100000GB"];
 
         for size_str in sizes {
             let size = Size(size_str.to_string());

goldboot/src/builder/os/alpine_linux/mod.rs

@@ -1,14 +1,15 @@
 use anyhow::Result;
 use goldboot_image::ImageArch;
 use serde::{Deserialize, Serialize};
+use smart_default::SmartDefault;
 use std::fmt::Display;
 use strum::{Display, EnumIter, IntoEnumIterator};
 use validator::Validate;
 
 use crate::{
     builder::{
         Builder,
-        options::{hostname::Hostname, iso::Iso, unix_account::RootPassword},
+        options::{hostname::Hostname, iso::Iso, size::Size, unix_account::RootPassword},
         qemu::{OsCategory, QemuBuilder},
     },
     cli::prompt::Prompt,
@@ -18,31 +19,21 @@ use crate::{
 use super::BuildImage;
 
 /// Produces [Alpine Linux](https://www.alpinelinux.org) images.
-#[derive(Clone, Serialize, Deserialize, Validate, Debug, goldboot_macros::Prompt)]
+#[derive(Clone, Serialize, Deserialize, Validate, Debug, SmartDefault, goldboot_macros::Prompt)]
 pub struct AlpineLinux {
+    pub size: Size,
     pub edition: AlpineEdition,
     #[serde(flatten)]
     pub hostname: Hostname,
     pub release: AlpineRelease,
     pub root_password: RootPassword,
+    #[default(Iso {
+        url: "https://dl-cdn.alpinelinux.org/alpine/v3.19/releases/x86_64/alpine-standard-3.19.1-x86_64.iso".parse().unwrap(),
+        checksum: Some("sha256:12addd7d4154df1caf5f258b80ad72e7a724d33e75e6c2e6adc1475298d47155".to_string()),
+    })]
     pub iso: Iso,
 }
 
-impl Default for AlpineLinux {
-    fn default() -> Self {
-        Self {
-            edition: AlpineEdition::default(),
-            hostname: Hostname::default(),
-            release: AlpineRelease::default(),
-            root_password: RootPassword::default(),
-            iso: Iso {
-                url: "https://dl-cdn.alpinelinux.org/alpine/v3.19/releases/x86_64/alpine-standard-3.19.1-x86_64.iso".parse().unwrap(),
-                checksum: Some("sha256:12addd7d4154df1caf5f258b80ad72e7a724d33e75e6c2e6adc1475298d47155".to_string()),
-            },
-        }
-    }
-}
-
 impl BuildImage for AlpineLinux {
     fn build(&self, worker: &Builder) -> Result<()> {
         let mut qemu = QemuBuilder::new(&worker, OsCategory::Linux)

goldboot/src/builder/os/arch_linux/archinstall.rs

@@ -249,7 +249,7 @@ impl From<&super::ArchLinux> for ArchinstallConfig {
             no_pkg_lookups: false,
             ntp: true,
             offline: false,
-            packages: value.packages.clone().unwrap_or_default().packages,
+            packages: value.packages.clone().unwrap_or_default().0,
             parallel_downloads: 0,
             profile_config: None,
             silent: true,

goldboot/src/builder/os/debian/mod.rs

@@ -1,6 +1,7 @@
 use anyhow::{Result, bail};
 use goldboot_image::ImageArch;
 use serde::{Deserialize, Serialize};
+use smart_default::SmartDefault;
 use std::io::{BufRead, BufReader};
 use strum::{Display, EnumIter, IntoEnumIterator};
 use validator::Validate;
@@ -9,7 +10,9 @@ use crate::{
     builder::{
         Builder,
         http::HttpServer,
-        options::{hostname::Hostname, iso::Iso, unix_account::RootPassword},
+        options::{
+            arch::Arch, hostname::Hostname, iso::Iso, size::Size, unix_account::RootPassword,
+        },
         qemu::{OsCategory, QemuBuilder},
     },
     cli::prompt::Prompt,
@@ -24,31 +27,22 @@ use super::BuildImage;
 ///
 /// Upstream: https://www.debian.org
 /// Maintainer: cilki
-#[derive(Clone, Serialize, Deserialize, Validate, Debug, goldboot_macros::Prompt)]
+#[derive(Clone, Serialize, Deserialize, Validate, Debug, SmartDefault, goldboot_macros::Prompt)]
 pub struct Debian {
+    #[default(Arch(ImageArch::Amd64))]
+    pub arch: Arch,
+    pub size: Size,
     pub edition: DebianEdition,
-
     #[serde(flatten)]
     pub hostname: Option<Hostname>,
     pub root_password: RootPassword,
-
+    #[default(Iso {
+        url: "http://example.com".parse().unwrap(),
+        checksum: None,
+    })]
     pub iso: Iso,
 }
 
-impl Default for Debian {
-    fn default() -> Self {
-        Self {
-            root_password: RootPassword::default(),
-            edition: DebianEdition::default(),
-            hostname: Some(Hostname::default()),
-            iso: Iso {
-                url: "https://example.com".parse().unwrap(),
-                checksum: None,
-            },
-        }
-    }
-}
-
 impl BuildImage for Debian {
     fn build(&self, worker: &Builder) -> Result<()> {
         let mut qemu = QemuBuilder::new(&worker, OsCategory::Linux)

goldboot/src/builder/os/mod.rs

@@ -26,22 +26,16 @@ pub mod nix;
 pub mod windows_10;
 pub mod windows_11;
 
-/// Macro to access fields from the inner variant of an Os enum.
-///
-/// Usage: `inner!(os).size` or `inner!(os).hostname`
-///
-/// This generates a match statement that extracts the inner variant
-/// and allows accessing its fields.
 #[macro_export]
-macro_rules! inner {
+macro_rules! size {
     ($os:expr) => {
-        match $os {
-            Os::AlpineLinux(inner)
-            | Os::ArchLinux(inner)
-            | Os::Debian(inner)
-            | Os::Nix(inner)
-            | Os::Windows10(inner)
-            | Os::Windows11(inner) => inner,
+        match $os.clone() {
+            Os::AlpineLinux(inner) => inner.size,
+            Os::ArchLinux(inner) => inner.size,
+            Os::Debian(inner) => inner.size,
+            Os::Nix(inner) => inner.size,
+            Os::Windows10(inner) => inner.size,
+            Os::Windows11(inner) => inner.size,
         }
     };
 }

goldboot/src/builder/os/nix/mod.rs

@@ -1,13 +1,14 @@
 use anyhow::Result;
 use goldboot_image::ImageArch;
 use serde::{Deserialize, Serialize};
+use smart_default::SmartDefault;
 use std::{collections::HashMap, path::PathBuf};
 use validator::Validate;
 
 use crate::{
     builder::{
         Builder,
-        options::iso::Iso,
+        options::{arch::Arch, iso::Iso, size::Size},
         qemu::{OsCategory, QemuBuilder},
     },
     cli::prompt::Prompt,
@@ -23,30 +24,26 @@ use super::BuildImage;
 ///
 /// Upstream: https://www.nixos.org
 /// Maintainer: cilki
-#[derive(Clone, Serialize, Deserialize, Validate, Debug, goldboot_macros::Prompt)]
+#[derive(Clone, Serialize, Deserialize, Validate, Debug, SmartDefault, goldboot_macros::Prompt)]
 pub struct Nix {
+    #[default(Arch(ImageArch::Amd64))]
+    pub arch: Arch,
+    pub size: Size,
+
     /// Path to /etc/nixos/configuration.nix
+    #[default(ConfigurationPath("configuration.nix".parse().unwrap()))]
     pub configuration: ConfigurationPath,
 
     /// Path to /etc/nixos/hardware-configuration.nix
     pub hardware_configuration: Option<ConfigurationPath>,
 
+    #[default(Iso {
+        url: "http://example.com".parse().unwrap(),
+        checksum: None,
+    })]
     pub iso: Iso,
 }
 
-impl Default for Nix {
-    fn default() -> Self {
-        Self {
-            configuration: ConfigurationPath(PathBuf::from("configuration.nix")),
-            hardware_configuration: None,
-            iso: Iso {
-                url: "https://example.com".parse().unwrap(),
-                checksum: None,
-            },
-        }
-    }
-}
-
 impl BuildImage for Nix {
     fn build(&self, worker: &Builder) -> Result<()> {
         let mut qemu = QemuBuilder::new(&worker, OsCategory::Linux)

goldboot/src/builder/os/windows_10/mod.rs

@@ -4,13 +4,14 @@ use anyhow::Result;
 use goldboot_image::ImageArch;
 use serde::{Deserialize, Serialize};
 use serde_win_unattend::*;
+use smart_default::SmartDefault;
 use tracing::debug;
 use validator::Validate;
 
 use crate::{
     builder::{
         Builder,
-        options::{hostname::Hostname, iso::Iso},
+        options::{arch::Arch, hostname::Hostname, iso::Iso, size::Size},
         qemu::{OsCategory, QemuBuilder},
     },
     cli::prompt::Prompt,
@@ -23,32 +24,24 @@ use super::BuildImage;
 ///
 /// Upstream: https://microsoft.com
 /// Maintainer: cilki
-#[derive(Clone, Serialize, Deserialize, Validate, Debug, goldboot_macros::Prompt)]
+#[derive(Clone, Serialize, Deserialize, Validate, Debug, SmartDefault, goldboot_macros::Prompt)]
 pub struct Windows10 {
+    #[default(Arch(ImageArch::Amd64))]
+    pub arch: Arch,
+    pub size: Size,
     #[serde(flatten)]
     pub hostname: Hostname,
 
     // username: String,
 
     // password: String,
+    #[default(Iso {
+        url: "http://example.com".parse().unwrap(),
+        checksum: None,
+    })]
     iso: Iso,
 }
 
-impl Default for Windows10 {
-    fn default() -> Self {
-        // TODO? https://github.com/pbatard/Fido
-        Self {
-            hostname: Hostname::default(),
-            // username: todo!(),
-            // password: todo!(),
-            iso: Iso {
-                url: "https://example.com".parse().unwrap(),
-                checksum: None,
-            },
-        }
-    }
-}
-
 impl BuildImage for Windows10 {
     fn build(&self, worker: &Builder) -> Result<()> {
         let unattended = UnattendXml {