[pve-devel] [PATCH 02/12] common: copy common code from tui-installer

Christoph Heiss c.heiss at proxmox.com
Fri Oct 27 13:14:03 CEST 2023


Simple code move/copy, so LGTM.

Reviewed-by: Christoph Heiss <c.heiss at proxmox.com>

On Wed, Oct 25, 2023 at 06:00:01PM +0200, Aaron Lauterer wrote:
>
> Copy code that is common to its own crate.
>
> Signed-off-by: Aaron Lauterer <a.lauterer at proxmox.com>
> ---
>  proxmox-installer-common/Cargo.toml         |   2 +
>  proxmox-installer-common/src/disk_checks.rs | 237 ++++++++++++
>  proxmox-installer-common/src/lib.rs         |   4 +
>  proxmox-installer-common/src/options.rs     | 387 ++++++++++++++++++++
>  proxmox-installer-common/src/setup.rs       | 330 +++++++++++++++++
>  proxmox-installer-common/src/utils.rs       | 268 ++++++++++++++
>  6 files changed, 1228 insertions(+)
>  create mode 100644 proxmox-installer-common/src/disk_checks.rs
>  create mode 100644 proxmox-installer-common/src/options.rs
>  create mode 100644 proxmox-installer-common/src/setup.rs
>  create mode 100644 proxmox-installer-common/src/utils.rs
>
> diff --git a/proxmox-installer-common/Cargo.toml b/proxmox-installer-common/Cargo.toml
> index b8762e8..bde5457 100644
> --- a/proxmox-installer-common/Cargo.toml
> +++ b/proxmox-installer-common/Cargo.toml
> @@ -8,3 +8,5 @@ exclude = [ "build", "debian" ]
>  homepage = "https://www.proxmox.com"
>
>  [dependencies]
> +serde = { version = "1.0", features = ["derive"] }
> +serde_json = "1.0"
> diff --git a/proxmox-installer-common/src/disk_checks.rs b/proxmox-installer-common/src/disk_checks.rs
> new file mode 100644
> index 0000000..15b5928
> --- /dev/null
> +++ b/proxmox-installer-common/src/disk_checks.rs
> @@ -0,0 +1,237 @@
> +use std::collections::HashSet;
> +
> +use crate::options::{BtrfsRaidLevel, Disk, ZfsRaidLevel};
> +use crate::setup::BootType;
> +
> +/// Checks a list of disks for duplicate entries, using their index as key.
> +///
> +/// # Arguments
> +///
> +/// * `disks` - A list of disks to check for duplicates.
> +fn check_for_duplicate_disks(disks: &[Disk]) -> Result<(), &Disk> {
> +    let mut set = HashSet::new();
> +
> +    for disk in disks {
> +        if !set.insert(&disk.index) {
> +            return Err(disk);
> +        }
> +    }
> +
> +    Ok(())
> +}
> +
> +/// Simple wrapper which returns an descriptive error if the list of disks is too short.
> +///
> +/// # Arguments
> +///
> +/// * `disks` - A list of disks to check the lenght of.
> +/// * `min` - Minimum number of disks
> +fn check_raid_min_disks(disks: &[Disk], min: usize) -> Result<(), String> {
> +    if disks.len() < min {
> +        Err(format!("Need at least {min} disks"))
> +    } else {
> +        Ok(())
> +    }
> +}
> +
> +/// Checks all disks for legacy BIOS boot compatibility and reports an error as appropriate. 4Kn
> +/// disks are generally broken with legacy BIOS and cannot be booted from.
> +///
> +/// # Arguments
> +///
> +/// * `runinfo` - `RuntimeInfo` instance of currently running system
> +/// * `disks` - List of disks designated as bootdisk targets.
> +fn check_disks_4kn_legacy_boot(boot_type: BootType, disks: &[Disk]) -> Result<(), &str> {
> +    let is_blocksize_4096 = |disk: &Disk| disk.block_size.map(|s| s == 4096).unwrap_or(false);
> +
> +    if boot_type == BootType::Bios && disks.iter().any(is_blocksize_4096) {
> +        return Err("Booting from 4Kn drive in legacy BIOS mode is not supported.");
> +    }
> +
> +    Ok(())
> +}
> +
> +/// Checks whether a user-supplied ZFS RAID setup is valid or not, such as disk sizes andminimum
> +/// number of disks.
> +///
> +/// # Arguments
> +///
> +/// * `level` - The targeted ZFS RAID level by the user.
> +/// * `disks` - List of disks designated as RAID targets.
> +fn check_zfs_raid_config(level: ZfsRaidLevel, disks: &[Disk]) -> Result<(), String> {
> +    // See also Proxmox/Install.pm:get_zfs_raid_setup()
> +
> +    let check_mirror_size = |disk1: &Disk, disk2: &Disk| {
> +        if (disk1.size - disk2.size).abs() > disk1.size / 10. {
> +            Err(format!(
> +                "Mirrored disks must have same size:\n\n  * {disk1}\n  * {disk2}"
> +            ))
> +        } else {
> +            Ok(())
> +        }
> +    };
> +
> +    match level {
> +        ZfsRaidLevel::Raid0 => check_raid_min_disks(disks, 1)?,
> +        ZfsRaidLevel::Raid1 => {
> +            check_raid_min_disks(disks, 2)?;
> +            for disk in disks {
> +                check_mirror_size(&disks[0], disk)?;
> +            }
> +        }
> +        ZfsRaidLevel::Raid10 => {
> +            check_raid_min_disks(disks, 4)?;
> +            // Pairs need to have the same size
> +            for i in (0..disks.len()).step_by(2) {
> +                check_mirror_size(&disks[i], &disks[i + 1])?;
> +            }
> +        }
> +        // For RAID-Z: minimum disks number is level + 2
> +        ZfsRaidLevel::RaidZ => {
> +            check_raid_min_disks(disks, 3)?;
> +            for disk in disks {
> +                check_mirror_size(&disks[0], disk)?;
> +            }
> +        }
> +        ZfsRaidLevel::RaidZ2 => {
> +            check_raid_min_disks(disks, 4)?;
> +            for disk in disks {
> +                check_mirror_size(&disks[0], disk)?;
> +            }
> +        }
> +        ZfsRaidLevel::RaidZ3 => {
> +            check_raid_min_disks(disks, 5)?;
> +            for disk in disks {
> +                check_mirror_size(&disks[0], disk)?;
> +            }
> +        }
> +    }
> +
> +    Ok(())
> +}
> +
> +/// Checks whether a user-supplied Btrfs RAID setup is valid or not, such as minimum
> +/// number of disks.
> +///
> +/// # Arguments
> +///
> +/// * `level` - The targeted Btrfs RAID level by the user.
> +/// * `disks` - List of disks designated as RAID targets.
> +fn check_btrfs_raid_config(level: BtrfsRaidLevel, disks: &[Disk]) -> Result<(), String> {
> +    // See also Proxmox/Install.pm:get_btrfs_raid_setup()
> +
> +    match level {
> +        BtrfsRaidLevel::Raid0 => check_raid_min_disks(disks, 1)?,
> +        BtrfsRaidLevel::Raid1 => check_raid_min_disks(disks, 2)?,
> +        BtrfsRaidLevel::Raid10 => check_raid_min_disks(disks, 4)?,
> +    }
> +
> +    Ok(())
> +}
> +
> +#[cfg(test)]
> +mod tests {
> +    use super::*;
> +
> +    fn dummy_disk(index: usize) -> Disk {
> +        Disk {
> +            index: index.to_string(),
> +            path: format!("/dev/dummy{index}"),
> +            model: Some("Dummy disk".to_owned()),
> +            size: 1024. * 1024. * 1024. * 8.,
> +            block_size: Some(512),
> +        }
> +    }
> +
> +    fn dummy_disks(num: usize) -> Vec<Disk> {
> +        (0..num).map(dummy_disk).collect()
> +    }
> +
> +    #[test]
> +    fn duplicate_disks() {
> +        assert!(check_for_duplicate_disks(&dummy_disks(2)).is_ok());
> +        assert_eq!(
> +            check_for_duplicate_disks(&[
> +                dummy_disk(0),
> +                dummy_disk(1),
> +                dummy_disk(2),
> +                dummy_disk(2),
> +                dummy_disk(3),
> +            ]),
> +            Err(&dummy_disk(2)),
> +        );
> +    }
> +
> +    #[test]
> +    fn raid_min_disks() {
> +        let disks = dummy_disks(10);
> +
> +        assert!(check_raid_min_disks(&disks[..1], 2).is_err());
> +        assert!(check_raid_min_disks(&disks[..1], 1).is_ok());
> +        assert!(check_raid_min_disks(&disks, 1).is_ok());
> +    }
> +
> +    #[test]
> +    fn bios_boot_compat_4kn() {
> +        for i in 0..10 {
> +            let mut disks = dummy_disks(10);
> +            disks[i].block_size = Some(4096);
> +
> +            // Must fail if /any/ of the disks are 4Kn
> +            assert!(check_disks_4kn_legacy_boot(BootType::Bios, &disks).is_err());
> +            // For UEFI, we allow it for every configuration
> +            assert!(check_disks_4kn_legacy_boot(BootType::Efi, &disks).is_ok());
> +        }
> +    }
> +
> +    #[test]
> +    fn btrfs_raid() {
> +        let disks = dummy_disks(10);
> +
> +        assert!(check_btrfs_raid_config(BtrfsRaidLevel::Raid0, &[]).is_err());
> +        assert!(check_btrfs_raid_config(BtrfsRaidLevel::Raid0, &disks[..1]).is_ok());
> +        assert!(check_btrfs_raid_config(BtrfsRaidLevel::Raid0, &disks).is_ok());
> +
> +        assert!(check_btrfs_raid_config(BtrfsRaidLevel::Raid1, &[]).is_err());
> +        assert!(check_btrfs_raid_config(BtrfsRaidLevel::Raid1, &disks[..1]).is_err());
> +        assert!(check_btrfs_raid_config(BtrfsRaidLevel::Raid1, &disks[..2]).is_ok());
> +        assert!(check_btrfs_raid_config(BtrfsRaidLevel::Raid1, &disks).is_ok());
> +
> +        assert!(check_btrfs_raid_config(BtrfsRaidLevel::Raid10, &[]).is_err());
> +        assert!(check_btrfs_raid_config(BtrfsRaidLevel::Raid10, &disks[..3]).is_err());
> +        assert!(check_btrfs_raid_config(BtrfsRaidLevel::Raid10, &disks[..4]).is_ok());
> +        assert!(check_btrfs_raid_config(BtrfsRaidLevel::Raid10, &disks).is_ok());
> +    }
> +
> +    #[test]
> +    fn zfs_raid() {
> +        let disks = dummy_disks(10);
> +
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::Raid0, &[]).is_err());
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::Raid0, &disks[..1]).is_ok());
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::Raid0, &disks).is_ok());
> +
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::Raid1, &[]).is_err());
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::Raid1, &disks[..2]).is_ok());
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::Raid1, &disks).is_ok());
> +
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::Raid10, &[]).is_err());
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::Raid10, &dummy_disks(4)).is_ok());
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::Raid10, &disks).is_ok());
> +
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::RaidZ, &[]).is_err());
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::RaidZ, &disks[..2]).is_err());
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::RaidZ, &disks[..3]).is_ok());
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::RaidZ, &disks).is_ok());
> +
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::RaidZ2, &[]).is_err());
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::RaidZ2, &disks[..3]).is_err());
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::RaidZ2, &disks[..4]).is_ok());
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::RaidZ2, &disks).is_ok());
> +
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::RaidZ3, &[]).is_err());
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::RaidZ3, &disks[..4]).is_err());
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::RaidZ3, &disks[..5]).is_ok());
> +        assert!(check_zfs_raid_config(ZfsRaidLevel::RaidZ3, &disks).is_ok());
> +    }
> +}
> diff --git a/proxmox-installer-common/src/lib.rs b/proxmox-installer-common/src/lib.rs
> index e69de29..f0093f5 100644
> --- a/proxmox-installer-common/src/lib.rs
> +++ b/proxmox-installer-common/src/lib.rs
> @@ -0,0 +1,4 @@
> +pub mod disk_checks;
> +pub mod options;
> +pub mod setup;
> +pub mod utils;
> diff --git a/proxmox-installer-common/src/options.rs b/proxmox-installer-common/src/options.rs
> new file mode 100644
> index 0000000..185be2e
> --- /dev/null
> +++ b/proxmox-installer-common/src/options.rs
> @@ -0,0 +1,387 @@
> +use std::net::{IpAddr, Ipv4Addr};
> +use std::{cmp, fmt};
> +
> +use crate::setup::{LocaleInfo, NetworkInfo, RuntimeInfo, SetupInfo};
> +use crate::utils::{CidrAddress, Fqdn};
> +
> +#[derive(Copy, Clone, Debug, Eq, PartialEq)]
> +pub enum BtrfsRaidLevel {
> +    Raid0,
> +    Raid1,
> +    Raid10,
> +}
> +
> +impl fmt::Display for BtrfsRaidLevel {
> +    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
> +        use BtrfsRaidLevel::*;
> +        match self {
> +            Raid0 => write!(f, "RAID0"),
> +            Raid1 => write!(f, "RAID1"),
> +            Raid10 => write!(f, "RAID10"),
> +        }
> +    }
> +}
> +
> +#[derive(Copy, Clone, Debug, Eq, PartialEq)]
> +pub enum ZfsRaidLevel {
> +    Raid0,
> +    Raid1,
> +    Raid10,
> +    RaidZ,
> +    RaidZ2,
> +    RaidZ3,
> +}
> +
> +impl fmt::Display for ZfsRaidLevel {
> +    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
> +        use ZfsRaidLevel::*;
> +        match self {
> +            Raid0 => write!(f, "RAID0"),
> +            Raid1 => write!(f, "RAID1"),
> +            Raid10 => write!(f, "RAID10"),
> +            RaidZ => write!(f, "RAIDZ-1"),
> +            RaidZ2 => write!(f, "RAIDZ-2"),
> +            RaidZ3 => write!(f, "RAIDZ-3"),
> +        }
> +    }
> +}
> +
> +#[derive(Copy, Clone, Debug, Eq, PartialEq)]
> +pub enum FsType {
> +    Ext4,
> +    Xfs,
> +    Zfs(ZfsRaidLevel),
> +    Btrfs(BtrfsRaidLevel),
> +}
> +
> +impl FsType {
> +    pub fn is_btrfs(&self) -> bool {
> +        matches!(self, FsType::Btrfs(_))
> +    }
> +}
> +
> +impl fmt::Display for FsType {
> +    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
> +        use FsType::*;
> +        match self {
> +            Ext4 => write!(f, "ext4"),
> +            Xfs => write!(f, "XFS"),
> +            Zfs(level) => write!(f, "ZFS ({level})"),
> +            Btrfs(level) => write!(f, "Btrfs ({level})"),
> +        }
> +    }
> +}
> +
> +#[derive(Clone, Debug)]
> +pub struct LvmBootdiskOptions {
> +    pub total_size: f64,
> +    pub swap_size: Option<f64>,
> +    pub max_root_size: Option<f64>,
> +    pub max_data_size: Option<f64>,
> +    pub min_lvm_free: Option<f64>,
> +}
> +
> +impl LvmBootdiskOptions {
> +    pub fn defaults_from(disk: &Disk) -> Self {
> +        Self {
> +            total_size: disk.size,
> +            swap_size: None,
> +            max_root_size: None,
> +            max_data_size: None,
> +            min_lvm_free: None,
> +        }
> +    }
> +}
> +
> +#[derive(Clone, Debug)]
> +pub struct BtrfsBootdiskOptions {
> +    pub disk_size: f64,
> +    pub selected_disks: Vec<usize>,
> +}
> +
> +impl BtrfsBootdiskOptions {
> +    /// This panics if the provided slice is empty.
> +    pub fn defaults_from(disks: &[Disk]) -> Self {
> +        let disk = &disks[0];
> +        Self {
> +            disk_size: disk.size,
> +            selected_disks: (0..disks.len()).collect(),
> +        }
> +    }
> +}
> +
> +#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
> +pub enum ZfsCompressOption {
> +    #[default]
> +    On,
> +    Off,
> +    Lzjb,
> +    Lz4,
> +    Zle,
> +    Gzip,
> +    Zstd,
> +}
> +
> +impl fmt::Display for ZfsCompressOption {
> +    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
> +        write!(f, "{}", format!("{self:?}").to_lowercase())
> +    }
> +}
> +
> +impl From<&ZfsCompressOption> for String {
> +    fn from(value: &ZfsCompressOption) -> Self {
> +        value.to_string()
> +    }
> +}
> +
> +pub const ZFS_COMPRESS_OPTIONS: &[ZfsCompressOption] = {
> +    use ZfsCompressOption::*;
> +    &[On, Off, Lzjb, Lz4, Zle, Gzip, Zstd]
> +};
> +
> +#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
> +pub enum ZfsChecksumOption {
> +    #[default]
> +    On,
> +    Off,
> +    Fletcher2,
> +    Fletcher4,
> +    Sha256,
> +}
> +
> +impl fmt::Display for ZfsChecksumOption {
> +    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
> +        write!(f, "{}", format!("{self:?}").to_lowercase())
> +    }
> +}
> +
> +impl From<&ZfsChecksumOption> for String {
> +    fn from(value: &ZfsChecksumOption) -> Self {
> +        value.to_string()
> +    }
> +}
> +
> +pub const ZFS_CHECKSUM_OPTIONS: &[ZfsChecksumOption] = {
> +    use ZfsChecksumOption::*;
> +    &[On, Off, Fletcher2, Fletcher4, Sha256]
> +};
> +
> +#[derive(Clone, Debug)]
> +pub struct ZfsBootdiskOptions {
> +    pub ashift: usize,
> +    pub compress: ZfsCompressOption,
> +    pub checksum: ZfsChecksumOption,
> +    pub copies: usize,
> +    pub disk_size: f64,
> +    pub selected_disks: Vec<usize>,
> +}
> +
> +impl ZfsBootdiskOptions {
> +    /// This panics if the provided slice is empty.
> +    pub fn defaults_from(disks: &[Disk]) -> Self {
> +        let disk = &disks[0];
> +        Self {
> +            ashift: 12,
> +            compress: ZfsCompressOption::default(),
> +            checksum: ZfsChecksumOption::default(),
> +            copies: 1,
> +            disk_size: disk.size,
> +            selected_disks: (0..disks.len()).collect(),
> +        }
> +    }
> +}
> +
> +#[derive(Clone, Debug)]
> +pub enum AdvancedBootdiskOptions {
> +    Lvm(LvmBootdiskOptions),
> +    Zfs(ZfsBootdiskOptions),
> +    Btrfs(BtrfsBootdiskOptions),
> +}
> +
> +#[derive(Clone, Debug, PartialEq)]
> +pub struct Disk {
> +    pub index: String,
> +    pub path: String,
> +    pub model: Option<String>,
> +    pub size: f64,
> +    pub block_size: Option<usize>,
> +}
> +
> +impl fmt::Display for Disk {
> +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
> +        // TODO: Format sizes properly with `proxmox-human-byte` once merged
> +        // https://lists.proxmox.com/pipermail/pbs-devel/2023-May/006125.html
> +        f.write_str(&self.path)?;
> +        if let Some(model) = &self.model {
> +            // FIXME: ellipsize too-long names?
> +            write!(f, " ({model})")?;
> +        }
> +        write!(f, " ({:.2} GiB)", self.size)
> +    }
> +}
> +
> +impl From<&Disk> for String {
> +    fn from(value: &Disk) -> Self {
> +        value.to_string()
> +    }
> +}
> +
> +impl cmp::Eq for Disk {}
> +
> +impl cmp::PartialOrd for Disk {
> +    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
> +        self.index.partial_cmp(&other.index)
> +    }
> +}
> +
> +impl cmp::Ord for Disk {
> +    fn cmp(&self, other: &Self) -> cmp::Ordering {
> +        self.index.cmp(&other.index)
> +    }
> +}
> +
> +#[derive(Clone, Debug)]
> +pub struct BootdiskOptions {
> +    pub disks: Vec<Disk>,
> +    pub fstype: FsType,
> +    pub advanced: AdvancedBootdiskOptions,
> +}
> +
> +impl BootdiskOptions {
> +    pub fn defaults_from(disk: &Disk) -> Self {
> +        Self {
> +            disks: vec![disk.clone()],
> +            fstype: FsType::Ext4,
> +            advanced: AdvancedBootdiskOptions::Lvm(LvmBootdiskOptions::defaults_from(disk)),
> +        }
> +    }
> +}
> +
> +#[derive(Clone, Debug)]
> +pub struct TimezoneOptions {
> +    pub country: String,
> +    pub timezone: String,
> +    pub kb_layout: String,
> +}
> +
> +impl TimezoneOptions {
> +    pub fn defaults_from(runtime: &RuntimeInfo, locales: &LocaleInfo) -> Self {
> +        let country = runtime.country.clone().unwrap_or_else(|| "at".to_owned());
> +
> +        let timezone = locales
> +            .cczones
> +            .get(&country)
> +            .and_then(|zones| zones.get(0))
> +            .cloned()
> +            .unwrap_or_else(|| "UTC".to_owned());
> +
> +        let kb_layout = locales
> +            .countries
> +            .get(&country)
> +            .and_then(|c| {
> +                if c.kmap.is_empty() {
> +                    None
> +                } else {
> +                    Some(c.kmap.clone())
> +                }
> +            })
> +            .unwrap_or_else(|| "en-us".to_owned());
> +
> +        Self {
> +            country,
> +            timezone,
> +            kb_layout,
> +        }
> +    }
> +}
> +
> +#[derive(Clone, Debug)]
> +pub struct PasswordOptions {
> +    pub email: String,
> +    pub root_password: String,
> +}
> +
> +impl Default for PasswordOptions {
> +    fn default() -> Self {
> +        Self {
> +            email: "mail at example.invalid".to_string(),
> +            root_password: String::new(),
> +        }
> +    }
> +}
> +
> +#[derive(Clone, Debug, PartialEq)]
> +pub struct NetworkOptions {
> +    pub ifname: String,
> +    pub fqdn: Fqdn,
> +    pub address: CidrAddress,
> +    pub gateway: IpAddr,
> +    pub dns_server: IpAddr,
> +}
> +
> +impl NetworkOptions {
> +    const DEFAULT_DOMAIN: &str = "example.invalid";
> +
> +    pub fn defaults_from(setup: &SetupInfo, network: &NetworkInfo) -> Self {
> +        let mut this = Self {
> +            ifname: String::new(),
> +            fqdn: Self::construct_fqdn(network, setup.config.product.default_hostname()),
> +            // Safety: The provided mask will always be valid.
> +            address: CidrAddress::new(Ipv4Addr::UNSPECIFIED, 0).unwrap(),
> +            gateway: Ipv4Addr::UNSPECIFIED.into(),
> +            dns_server: Ipv4Addr::UNSPECIFIED.into(),
> +        };
> +
> +        if let Some(ip) = network.dns.dns.first() {
> +            this.dns_server = *ip;
> +        }
> +
> +        if let Some(routes) = &network.routes {
> +            let mut filled = false;
> +            if let Some(gw) = &routes.gateway4 {
> +                if let Some(iface) = network.interfaces.get(&gw.dev) {
> +                    this.ifname = iface.name.clone();
> +                    if let Some(addresses) = &iface.addresses {
> +                        if let Some(addr) = addresses.iter().find(|addr| addr.is_ipv4()) {
> +                            this.gateway = gw.gateway;
> +                            this.address = addr.clone();
> +                            filled = true;
> +                        }
> +                    }
> +                }
> +            }
> +            if !filled {
> +                if let Some(gw) = &routes.gateway6 {
> +                    if let Some(iface) = network.interfaces.get(&gw.dev) {
> +                        if let Some(addresses) = &iface.addresses {
> +                            if let Some(addr) = addresses.iter().find(|addr| addr.is_ipv6()) {
> +                                this.ifname = iface.name.clone();
> +                                this.gateway = gw.gateway;
> +                                this.address = addr.clone();
> +                            }
> +                        }
> +                    }
> +                }
> +            }
> +        }
> +
> +        this
> +    }
> +
> +    fn construct_fqdn(network: &NetworkInfo, default_hostname: &str) -> Fqdn {
> +        let hostname = network.hostname.as_deref().unwrap_or(default_hostname);
> +
> +        let domain = network
> +            .dns
> +            .domain
> +            .as_deref()
> +            .unwrap_or(Self::DEFAULT_DOMAIN);
> +
> +        Fqdn::from(&format!("{hostname}.{domain}")).unwrap_or_else(|_| {
> +            // Safety: This will always result in a valid FQDN, as we control & know
> +            // the values of default_hostname (one of "pve", "pmg" or "pbs") and
> +            // constant-defined DEFAULT_DOMAIN.
> +            Fqdn::from(&format!("{}.{}", default_hostname, Self::DEFAULT_DOMAIN)).unwrap()
> +        })
> +    }
> +}
> diff --git a/proxmox-installer-common/src/setup.rs b/proxmox-installer-common/src/setup.rs
> new file mode 100644
> index 0000000..a4947f1
> --- /dev/null
> +++ b/proxmox-installer-common/src/setup.rs
> @@ -0,0 +1,330 @@
> +use std::{
> +    cmp,
> +    collections::HashMap,
> +    fmt,
> +    fs::File,
> +    io::BufReader,
> +    net::IpAddr,
> +    path::{Path, PathBuf},
> +};
> +
> +use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
> +
> +use crate::{
> +    options::{Disk, ZfsBootdiskOptions, ZfsChecksumOption, ZfsCompressOption},
> +    utils::CidrAddress,
> +};
> +
> +#[allow(clippy::upper_case_acronyms)]
> +#[derive(Clone, Copy, Deserialize, PartialEq)]
> +#[serde(rename_all = "lowercase")]
> +pub enum ProxmoxProduct {
> +    PVE,
> +    PBS,
> +    PMG,
> +}
> +
> +impl ProxmoxProduct {
> +    pub fn default_hostname(self) -> &'static str {
> +        match self {
> +            Self::PVE => "pve",
> +            Self::PMG => "pmg",
> +            Self::PBS => "pbs",
> +        }
> +    }
> +}
> +
> +#[derive(Clone, Deserialize)]
> +pub struct ProductConfig {
> +    pub fullname: String,
> +    pub product: ProxmoxProduct,
> +    #[serde(deserialize_with = "deserialize_bool_from_int")]
> +    pub enable_btrfs: bool,
> +}
> +
> +#[derive(Clone, Deserialize)]
> +pub struct IsoInfo {
> +    pub release: String,
> +    pub isorelease: String,
> +}
> +
> +/// Paths in the ISO environment containing installer data.
> +#[derive(Clone, Deserialize)]
> +pub struct IsoLocations {
> +    pub iso: PathBuf,
> +}
> +
> +#[derive(Clone, Deserialize)]
> +pub struct SetupInfo {
> +    #[serde(rename = "product-cfg")]
> +    pub config: ProductConfig,
> +    #[serde(rename = "iso-info")]
> +    pub iso_info: IsoInfo,
> +    pub locations: IsoLocations,
> +}
> +
> +#[derive(Clone, Deserialize)]
> +pub struct CountryInfo {
> +    pub name: String,
> +    #[serde(default)]
> +    pub zone: String,
> +    pub kmap: String,
> +}
> +
> +#[derive(Clone, Deserialize, Eq, PartialEq)]
> +pub struct KeyboardMapping {
> +    pub name: String,
> +    #[serde(rename = "kvm")]
> +    pub id: String,
> +    #[serde(rename = "x11")]
> +    pub xkb_layout: String,
> +    #[serde(rename = "x11var")]
> +    pub xkb_variant: String,
> +}
> +
> +impl cmp::PartialOrd for KeyboardMapping {
> +    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
> +        self.name.partial_cmp(&other.name)
> +    }
> +}
> +
> +impl cmp::Ord for KeyboardMapping {
> +    fn cmp(&self, other: &Self) -> cmp::Ordering {
> +        self.name.cmp(&other.name)
> +    }
> +}
> +
> +#[derive(Clone, Deserialize)]
> +pub struct LocaleInfo {
> +    #[serde(deserialize_with = "deserialize_cczones_map")]
> +    pub cczones: HashMap<String, Vec<String>>,
> +    #[serde(rename = "country")]
> +    pub countries: HashMap<String, CountryInfo>,
> +    pub kmap: HashMap<String, KeyboardMapping>,
> +}
> +
> +#[derive(Serialize)]
> +struct InstallZfsOption {
> +    ashift: usize,
> +    #[serde(serialize_with = "serialize_as_display")]
> +    compress: ZfsCompressOption,
> +    #[serde(serialize_with = "serialize_as_display")]
> +    checksum: ZfsChecksumOption,
> +    copies: usize,
> +}
> +
> +impl From<ZfsBootdiskOptions> for InstallZfsOption {
> +    fn from(opts: ZfsBootdiskOptions) -> Self {
> +        InstallZfsOption {
> +            ashift: opts.ashift,
> +            compress: opts.compress,
> +            checksum: opts.checksum,
> +            copies: opts.copies,
> +        }
> +    }
> +}
> +
> +pub fn read_json<T: for<'de> Deserialize<'de>, P: AsRef<Path>>(path: P) -> Result<T, String> {
> +    let file = File::open(path).map_err(|err| err.to_string())?;
> +    let reader = BufReader::new(file);
> +
> +    serde_json::from_reader(reader).map_err(|err| format!("failed to parse JSON: {err}"))
> +}
> +
> +fn deserialize_bool_from_int<'de, D>(deserializer: D) -> Result<bool, D::Error>
> +where
> +    D: Deserializer<'de>,
> +{
> +    let val: u32 = Deserialize::deserialize(deserializer)?;
> +    Ok(val != 0)
> +}
> +
> +fn deserialize_cczones_map<'de, D>(
> +    deserializer: D,
> +) -> Result<HashMap<String, Vec<String>>, D::Error>
> +where
> +    D: Deserializer<'de>,
> +{
> +    let map: HashMap<String, HashMap<String, u32>> = Deserialize::deserialize(deserializer)?;
> +
> +    let mut result = HashMap::new();
> +    for (cc, list) in map.into_iter() {
> +        result.insert(cc, list.into_keys().collect());
> +    }
> +
> +    Ok(result)
> +}
> +
> +fn deserialize_disks_map<'de, D>(deserializer: D) -> Result<Vec<Disk>, D::Error>
> +where
> +    D: Deserializer<'de>,
> +{
> +    let disks =
> +        <Vec<(usize, String, f64, String, Option<usize>, String)>>::deserialize(deserializer)?;
> +    Ok(disks
> +        .into_iter()
> +        .map(
> +            |(index, device, size_mb, model, logical_bsize, _syspath)| Disk {
> +                index: index.to_string(),
> +                // Linux always reports the size of block devices in sectors, where one sector is
> +                // defined as being 2^9 = 512 bytes in size.
> +                // https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/blk_types.h?h=v6.4#n30
> +                size: (size_mb * 512.) / 1024. / 1024. / 1024.,
> +                block_size: logical_bsize,
> +                path: device,
> +                model: (!model.is_empty()).then_some(model),
> +            },
> +        )
> +        .collect())
> +}
> +
> +fn deserialize_cidr_list<'de, D>(deserializer: D) -> Result<Option<Vec<CidrAddress>>, D::Error>
> +where
> +    D: Deserializer<'de>,
> +{
> +    #[derive(Deserialize)]
> +    struct CidrDescriptor {
> +        address: String,
> +        prefix: usize,
> +        // family is implied anyway by parsing the address
> +    }
> +
> +    let list: Vec<CidrDescriptor> = Deserialize::deserialize(deserializer)?;
> +
> +    let mut result = Vec::with_capacity(list.len());
> +    for desc in list {
> +        let ip_addr = desc
> +            .address
> +            .parse::<IpAddr>()
> +            .map_err(|err| de::Error::custom(format!("{:?}", err)))?;
> +
> +        result.push(
> +            CidrAddress::new(ip_addr, desc.prefix)
> +                .map_err(|err| de::Error::custom(format!("{:?}", err)))?,
> +        );
> +    }
> +
> +    Ok(Some(result))
> +}
> +
> +fn serialize_as_display<S, T>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
> +where
> +    S: Serializer,
> +    T: fmt::Display,
> +{
> +    serializer.collect_str(value)
> +}
> +
> +#[derive(Clone, Deserialize)]
> +pub struct RuntimeInfo {
> +    /// Whether is system was booted in (legacy) BIOS or UEFI mode.
> +    pub boot_type: BootType,
> +
> +    /// Detected country if available.
> +    pub country: Option<String>,
> +
> +    /// Maps devices to their information.
> +    #[serde(deserialize_with = "deserialize_disks_map")]
> +    pub disks: Vec<Disk>,
> +
> +    /// Network addresses, gateways and DNS info.
> +    pub network: NetworkInfo,
> +
> +    /// Total memory of the system in MiB.
> +    pub total_memory: usize,
> +
> +    /// Whether the CPU supports hardware-accelerated virtualization
> +    #[serde(deserialize_with = "deserialize_bool_from_int")]
> +    pub hvm_supported: bool,
> +}
> +
> +#[derive(Copy, Clone, Eq, Deserialize, PartialEq)]
> +#[serde(rename_all = "lowercase")]
> +pub enum BootType {
> +    Bios,
> +    Efi,
> +}
> +
> +#[derive(Clone, Deserialize)]
> +pub struct NetworkInfo {
> +    pub dns: Dns,
> +    pub routes: Option<Routes>,
> +
> +    /// Maps devices to their configuration, if it has a usable configuration.
> +    /// (Contains no entries for devices with only link-local addresses.)
> +    #[serde(default)]
> +    pub interfaces: HashMap<String, Interface>,
> +
> +    /// The hostname of this machine, if set by the DHCP server.
> +    pub hostname: Option<String>,
> +}
> +
> +#[derive(Clone, Deserialize)]
> +pub struct Dns {
> +    pub domain: Option<String>,
> +
> +    /// List of stringified IP addresses.
> +    #[serde(default)]
> +    pub dns: Vec<IpAddr>,
> +}
> +
> +#[derive(Clone, Deserialize)]
> +pub struct Routes {
> +    /// Ipv4 gateway.
> +    pub gateway4: Option<Gateway>,
> +
> +    /// Ipv6 gateway.
> +    pub gateway6: Option<Gateway>,
> +}
> +
> +#[derive(Clone, Deserialize)]
> +pub struct Gateway {
> +    /// Outgoing network device.
> +    pub dev: String,
> +
> +    /// Stringified gateway IP address.
> +    pub gateway: IpAddr,
> +}
> +
> +#[derive(Clone, Deserialize)]
> +#[serde(rename_all = "UPPERCASE")]
> +pub enum InterfaceState {
> +    Up,
> +    Down,
> +    #[serde(other)]
> +    Unknown,
> +}
> +
> +impl InterfaceState {
> +    // avoid display trait as this is not the string representation for a serializer
> +    pub fn render(&self) -> String {
> +        match self {
> +            Self::Up => "\u{25CF}",
> +            Self::Down | Self::Unknown => " ",
> +        }
> +        .into()
> +    }
> +}
> +
> +#[derive(Clone, Deserialize)]
> +pub struct Interface {
> +    pub name: String,
> +
> +    pub index: usize,
> +
> +    pub mac: String,
> +
> +    pub state: InterfaceState,
> +
> +    #[serde(default)]
> +    #[serde(deserialize_with = "deserialize_cidr_list")]
> +    pub addresses: Option<Vec<CidrAddress>>,
> +}
> +
> +impl Interface {
> +    // avoid display trait as this is not the string representation for a serializer
> +    pub fn render(&self) -> String {
> +        format!("{} {}", self.state.render(), self.name)
> +    }
> +}
> +
> diff --git a/proxmox-installer-common/src/utils.rs b/proxmox-installer-common/src/utils.rs
> new file mode 100644
> index 0000000..89349ed
> --- /dev/null
> +++ b/proxmox-installer-common/src/utils.rs
> @@ -0,0 +1,268 @@
> +use std::{
> +    fmt,
> +    net::{AddrParseError, IpAddr},
> +    num::ParseIntError,
> +    str::FromStr,
> +};
> +
> +use serde::Deserialize;
> +
> +/// Possible errors that might occur when parsing CIDR addresses.
> +#[derive(Debug)]
> +pub enum CidrAddressParseError {
> +    /// No delimiter for separating address and mask was found.
> +    NoDelimiter,
> +    /// The IP address part could not be parsed.
> +    InvalidAddr(AddrParseError),
> +    /// The mask could not be parsed.
> +    InvalidMask(Option<ParseIntError>),
> +}
> +
> +/// An IP address (IPv4 or IPv6), including network mask.
> +///
> +/// See the [`IpAddr`] type for more information how IP addresses are handled.
> +/// The mask is appropriately enforced to be `0 <= mask <= 32` for IPv4 or
> +/// `0 <= mask <= 128` for IPv6 addresses.
> +///
> +/// # Examples
> +/// ```
> +/// use std::net::{Ipv4Addr, Ipv6Addr};
> +/// let ipv4 = CidrAddress::new(Ipv4Addr::new(192, 168, 0, 1), 24).unwrap();
> +/// let ipv6 = CidrAddress::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0xc0a8, 1), 32).unwrap();
> +///
> +/// assert_eq!(ipv4.to_string(), "192.168.0.1/24");
> +/// assert_eq!(ipv6.to_string(), "2001:db8::c0a8:1/32");
> +/// ```
> +#[derive(Clone, Debug, PartialEq)]
> +pub struct CidrAddress {
> +    addr: IpAddr,
> +    mask: usize,
> +}
> +
> +impl CidrAddress {
> +    /// Constructs a new CIDR address.
> +    ///
> +    /// It fails if the mask is invalid for the given IP address.
> +    pub fn new<T: Into<IpAddr>>(addr: T, mask: usize) -> Result<Self, CidrAddressParseError> {
> +        let addr = addr.into();
> +
> +        if mask > mask_limit(&addr) {
> +            Err(CidrAddressParseError::InvalidMask(None))
> +        } else {
> +            Ok(Self { addr, mask })
> +        }
> +    }
> +
> +    /// Returns only the IP address part of the address.
> +    pub fn addr(&self) -> IpAddr {
> +        self.addr
> +    }
> +
> +    /// Returns `true` if this address is an IPv4 address, `false` otherwise.
> +    pub fn is_ipv4(&self) -> bool {
> +        self.addr.is_ipv4()
> +    }
> +
> +    /// Returns `true` if this address is an IPv6 address, `false` otherwise.
> +    pub fn is_ipv6(&self) -> bool {
> +        self.addr.is_ipv6()
> +    }
> +
> +    /// Returns only the mask part of the address.
> +    pub fn mask(&self) -> usize {
> +        self.mask
> +    }
> +}
> +
> +impl FromStr for CidrAddress {
> +    type Err = CidrAddressParseError;
> +
> +    fn from_str(s: &str) -> Result<Self, Self::Err> {
> +        let (addr, mask) = s
> +            .split_once('/')
> +            .ok_or(CidrAddressParseError::NoDelimiter)?;
> +
> +        let addr = addr.parse().map_err(CidrAddressParseError::InvalidAddr)?;
> +
> +        let mask = mask
> +            .parse()
> +            .map_err(|err| CidrAddressParseError::InvalidMask(Some(err)))?;
> +
> +        if mask > mask_limit(&addr) {
> +            Err(CidrAddressParseError::InvalidMask(None))
> +        } else {
> +            Ok(Self { addr, mask })
> +        }
> +    }
> +}
> +
> +impl fmt::Display for CidrAddress {
> +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
> +        write!(f, "{}/{}", self.addr, self.mask)
> +    }
> +}
> +
> +fn mask_limit(addr: &IpAddr) -> usize {
> +    if addr.is_ipv4() {
> +        32
> +    } else {
> +        128
> +    }
> +}
> +
> +/// Possible errors that might occur when parsing FQDNs.
> +#[derive(Debug, Eq, PartialEq)]
> +pub enum FqdnParseError {
> +    MissingHostname,
> +    NumericHostname,
> +    InvalidPart(String),
> +}
> +
> +impl fmt::Display for FqdnParseError {
> +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
> +        use FqdnParseError::*;
> +        match self {
> +            MissingHostname => write!(f, "missing hostname part"),
> +            NumericHostname => write!(f, "hostname cannot be purely numeric"),
> +            InvalidPart(part) => write!(
> +                f,
> +                "FQDN must only consist of alphanumeric characters and dashes. Invalid part: '{part}'",
> +            ),
> +        }
> +    }
> +}
> +
> +#[derive(Clone, Debug, Eq, PartialEq)]
> +pub struct Fqdn {
> +    parts: Vec<String>,
> +}
> +
> +impl Fqdn {
> +    pub fn from(fqdn: &str) -> Result<Self, FqdnParseError> {
> +        let parts = fqdn
> +            .split('.')
> +            .map(ToOwned::to_owned)
> +            .collect::<Vec<String>>();
> +
> +        for part in &parts {
> +            if !Self::validate_single(part) {
> +                return Err(FqdnParseError::InvalidPart(part.clone()));
> +            }
> +        }
> +
> +        if parts.len() < 2 {
> +            Err(FqdnParseError::MissingHostname)
> +        } else if parts[0].chars().all(|c| c.is_ascii_digit()) {
> +            // Not allowed/supported on Debian systems.
> +            Err(FqdnParseError::NumericHostname)
> +        } else {
> +            Ok(Self { parts })
> +        }
> +    }
> +
> +    pub fn host(&self) -> Option<&str> {
> +        self.has_host().then_some(&self.parts[0])
> +    }
> +
> +    pub fn domain(&self) -> String {
> +        let parts = if self.has_host() {
> +            &self.parts[1..]
> +        } else {
> +            &self.parts
> +        };
> +
> +        parts.join(".")
> +    }
> +
> +    /// Checks whether the FQDN has a hostname associated with it, i.e. is has more than 1 part.
> +    fn has_host(&self) -> bool {
> +        self.parts.len() > 1
> +    }
> +
> +    fn validate_single(s: &String) -> bool {
> +        !s.is_empty()
> +            // First character must be alphanumeric
> +            && s.chars()
> +                .next()
> +                .map(|c| c.is_ascii_alphanumeric())
> +                .unwrap_or_default()
> +            // .. last character as well,
> +            && s.chars()
> +                .last()
> +                .map(|c| c.is_ascii_alphanumeric())
> +                .unwrap_or_default()
> +            // and anything between must be alphanumeric or -
> +            && s.chars()
> +                .skip(1)
> +                .take(s.len().saturating_sub(2))
> +                .all(|c| c.is_ascii_alphanumeric() || c == '-')
> +    }
> +}
> +
> +impl FromStr for Fqdn {
> +    type Err = FqdnParseError;
> +
> +    fn from_str(value: &str) -> Result<Self, Self::Err> {
> +        Self::from(value)
> +    }
> +}
> +
> +impl fmt::Display for Fqdn {
> +    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
> +        write!(f, "{}", self.parts.join("."))
> +    }
> +}
> +
> +impl<'de> Deserialize<'de> for Fqdn {
> +    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
> +    where
> +        D: serde::Deserializer<'de>,
> +    {
> +        let s: String = Deserialize::deserialize(deserializer)?;
> +        s.parse()
> +            .map_err(|_| serde::de::Error::custom("invalid FQDN"))
> +    }
> +}
> +
> +#[cfg(test)]
> +mod tests {
> +    use super::*;
> +
> +    #[test]
> +    fn fqdn_construct() {
> +        use FqdnParseError::*;
> +        assert!(Fqdn::from("foo.example.com").is_ok());
> +        assert!(Fqdn::from("foo-bar.com").is_ok());
> +        assert!(Fqdn::from("a-b.com").is_ok());
> +
> +        assert_eq!(Fqdn::from("foo"), Err(MissingHostname));
> +
> +        assert_eq!(Fqdn::from("-foo.com"), Err(InvalidPart("-foo".to_owned())));
> +        assert_eq!(Fqdn::from("foo-.com"), Err(InvalidPart("foo-".to_owned())));
> +        assert_eq!(Fqdn::from("foo.com-"), Err(InvalidPart("com-".to_owned())));
> +        assert_eq!(Fqdn::from("-o-.com"), Err(InvalidPart("-o-".to_owned())));
> +
> +        assert_eq!(Fqdn::from("123.com"), Err(NumericHostname));
> +        assert!(Fqdn::from("foo123.com").is_ok());
> +        assert!(Fqdn::from("123foo.com").is_ok());
> +    }
> +
> +    #[test]
> +    fn fqdn_parts() {
> +        let fqdn = Fqdn::from("pve.example.com").unwrap();
> +        assert_eq!(fqdn.host().unwrap(), "pve");
> +        assert_eq!(fqdn.domain(), "example.com");
> +        assert_eq!(
> +            fqdn.parts,
> +            &["pve".to_owned(), "example".to_owned(), "com".to_owned()]
> +        );
> +    }
> +
> +    #[test]
> +    fn fqdn_display() {
> +        assert_eq!(
> +            Fqdn::from("foo.example.com").unwrap().to_string(),
> +            "foo.example.com"
> +        );
> +    }
> +}
> --
> 2.39.2
>
>
>
> _______________________________________________
> pve-devel mailing list
> pve-devel at lists.proxmox.com
> https://lists.proxmox.com/cgi-bin/mailman/listinfo/pve-devel
>
>





More information about the pve-devel mailing list