Merge remote-tracking branch 'origin/master' into TenantManager_impl_k8s_anywhere

Cargo.lock

@@ -1409,6 +1409,7 @@ dependencies = [
  "derive-new",
  "directories",
  "dockerfile_builder",
+ "dyn-clone",
  "email_address",
  "env_logger",
  "fqdn",

harmony/Cargo.toml

@@ -49,3 +49,4 @@ fqdn = { version = "0.4.6", features = [
     "serde",
 ] }
 temp-dir = "0.1.14"
+dyn-clone = "1.0.19"

harmony/src/domain/data/id.rs

@@ -10,3 +10,9 @@ impl Id {
         Self { value }
     }
 }
+
+impl std::fmt::Display for Id {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.value)
+    }
+}

harmony/src/domain/interpret/mod.rs

@@ -20,6 +20,7 @@ pub enum InterpretName {
     Panic,
     OPNSense,
     K3dInstallation,
+    TenantInterpret,
 }
 
 impl std::fmt::Display for InterpretName {
@@ -35,6 +36,7 @@ impl std::fmt::Display for InterpretName {
             InterpretName::Panic => f.write_str("Panic"),
             InterpretName::OPNSense => f.write_str("OPNSense"),
             InterpretName::K3dInstallation => f.write_str("K3dInstallation"),
+            InterpretName::TenantInterpret => f.write_str("Tenant"),
         }
     }
 }

harmony/src/domain/topology/mod.rs

@@ -3,6 +3,7 @@ mod host_binding;
 mod http;
 mod k8s_anywhere;
 mod localhost;
+pub mod oberservability;
 pub mod tenant;
 pub use k8s_anywhere::*;
 pub use localhost::*;

harmony/src/domain/topology/oberservability/mod.rs

@@ -0,0 +1 @@
+pub mod monitoring;

harmony/src/domain/topology/oberservability/monitoring.rs

@@ -0,0 +1,31 @@
+use async_trait::async_trait;
+
+use std::fmt::Debug;
+use url::Url;
+
+use crate::interpret::InterpretError;
+
+use crate::{interpret::Outcome, topology::Topology};
+
+/// Represents an entity responsible for collecting and organizing observability data
+/// from various telemetry sources
+/// A `Monitor` abstracts the logic required to scrape, aggregate, and structure
+/// monitoring data, enabling consistent processing regardless of the underlying data source.
+#[async_trait]
+pub trait Monitor<T: Topology>: Debug + Send + Sync {
+    async fn deploy_monitor(
+        &self,
+        topology: &T,
+        alert_receivers: Vec<AlertReceiver>,
+    ) -> Result<Outcome, InterpretError>;
+
+    async fn delete_monitor(
+        &self,
+        topolgy: &T,
+        alert_receivers: Vec<AlertReceiver>,
+    ) -> Result<Outcome, InterpretError>;
+}
+
+pub struct AlertReceiver {
+    pub receiver_id: String,
+}

harmony/src/modules/mod.rs

@@ -12,4 +12,5 @@ pub mod load_balancer;
 pub mod monitoring;
 pub mod okd;
 pub mod opnsense;
+pub mod tenant;
 pub mod tftp;

harmony/src/modules/monitoring/discord_alert_manager.rs

@@ -1,30 +1,25 @@
 use std::str::FromStr;
 
 use non_blank_string_rs::NonBlankString;
+use url::Url;
 
 use crate::modules::helm::chart::HelmChartScore;
 
-use super::{config::KubePrometheusConfig, monitoring_alerting::AlertChannel};
+pub fn discord_alert_manager_score(
-
+    webhook_url: Url,
-fn get_discord_alert_manager_score(config: &KubePrometheusConfig) -> Option<HelmChartScore> {
+    namespace: String,
-    let (url, name) = config.alert_channel.iter().find_map(|channel| {
+    name: String,
-        if let AlertChannel::Discord { webhook_url, name } = channel {
+) -> HelmChartScore {
-            Some((webhook_url, name))
-        } else {
-            None
-        }
-    })?;
-
     let values = format!(
         r#"
 environment:
   - name: "DISCORD_WEBHOOK"
-    value: "{url}"
+    value: "{webhook_url}"
 "#,
     );
 
-    Some(HelmChartScore {
+    HelmChartScore {
-        namespace: Some(NonBlankString::from_str(&config.namespace).unwrap()),
+        namespace: Some(NonBlankString::from_str(&namespace).unwrap()),
         release_name: NonBlankString::from_str(&name).unwrap(),
         chart_name: NonBlankString::from_str(
             "oci://hub.nationtech.io/library/alertmanager-discord",
@@ -36,13 +31,5 @@ environment:
         create_namespace: true,
         install_only: true,
         repository: None,
-    })
-}
-
-pub fn discord_alert_manager_score(config: &KubePrometheusConfig) -> HelmChartScore {
-    if let Some(chart) = get_discord_alert_manager_score(config) {
-        chart
-    } else {
-        panic!("Expected discord alert manager helm chart");
     }
 }

harmony/src/modules/monitoring/discord_webhook_sender.rs

@@ -0,0 +1,55 @@
+use async_trait::async_trait;
+use serde_json::Value;
+use url::Url;
+
+use crate::{
+    interpret::{InterpretError, Outcome},
+    topology::K8sAnywhereTopology,
+};
+
+#[derive(Debug, Clone)]
+pub struct DiscordWebhookConfig {
+    pub webhook_url: Url,
+    pub name: String,
+    pub send_resolved_notifications: bool,
+}
+
+pub trait DiscordWebhookReceiver {
+    fn deploy_discord_webhook_receiver(
+        &self,
+        _notification_adapter_id: &str,
+    ) -> Result<Outcome, InterpretError>;
+
+    fn delete_discord_webhook_receiver(
+        &self,
+        _notification_adapter_id: &str,
+    ) -> Result<Outcome, InterpretError>;
+}
+
+// trait used to generate alert manager config values impl<T: Topology + AlertManagerConfig> Monitor for KubePrometheus
+pub trait AlertManagerConfig<T> {
+    fn get_alert_manager_config(&self) -> Result<Value, InterpretError>;
+}
+
+#[async_trait]
+impl<T: DiscordWebhookReceiver> AlertManagerConfig<T> for DiscordWebhookConfig {
+    fn get_alert_manager_config(&self) -> Result<Value, InterpretError> {
+        todo!()
+    }
+}
+
+#[async_trait]
+impl DiscordWebhookReceiver for K8sAnywhereTopology {
+    fn deploy_discord_webhook_receiver(
+        &self,
+        _notification_adapter_id: &str,
+    ) -> Result<Outcome, InterpretError> {
+        todo!()
+    }
+    fn delete_discord_webhook_receiver(
+        &self,
+        _notification_adapter_id: &str,
+    ) -> Result<Outcome, InterpretError> {
+        todo!()
+    }
+}

harmony/src/modules/monitoring/mod.rs

@@ -1,4 +1,5 @@
 mod config;
 mod discord_alert_manager;
+pub mod discord_webhook_sender;
 mod kube_prometheus;
 pub mod monitoring_alerting;

harmony/src/modules/monitoring/monitoring_alerting.rs

@@ -96,28 +96,28 @@ impl MonitoringAlertingStackInterpret {
         topology: &T,
         config: &KubePrometheusConfig,
     ) -> Result<Outcome, InterpretError> {
-        let mut outcomes = vec![];
+        //let mut outcomes = vec![];
 
-        for channel in &self.score.alert_channel {
+        //for channel in &self.score.alert_channel {
-            let outcome = match channel {
+        //    let outcome = match channel {
-                AlertChannel::Discord { .. } => {
+        //        AlertChannel::Discord { .. } => {
-                    discord_alert_manager_score(config)
+        //            discord_alert_manager_score(config)
-                        .create_interpret()
+        //                .create_interpret()
-                        .execute(inventory, topology)
+        //                .execute(inventory, topology)
-                        .await
+        //                .await
-                }
+        //        }
-                AlertChannel::Slack { .. } => Ok(Outcome::success(
+        //        AlertChannel::Slack { .. } => Ok(Outcome::success(
-                    "No extra configs for slack alerting".to_string(),
+        //            "No extra configs for slack alerting".to_string(),
-                )),
+        //        )),
-                AlertChannel::Smpt { .. } => {
+        //        AlertChannel::Smpt { .. } => {
-                    todo!()
+        //            todo!()
-                }
+        //        }
-            };
+        //    };
-            outcomes.push(outcome);
+        //    outcomes.push(outcome);
-        }
+        //}
-        for result in outcomes {
+        //for result in outcomes {
-            result?;
+        //    result?;
-        }
+        //}
 
         Ok(Outcome::success("All alert channels deployed".to_string()))
     }

harmony/src/modules/tenant/mod.rs

@@ -0,0 +1,67 @@
+use async_trait::async_trait;
+use serde::Serialize;
+
+use crate::{
+    data::{Id, Version},
+    interpret::{Interpret, InterpretError, InterpretName, InterpretStatus, Outcome},
+    inventory::Inventory,
+    score::Score,
+    topology::{
+        Topology,
+        tenant::{TenantConfig, TenantManager},
+    },
+};
+
+#[derive(Debug, Serialize, Clone)]
+pub struct TenantScore {
+    config: TenantConfig,
+}
+
+impl<T: Topology + TenantManager> Score<T> for TenantScore {
+    fn create_interpret(&self) -> Box<dyn crate::interpret::Interpret<T>> {
+        Box::new(TenantInterpret {
+            tenant_config: self.config.clone(),
+        })
+    }
+
+    fn name(&self) -> String {
+        format!("{} TenantScore", self.config.name)
+    }
+}
+
+#[derive(Debug)]
+pub struct TenantInterpret {
+    tenant_config: TenantConfig,
+}
+
+#[async_trait]
+impl<T: Topology + TenantManager> Interpret<T> for TenantInterpret {
+    async fn execute(
+        &self,
+        _inventory: &Inventory,
+        topology: &T,
+    ) -> Result<Outcome, InterpretError> {
+        topology.provision_tenant(&self.tenant_config).await?;
+
+        Ok(Outcome::success(format!(
+            "Successfully provisioned tenant {} with id {}",
+            self.tenant_config.name, self.tenant_config.id
+        )))
+    }
+
+    fn get_name(&self) -> InterpretName {
+        InterpretName::TenantInterpret
+    }
+
+    fn get_version(&self) -> Version {
+        todo!()
+    }
+
+    fn get_status(&self) -> InterpretStatus {
+        todo!()
+    }
+
+    fn get_children(&self) -> Vec<Id> {
+        todo!()
+    }
+}