[pve-devel] [PATCH v3 09/30] auto-installer: add answer file definition

[Aaron Lauterer <a.lauterer@proxmox.com>]

Signed-off-by: Aaron Lauterer <a.lauterer@proxmox.com>
---
 proxmox-auto-installer/Cargo.toml    |   1 +
 proxmox-auto-installer/src/answer.rs | 256 +++++++++++++++++++++++++++
 proxmox-auto-installer/src/lib.rs    |   1 +
 3 files changed, 258 insertions(+)
 create mode 100644 proxmox-auto-installer/src/answer.rs

diff --git a/proxmox-auto-installer/Cargo.toml b/proxmox-auto-installer/Cargo.toml
index 67218dd..80de4fa 100644
--- a/proxmox-auto-installer/Cargo.toml
+++ b/proxmox-auto-installer/Cargo.toml
@@ -12,3 +12,4 @@ proxmox-installer-common = { path = "../proxmox-installer-common" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 toml = "0.7"
+enum-iterator = "0.6.0"
diff --git a/proxmox-auto-installer/src/answer.rs b/proxmox-auto-installer/src/answer.rs
new file mode 100644
index 0000000..96e5608
--- /dev/null
+++ b/proxmox-auto-installer/src/answer.rs
@@ -0,0 +1,256 @@
+use enum_iterator::IntoEnumIterator;
+use proxmox_installer_common::{
+    options::{BtrfsRaidLevel, FsType, ZfsChecksumOption, ZfsCompressOption, ZfsRaidLevel},
+    utils::{CidrAddress, Fqdn},
+};
+use serde::{Deserialize, Serialize};
+use std::{collections::BTreeMap, net::IpAddr};
+
+#[derive(Clone, Deserialize, Debug)]
+#[serde(rename_all = "kebab-case")]
+pub struct Answer {
+    pub global: Global,
+    pub network: Network,
+    #[serde(rename = "disk-setup")]
+    pub disks: Disks,
+}
+
+#[derive(Clone, Deserialize, Debug)]
+pub struct Global {
+    pub country: String,
+    pub fqdn: Fqdn,
+    pub keyboard: String,
+    pub mailto: String,
+    pub timezone: String,
+    pub password: String,
+    pub pre_command: Option<Vec<String>>,
+    pub post_command: Option<Vec<String>>,
+    pub reboot_on_error: Option<bool>,
+}
+
+#[derive(Clone, Deserialize, Debug)]
+struct NetworkInAnswer {
+    pub use_dhcp: Option<bool>,
+    pub cidr: Option<CidrAddress>,
+    pub dns: Option<IpAddr>,
+    pub gateway: Option<IpAddr>,
+    // use BTreeMap to have keys sorted
+    pub filter: Option<BTreeMap<String, String>>,
+}
+
+#[derive(Clone, Deserialize, Debug)]
+#[serde(try_from = "NetworkInAnswer")]
+pub struct Network {
+    pub network_settings: NetworkSettings,
+}
+
+impl TryFrom<NetworkInAnswer> for Network {
+    type Error = &'static str;
+
+    fn try_from(source: NetworkInAnswer) -> Result<Self, Self::Error> {
+        if source.use_dhcp.is_none() || source.use_dhcp == Some(false) {
+            if source.cidr.is_none() {
+                return Err("Field 'cidr' must be set.");
+            }
+            if source.dns.is_none() {
+                return Err("Field 'dns' must be set.");
+            }
+            if source.gateway.is_none() {
+                return Err("Field 'gateway' must be set.");
+            }
+            if source.filter.is_none() {
+                return Err("Field 'filter' must be set.");
+            }
+
+            Ok(Network {
+                network_settings: NetworkSettings::Manual(NetworkManual {
+                    cidr: source.cidr.unwrap(),
+                    dns: source.dns.unwrap(),
+                    gateway: source.gateway.unwrap(),
+                    filter: source.filter.unwrap(),
+                }),
+            })
+        } else {
+            Ok(Network {
+                network_settings: NetworkSettings::Dhcp(true),
+            })
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum NetworkSettings {
+    Dhcp(bool),
+    Manual(NetworkManual),
+}
+
+#[derive(Clone, Debug)]
+pub struct NetworkManual {
+    pub cidr: CidrAddress,
+    pub dns: IpAddr,
+    pub gateway: IpAddr,
+    // use BTreeMap to have keys sorted
+    pub filter: BTreeMap<String, String>,
+}
+
+#[derive(Clone, Deserialize, Debug)]
+pub struct DiskSetup {
+    pub filesystem: Filesystem,
+    pub disk_list: Option<Vec<String>>,
+    // use BTreeMap to have keys sorted
+    pub filter: Option<BTreeMap<String, String>>,
+    pub filter_match: Option<FilterMatch>,
+    pub zfs: Option<ZfsOptions>,
+    pub lvm: Option<LvmOptions>,
+    pub btrfs: Option<BtrfsOptions>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(try_from = "DiskSetup")]
+pub struct Disks {
+    pub fs_type: FsType,
+    pub disk_selection: DiskSelection,
+    pub filter_match: Option<FilterMatch>,
+    pub fs_options: FsOptions,
+}
+
+impl TryFrom<DiskSetup> for Disks {
+    type Error = &'static str;
+
+    fn try_from(source: DiskSetup) -> Result<Self, Self::Error> {
+        if source.disk_list.is_none() && source.filter.is_none() {
+            return Err("Need either 'disk_list' or 'filter' set");
+        }
+        if source.disk_list.clone().is_some_and(|v| v.is_empty()) {
+            return Err("'disk_list' cannot be empty");
+        }
+        if source.disk_list.is_some() && source.filter.is_some() {
+            return Err("Cannot use both, 'disk_list' and 'filter'");
+        }
+
+        let disk_selection = match source.disk_list {
+            Some(disk_list) => DiskSelection::Selection(disk_list),
+            None => DiskSelection::Filter(source.filter.unwrap()),
+        };
+
+        // TODO: improve checks for foreign FS options. E.g. less verbose and handling new FS types
+        // automatically
+        let fs_options;
+        let fs = match source.filesystem {
+            Filesystem::Xfs => {
+                if source.zfs.is_some() || source.btrfs.is_some() {
+                    return Err("make sure only 'lvm' options are set");
+                }
+                fs_options = FsOptions::LVM(source.lvm.unwrap_or(LvmOptions::default()));
+                FsType::Xfs
+            }
+            Filesystem::Ext4 => {
+                if source.zfs.is_some() || source.btrfs.is_some() {
+                    return Err("make sure only 'lvm' options are set");
+                }
+                fs_options = FsOptions::LVM(source.lvm.unwrap_or(LvmOptions::default()));
+                FsType::Ext4
+            }
+            Filesystem::Zfs => {
+                if source.lvm.is_some() || source.btrfs.is_some() {
+                    return Err("make sure only 'zfs' options are set");
+                }
+                if source.zfs.is_none() || source.zfs.is_some_and(|v| v.raid.is_none()) {
+                    return Err("ZFS raid level 'zfs.raid' must be set");
+                }
+                fs_options = FsOptions::ZFS(source.zfs.unwrap());
+                FsType::Zfs(source.zfs.unwrap().raid.unwrap())
+            }
+            Filesystem::Btrfs => {
+                if source.zfs.is_some() || source.lvm.is_some() {
+                    return Err("make sure only 'btrfs' options are set");
+                }
+                if source.btrfs.is_none() || source.btrfs.is_some_and(|v| v.raid.is_none()) {
+                    return Err("BRFS raid level 'btrfs.raid' must be set");
+                }
+                fs_options = FsOptions::BRFS(source.btrfs.unwrap());
+                FsType::Btrfs(source.btrfs.unwrap().raid.unwrap())
+            }
+        };
+
+        let res = Disks {
+            fs_type: fs,
+            disk_selection,
+            filter_match: source.filter_match,
+            fs_options,
+        };
+        Ok(res)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum FsOptions {
+    LVM(LvmOptions),
+    ZFS(ZfsOptions),
+    BRFS(BtrfsOptions),
+}
+
+#[derive(Clone, Debug)]
+pub enum DiskSelection {
+    Selection(Vec<String>),
+    Filter(BTreeMap<String, String>),
+}
+#[derive(Clone, Deserialize, Debug, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum FilterMatch {
+    Any,
+    All,
+}
+
+#[derive(Clone, IntoEnumIterator, Deserialize, Serialize, Debug, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum Filesystem {
+    Ext4,
+    Xfs,
+    Zfs,
+    Btrfs,
+}
+
+#[derive(Clone, Copy, Default, Deserialize, Debug)]
+pub struct ZfsOptions {
+    pub raid: Option<ZfsRaidLevel>,
+    pub ashift: Option<usize>,
+    pub arc_max: Option<usize>,
+    pub checksum: Option<ZfsChecksumOption>,
+    pub compress: Option<ZfsCompressOption>,
+    pub copies: Option<usize>,
+    pub hdsize: Option<f64>,
+}
+
+impl ZfsOptions {
+    pub fn new() -> ZfsOptions {
+        ZfsOptions::default()
+    }
+}
+
+#[derive(Clone, Copy, Default, Deserialize, Serialize, Debug)]
+pub struct LvmOptions {
+    pub hdsize: Option<f64>,
+    pub swapsize: Option<f64>,
+    pub maxroot: Option<f64>,
+    pub maxvz: Option<f64>,
+    pub minfree: Option<f64>,
+}
+
+impl LvmOptions {
+    pub fn new() -> LvmOptions {
+        LvmOptions::default()
+    }
+}
+
+#[derive(Clone, Copy, Default, Deserialize, Debug)]
+pub struct BtrfsOptions {
+    pub hdsize: Option<f64>,
+    pub raid: Option<BtrfsRaidLevel>,
+}
+
+impl BtrfsOptions {
+    pub fn new() -> BtrfsOptions {
+        BtrfsOptions::default()
+    }
+}
diff --git a/proxmox-auto-installer/src/lib.rs b/proxmox-auto-installer/src/lib.rs
index e69de29..7813b98 100644
--- a/proxmox-auto-installer/src/lib.rs
+++ b/proxmox-auto-installer/src/lib.rs
@@ -0,0 +1 @@
+pub mod answer;
-- 
2.39.2