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

@@ -1,5 +1,4 @@
 use async_trait::async_trait;
-use dyn_clone::DynClone;
 use serde::Serialize;
 
 use std::fmt::Debug;
@@ -14,18 +13,19 @@ use crate::{interpret::Outcome, topology::Topology};
 /// 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) -> Result<Outcome, InterpretError>;
+    async fn deploy_monitor(
+        &self,
+        topology: &T,
+        alert_receivers: Vec<AlertReceiver>,
+    ) -> Result<Outcome, InterpretError>;
 
-    async fn delete_monitor(&self, topolgy: &T) -> Result<Outcome, InterpretError>;
+    async fn delete_monitor(
+        &self,
+        topolgy: &T,
+        alert_receivers: Vec<AlertReceiver>,
+    ) -> Result<Outcome, InterpretError>;
 }
 
-#[async_trait]
-pub trait AlertReceiverDeployment<T: Topology>: Debug + DynClone + Send + Sync {
-    async fn deploy_alert_receiver(&self, topology: &T) -> Result<Outcome, InterpretError>;
-}
-
-dyn_clone::clone_trait_object!(<T> AlertReceiverDeployment<T>);
-
 #[derive(Debug, Clone, Serialize)]
 pub struct AlertReceiver {
     pub receiver_id: String,

harmony/src/modules/monitoring/alertmanager_types.rs

@@ -1,102 +0,0 @@
-use serde::{Deserialize, Serialize};
-use url::Url;
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AlertManagerValues {
-    pub alertmanager: AlertManager,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AlertManager {
-    pub enabled: bool,
-    pub config: AlertManagerConfig,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct AlertChannelConfig {
-    pub receiver: AlertChannelReceiver,
-    pub route: AlertChannelRoute,
-    pub global_config: Option<AlertChannelGlobalConfig>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AlertChannelReceiver {
-    pub name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub slack_configs: Option<Vec<SlackConfig>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub webhook_configs: Option<Vec<WebhookConfig>>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AlertManagerRoute {
-    pub group_by: Vec<String>,
-    pub group_wait: String,
-    pub group_interval: String,
-    pub repeat_interval: String,
-    pub routes: Vec<AlertChannelRoute>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AlertChannelGlobalConfig {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub slack_api_url: Option<Url>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SlackConfig {
-    pub channel: String,
-    pub send_resolved: bool,
-    pub title: String,
-    pub text: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct WebhookConfig {
-    pub url: Url,
-    pub send_resolved: bool,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AlertChannelRoute {
-    pub receiver: String,
-    pub matchers: Vec<String>,
-    #[serde(default)]
-    pub r#continue: bool,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AlertManagerConfig {
-    pub global: Option<AlertChannelGlobalConfig>,
-    pub route: AlertManagerRoute,
-    pub receivers: Vec<AlertChannelReceiver>,
-}
-
-impl AlertManagerValues {
-    pub fn default() -> Self {
-        Self {
-            alertmanager: AlertManager {
-                enabled: true,
-                config: AlertManagerConfig {
-                    global: None,
-                    route: AlertManagerRoute {
-                        group_by: vec!["job".to_string()],
-                        group_wait: "30s".to_string(),
-                        group_interval: "5m".to_string(),
-                        repeat_interval: "12h".to_string(),
-                        routes: vec![AlertChannelRoute {
-                            receiver: "null".to_string(),
-                            matchers: vec!["alertname=Watchdog".to_string()],
-                            r#continue: false,
-                        }],
-                    },
-                    receivers: vec![AlertChannelReceiver {
-                        name: "null".to_string(),
-                        slack_configs: None,
-                        webhook_configs: None,
-                    }],
-                },
-            },
-        }
-    }
-}

harmony/src/modules/monitoring/discord_webhook_sender.rs

@@ -1,6 +1,6 @@
-use super::{
+use std::sync::Arc;
-    discord_alert_manager::discord_alert_manager_score, kube_prometheus_monitor::AlertManagerConfig,
+
-};
+use super::discord_alert_manager::discord_alert_manager_score;
 use async_trait::async_trait;
 use serde::Serialize;
 use serde_yaml::Value;
@@ -13,18 +13,10 @@ use crate::{
     inventory::Inventory,
     score::Score,
     topology::{
-        HelmCommand, K8sAnywhereTopology, Topology,
+        HelmCommand, K8sAnywhereTopology, Topology, oberservability::monitoring::AlertReceiver,
-        oberservability::monitoring::{AlertReceiver, AlertReceiverDeployment},
     },
 };
 
-#[async_trait]
-impl<T: Topology + DiscordWebhookReceiver> AlertReceiverDeployment<T> for DiscordWebhookConfig {
-    async fn deploy_alert_receiver(&self, topology: &T) -> Result<Outcome, InterpretError> {
-        topology.deploy_discord_webhook_receiver(self.clone()).await
-    }
-}
-
 #[derive(Debug, Clone, Serialize)]
 pub struct DiscordWebhookConfig {
     pub webhook_url: Url,
@@ -44,9 +36,13 @@ pub trait DiscordWebhookReceiver {
     ) -> Result<Outcome, InterpretError>;
 }
 
+pub trait AlertManagerConfig<T> {
+    fn get_alert_manager_config(&self) -> Result<Value, InterpretError>;
+}
+
 #[async_trait]
 impl<T: DiscordWebhookReceiver> AlertManagerConfig<T> for DiscordWebhookConfig {
-    async fn get_alert_manager_config(&self) -> Result<Value, InterpretError> {
+    fn get_alert_manager_config(&self) -> Result<Value, InterpretError> {
         todo!()
     }
 }

harmony/src/modules/monitoring/kube_prometheus_monitor.rs

@@ -1,108 +0,0 @@
-use async_trait::async_trait;
-use serde::Serialize;
-use serde_yaml::Value;
-
-use crate::{
-    data::{Id, Version},
-    interpret::{Interpret, InterpretError, InterpretName, InterpretStatus, Outcome},
-    inventory::Inventory,
-    score::Score,
-    topology::{
-        HelmCommand, Topology,
-        oberservability::monitoring::{AlertReceiverDeployment, Monitor},
-    },
-};
-
-use super::{
-    config::KubePrometheusConfig, kube_prometheus_helm_chart::kube_prometheus_helm_chart_score,
-};
-
-#[derive(Debug, Clone)]
-pub struct KubePrometheus<T> {
-    alert_receivers: Vec<Box<dyn AlertReceiverDeployment<T>>>,
-    config: KubePrometheusConfig,
-}
-
-#[async_trait]
-pub trait AlertManagerConfig<T> {
-    async fn get_alert_manager_config(&self) -> Result<Value, InterpretError>;
-}
-
-impl<T: Topology> KubePrometheus<T> {
-    pub fn new() -> Self {
-        Self {
-            alert_receivers: Vec::new(),
-            config: KubePrometheusConfig::new(),
-        }
-    }
-}
-
-#[async_trait]
-impl<T: Topology + HelmCommand + std::fmt::Debug> Monitor<T> for KubePrometheus<T> {
-    async fn deploy_monitor(&self, topology: &T) -> Result<Outcome, InterpretError> {
-        for alert_receiver in &self.alert_receivers {
-            alert_receiver.deploy_alert_receiver(topology).await?;
-        }
-        let score = KubePrometheusScore {
-            config: self.config.clone(),
-        };
-        let inventory = Inventory::autoload();
-        score.create_interpret().execute(&inventory, topology).await
-    }
-
-    async fn delete_monitor(&self, _topolgy: &T) -> Result<Outcome, InterpretError> {
-        todo!()
-    }
-}
-
-#[derive(Debug, Clone, Serialize)]
-struct KubePrometheusScore {
-    config: KubePrometheusConfig,
-}
-
-impl<T: Topology + HelmCommand> Score<T> for KubePrometheusScore {
-    fn create_interpret(&self) -> Box<dyn Interpret<T>> {
-        Box::new(KubePromethusScoreInterpret {
-            score: self.clone(),
-        })
-    }
-
-    fn name(&self) -> String {
-        todo!()
-    }
-}
-
-#[derive(Debug, Clone, Serialize)]
-struct KubePromethusScoreInterpret {
-    score: KubePrometheusScore,
-}
-
-#[async_trait]
-impl<T: Topology + HelmCommand> Interpret<T> for KubePromethusScoreInterpret {
-    async fn execute(
-        &self,
-        inventory: &Inventory,
-        topology: &T,
-    ) -> Result<Outcome, InterpretError> {
-        kube_prometheus_helm_chart_score(&self.score.config)
-            .create_interpret()
-            .execute(inventory, topology)
-            .await
-    }
-
-    fn get_name(&self) -> InterpretName {
-        todo!()
-    }
-
-    fn get_version(&self) -> Version {
-        todo!()
-    }
-
-    fn get_status(&self) -> InterpretStatus {
-        todo!()
-    }
-
-    fn get_children(&self) -> Vec<Id> {
-        todo!()
-    }
-}

harmony/src/modules/monitoring/mod.rs

@@ -1,7 +1,5 @@
-pub mod alertmanager_types;
 mod config;
 mod discord_alert_manager;
 pub mod discord_webhook_sender;
-mod kube_prometheus_helm_chart;
+mod kube_prometheus;
-pub mod kube_prometheus_monitor;
 pub mod monitoring_alerting;

harmony/src/modules/monitoring/monitoring_alerting.rs

@@ -14,7 +14,8 @@ use crate::{
 };
 
 use super::{
-    config::KubePrometheusConfig, kube_prometheus_helm_chart::kube_prometheus_helm_chart_score,
+    config::KubePrometheusConfig, discord_alert_manager::discord_alert_manager_score,
+    kube_prometheus::kube_prometheus_helm_chart_score,
 };
 
 #[derive(Debug, Clone, Serialize)]