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/topology/k8s_anywhere.rs

@@ -1,4 +1,4 @@
-use std::{io::Error, process::Command, sync::Arc};
+use std::{process::Command, sync::Arc};
 
 use async_trait::async_trait;
 use inquire::Confirm;

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/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};
-
-fn get_discord_alert_manager_score(config: &KubePrometheusConfig) -> Option<HelmChartScore> {
-    let (url, name) = config.alert_channel.iter().find_map(|channel| {
-        if let AlertChannel::Discord { webhook_url, name } = channel {
-            Some((webhook_url, name))
-        } else {
-            None
-        }
-    })?;
-
+pub fn discord_alert_manager_score(
+    webhook_url: Url,
+    namespace: String,
+    name: String,
+) -> HelmChartScore {
     let values = format!(
         r#"
 environment:
   - name: "DISCORD_WEBHOOK"
-    value: "{url}"
+    value: "{webhook_url}"
 "#,
     );
 
-    Some(HelmChartScore {
-        namespace: Some(NonBlankString::from_str(&config.namespace).unwrap()),
+    HelmChartScore {
+        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 {
-            let outcome = match channel {
-                AlertChannel::Discord { .. } => {
-                    discord_alert_manager_score(config)
-                        .create_interpret()
-                        .execute(inventory, topology)
-                        .await
-                }
-                AlertChannel::Slack { .. } => Ok(Outcome::success(
-                    "No extra configs for slack alerting".to_string(),
-                )),
-                AlertChannel::Smpt { .. } => {
-                    todo!()
-                }
-            };
-            outcomes.push(outcome);
-        }
-        for result in outcomes {
-            result?;
-        }
+        //for channel in &self.score.alert_channel {
+        //    let outcome = match channel {
+        //        AlertChannel::Discord { .. } => {
+        //            discord_alert_manager_score(config)
+        //                .create_interpret()
+        //                .execute(inventory, topology)
+        //                .await
+        //        }
+        //        AlertChannel::Slack { .. } => Ok(Outcome::success(
+        //            "No extra configs for slack alerting".to_string(),
+        //        )),
+        //        AlertChannel::Smpt { .. } => {
+        //            todo!()
+        //        }
+        //    };
+        //    outcomes.push(outcome);
+        //}
+        //for result in outcomes {
+        //    result?;
+        //}
 
         Ok(Outcome::success("All alert channels deployed".to_string()))
     }