harmony/harmony/src/domain/interpret/mod.rs

use std::error::Error;

use async_trait::async_trait;
use derive_new::new;

use super::{
    data::{Id, Version},
    executors::ExecutorError,
    inventory::Inventory,
    topology::PreparationError,
};

pub enum InterpretName {
    OPNSenseDHCP,
    OPNSenseDns,
    LoadBalancer,
    Tftp,
    Http,
    Ipxe,
    Dummy,
    Panic,
    OPNSense,
    K3dInstallation,
    TenantInterpret,
    Application,
    ArgoCD,
    Alerting,
    Ntfy,
    HelmChart,
    HelmCommand,
    K8sResource,
    Lamp,
    ApplicationMonitoring,
    K8sPrometheusCrdAlerting,
    CephClusterHealth,
}

impl std::fmt::Display for InterpretName {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            InterpretName::OPNSenseDHCP => f.write_str("OPNSenseDHCP"),
            InterpretName::OPNSenseDns => f.write_str("OPNSenseDns"),
            InterpretName::LoadBalancer => f.write_str("LoadBalancer"),
            InterpretName::Tftp => f.write_str("Tftp"),
            InterpretName::Http => f.write_str("Http"),
            InterpretName::Ipxe => f.write_str("iPXE"),
            InterpretName::Dummy => f.write_str("Dummy"),
            InterpretName::Panic => f.write_str("Panic"),
            InterpretName::OPNSense => f.write_str("OPNSense"),
            InterpretName::K3dInstallation => f.write_str("K3dInstallation"),
            InterpretName::TenantInterpret => f.write_str("Tenant"),
            InterpretName::Application => f.write_str("Application"),
            InterpretName::ArgoCD => f.write_str("ArgoCD"),
            InterpretName::Alerting => f.write_str("Alerting"),
            InterpretName::Ntfy => f.write_str("Ntfy"),
            InterpretName::HelmChart => f.write_str("HelmChart"),
            InterpretName::HelmCommand => f.write_str("HelmCommand"),
            InterpretName::K8sResource => f.write_str("K8sResource"),
            InterpretName::Lamp => f.write_str("LAMP"),
            InterpretName::ApplicationMonitoring => f.write_str("ApplicationMonitoring"),
            InterpretName::K8sPrometheusCrdAlerting => f.write_str("K8sPrometheusCrdAlerting"),
            InterpretName::CephClusterHealth => f.write_str("CephClusterHealth"),
        }
    }
}

#[async_trait]
pub trait Interpret<T>: std::fmt::Debug + Send {
    async fn execute(&self, inventory: &Inventory, topology: &T)
    -> Result<Outcome, InterpretError>;
    fn get_name(&self) -> InterpretName;
    fn get_version(&self) -> Version;
    fn get_status(&self) -> InterpretStatus;
    fn get_children(&self) -> Vec<Id>;
}

#[derive(Debug, new, Clone)]
pub struct Outcome {
    pub status: InterpretStatus,
    pub message: String,
}

impl Outcome {
    pub fn noop() -> Self {
        Self {
            status: InterpretStatus::NOOP,
            message: String::new(),
        }
    }

    pub fn success(message: String) -> Self {
        Self {
            status: InterpretStatus::SUCCESS,
            message,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum InterpretStatus {
    SUCCESS,
    FAILURE,
    RUNNING,
    QUEUED,
    BLOCKED,
    NOOP,
}

impl std::fmt::Display for InterpretStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let msg = match self {
            InterpretStatus::SUCCESS => "SUCCESS",
            InterpretStatus::FAILURE => "FAILURE",
            InterpretStatus::RUNNING => "RUNNING",
            InterpretStatus::QUEUED => "QUEUED",
            InterpretStatus::BLOCKED => "BLOCKED",
            InterpretStatus::NOOP => "NO_OP",
        };
        f.write_str(msg)
    }
}

#[derive(Debug, Clone, new)]
pub struct InterpretError {
    msg: String,
}

impl std::fmt::Display for InterpretError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&self.msg)
    }
}
impl Error for InterpretError {}

impl From<PreparationError> for InterpretError {
    fn from(value: PreparationError) -> Self {
        Self {
            msg: format!("InterpretError : {value}"),
        }
    }
}

impl From<ExecutorError> for InterpretError {
    fn from(value: ExecutorError) -> Self {
        Self {
            msg: format!("InterpretError : {value}"),
        }
    }
}

impl From<kube::Error> for InterpretError {
    fn from(value: kube::Error) -> Self {
        Self {
            msg: format!("InterpretError : {value}"),
        }
    }
}

impl From<String> for InterpretError {
    fn from(value: String) -> Self {
        Self {
            msg: format!("InterpretError : {value}"),
        }
    }
}