harmony/harmony/src/modules/okd/bootstrap_persist_network_bond.rs

use crate::{
    data::Version,
    hardware::PhysicalHost,
    infra::inventory::InventoryRepositoryFactory,
    interpret::{Interpret, InterpretError, InterpretName, InterpretStatus, Outcome},
    inventory::{HostRole, Inventory},
    modules::okd::host_network::HostNetworkConfigurationScore,
    score::Score,
    topology::HAClusterTopology,
};
use async_trait::async_trait;
use derive_new::new;
use harmony_types::id::Id;
use log::info;
use serde::Serialize;

// -------------------------------------------------------------------------------------------------
// Persist Network Bond
// - Persist bonding via NMState
// - Persist port channels on the Switch
// -------------------------------------------------------------------------------------------------

#[derive(Debug, Clone, Serialize, new)]
pub struct OKDSetupPersistNetworkBondScore {}

impl Score<HAClusterTopology> for OKDSetupPersistNetworkBondScore {
    fn create_interpret(&self) -> Box<dyn Interpret<HAClusterTopology>> {
        Box::new(OKDSetupPersistNetworkBondInterpet::new())
    }

    fn name(&self) -> String {
        "OKDSetupPersistNetworkBondScore".to_string()
    }
}

#[derive(Debug, Clone)]
pub struct OKDSetupPersistNetworkBondInterpet {
    version: Version,
    status: InterpretStatus,
}

impl OKDSetupPersistNetworkBondInterpet {
    pub fn new() -> Self {
        let version = Version::from("1.0.0").unwrap();
        Self {
            version,
            status: InterpretStatus::QUEUED,
        }
    }

    /// Ensures that three physical hosts are discovered and available for the ControlPlane role.
    /// It will trigger discovery if not enough hosts are found.
    async fn get_nodes(
        &self,
        _inventory: &Inventory,
        _topology: &HAClusterTopology,
    ) -> Result<Vec<PhysicalHost>, InterpretError> {
        const REQUIRED_HOSTS: usize = 3;
        let repo = InventoryRepositoryFactory::build().await?;
        let control_plane_hosts = repo.get_host_for_role(&HostRole::ControlPlane).await?;

        if control_plane_hosts.len() < REQUIRED_HOSTS {
            Err(InterpretError::new(format!(
                "OKD Requires at least {} control plane hosts, but only found {}. Cannot proceed.",
                REQUIRED_HOSTS,
                control_plane_hosts.len()
            )))
        } else {
            // Take exactly the number of required hosts to ensure consistency.
            Ok(control_plane_hosts
                .into_iter()
                .take(REQUIRED_HOSTS)
                .collect())
        }
    }

    async fn persist_network_bond(
        &self,
        inventory: &Inventory,
        topology: &HAClusterTopology,
        hosts: &Vec<PhysicalHost>,
    ) -> Result<(), InterpretError> {
        info!("Ensuring persistent bonding");

        let score = HostNetworkConfigurationScore {
            hosts: hosts.clone(),
        };
        score.interpret(inventory, topology).await?;

        Ok(())
    }
}

#[async_trait]
impl Interpret<HAClusterTopology> for OKDSetupPersistNetworkBondInterpet {
    fn get_name(&self) -> InterpretName {
        InterpretName::Custom("OKDSetupPersistNetworkBondInterpet")
    }

    fn get_version(&self) -> Version {
        self.version.clone()
    }

    fn get_status(&self) -> InterpretStatus {
        self.status.clone()
    }

    fn get_children(&self) -> Vec<Id> {
        vec![]
    }

    async fn execute(
        &self,
        inventory: &Inventory,
        topology: &HAClusterTopology,
    ) -> Result<Outcome, InterpretError> {
        let nodes = self.get_nodes(inventory, topology).await?;

        let res = self.persist_network_bond(inventory, topology, &nodes).await;

        match res {
            Ok(_) => Ok(Outcome::success(
                "Network bond successfully persisted".into(),
            )),
            Err(_) => Err(InterpretError::new(
                "Failed to persist network bond".to_string(),
            )),
        }
    }
}