fix: K8sTenantManager is responsible for concrete implementation. K8sAnywhere should delegate

harmony/src/domain/topology/installable.rs

@@ -4,7 +4,7 @@ use crate::{interpret::InterpretError, inventory::Inventory};
 
 #[async_trait]
 pub trait Installable<T>: Send + Sync {
-    fn configure(&self, inventory: &Inventory, topology: &T) -> Result<(), InterpretError>;
+    async fn configure(&self, inventory: &Inventory, topology: &T) -> Result<(), InterpretError>;
 
     async fn ensure_installed(
         &self,

harmony/src/domain/topology/k8s_anywhere.rs

@@ -39,7 +39,6 @@ pub struct K8sAnywhereTopology {
     k8s_state: Arc<OnceCell<Option<K8sState>>>,
     tenant_manager: Arc<OnceCell<K8sTenantManager>>,
     config: Arc<K8sAnywhereConfig>,
-    tenant_manager_config: OnceCell<TenantConfig>,
 }
 
 #[async_trait]
@@ -74,7 +73,6 @@ impl K8sAnywhereTopology {
             k8s_state: Arc::new(OnceCell::new()),
             tenant_manager: Arc::new(OnceCell::new()),
             config: Arc::new(K8sAnywhereConfig::from_env()),
-            tenant_manager_config: OnceCell::new(),
         }
     }
 
@@ -83,7 +81,6 @@ impl K8sAnywhereTopology {
             k8s_state: Arc::new(OnceCell::new()),
             tenant_manager: Arc::new(OnceCell::new()),
             config: Arc::new(config),
-            tenant_manager_config: OnceCell::new(),
         }
     }
 
@@ -199,16 +196,10 @@ impl K8sAnywhereTopology {
                 let k8s_client = self.k8s_client().await?;
                 Ok(K8sTenantManager::new(k8s_client))
             })
-            .await
-            .unwrap();
+            .await?;
 
         Ok(())
     }
-    async fn store_tenant_config(&self, config: TenantConfig) {
-        self.tenant_manager_config
-            .get_or_init(|| async { config })
-            .await;
-    }
 
     fn get_k8s_tenant_manager(&self) -> Result<&K8sTenantManager, ExecutorError> {
         match self.tenant_manager.get() {
@@ -289,13 +280,15 @@ impl HelmCommand for K8sAnywhereTopology {}
 #[async_trait]
 impl TenantManager for K8sAnywhereTopology {
     async fn provision_tenant(&self, config: &TenantConfig) -> Result<(), ExecutorError> {
-        self.store_tenant_config(config.clone()).await;
         self.get_k8s_tenant_manager()?
             .provision_tenant(config)
             .await
     }
 
-    fn get_tenant_config(&self) -> Option<TenantConfig> {
-        self.tenant_manager_config.get().cloned()
+    async fn get_tenant_config(&self) -> Option<TenantConfig> {
+        self.get_k8s_tenant_manager()
+            .ok()?
+            .get_tenant_config()
+            .await
     }
 }

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

@@ -27,7 +27,7 @@ impl<S: AlertSender + Installable<T>, T: Topology> Interpret<T> for AlertingInte
         inventory: &Inventory,
         topology: &T,
     ) -> Result<Outcome, InterpretError> {
-        self.sender.configure(inventory, topology)?;
+        self.sender.configure(inventory, topology).await?;
         for receiver in self.receivers.iter() {
             receiver.install(&self.sender).await?;
         }

harmony/src/domain/topology/tenant/k8s.rs

@@ -5,7 +5,6 @@ use crate::{
     topology::k8s::{ApplyStrategy, K8sClient},
 };
 use async_trait::async_trait;
-use derive_new::new;
 use k8s_openapi::{
     api::{
         core::v1::{LimitRange, Namespace, ResourceQuota},
@@ -19,12 +18,23 @@ use kube::Resource;
 use log::{debug, info, warn};
 use serde::de::DeserializeOwned;
 use serde_json::json;
+use tokio::sync::OnceCell;
 
 use super::{TenantConfig, TenantManager};
 
-#[derive(new, Clone, Debug)]
+#[derive(Clone, Debug)]
 pub struct K8sTenantManager {
     k8s_client: Arc<K8sClient>,
+    k8s_tenant_config: Arc<OnceCell<TenantConfig>>,
+}
+
+impl K8sTenantManager {
+    pub fn new(client: Arc<K8sClient>) -> Self {
+        Self {
+            k8s_client: client,
+            k8s_tenant_config: Arc::new(OnceCell::new()),
+        }
+    }
 }
 
 impl K8sTenantManager {
@@ -147,7 +157,7 @@ impl K8sTenantManager {
           "spec": {
             "limits": [
               {
-                "type": "Container", 
+                "type": "Container",
                 "default": {
                   "cpu": "500m",
                   "memory": "500Mi"
@@ -391,6 +401,9 @@ impl K8sTenantManager {
 
         Ok(network_policy)
     }
+    fn store_config(&self, config: &TenantConfig) {
+        let _ = self.k8s_tenant_config.set(config.clone());
+    }
 }
 
 #[async_trait]
@@ -419,9 +432,10 @@ impl TenantManager for K8sTenantManager {
             "Success provisionning K8s tenant id {} name {}",
             config.id, config.name
         );
+        self.store_config(config);
         Ok(())
     }
-    fn get_tenant_config(&self) -> Option<TenantConfig> {
-        todo!()
+    async fn get_tenant_config(&self) -> Option<TenantConfig> {
+        self.k8s_tenant_config.get().cloned()
     }
 }

harmony/src/domain/topology/tenant/manager.rs

@@ -16,5 +16,5 @@ pub trait TenantManager {
     /// * `config`: The desired configuration for the new tenant.
     async fn provision_tenant(&self, config: &TenantConfig) -> Result<(), ExecutorError>;
 
-    fn get_tenant_config(&self) -> Option<TenantConfig>;
+    async fn get_tenant_config(&self) -> Option<TenantConfig>;
 }

harmony/src/modules/monitoring/kube_prometheus/helm/kube_prometheus_helm_chart.rs

@@ -11,7 +11,9 @@ use std::{
 use crate::modules::{
     helm::chart::HelmChartScore,
     monitoring::kube_prometheus::types::{
-        AlertGroup, AlertManager, AlertManagerAdditionalPromRules, AlertManagerConfig, AlertManagerRoute, AlertManagerSpec, AlertManagerValues, ConfigReloader, Limits, PrometheusConfig, Requests, Resources
+        AlertGroup, AlertManager, AlertManagerAdditionalPromRules, AlertManagerConfig,
+        AlertManagerRoute, AlertManagerSpec, AlertManagerValues, ConfigReloader, Limits,
+        PrometheusConfig, Requests, Resources,
     },
 };
 

harmony/src/modules/monitoring/kube_prometheus/prometheus.rs

@@ -35,8 +35,8 @@ impl AlertSender for Prometheus {
 
 #[async_trait]
 impl<T: Topology + HelmCommand + TenantManager> Installable<T> for Prometheus {
-    fn configure(&self, _inventory: &Inventory, topology: &T) -> Result<(), InterpretError> {
-        self.configure_with_topology(topology);
+    async fn configure(&self, _inventory: &Inventory, topology: &T) -> Result<(), InterpretError> {
+        self.configure_with_topology(topology).await;
         Ok(())
     }
 
@@ -62,9 +62,10 @@ impl Prometheus {
         }
     }
 
-    pub fn configure_with_topology<T: TenantManager>(&self, topology: &T) {
+    pub async fn configure_with_topology<T: TenantManager>(&self, topology: &T) {
         let ns = topology
             .get_tenant_config()
+            .await
             .map(|cfg| cfg.name.clone())
             .unwrap_or_else(|| "monitoring".to_string());
         error!("This must be refactored, see comments in pr #74");