refactor: Interpret score with a provided method on Score

harmony/src/domain/maestro/mod.rs

@@ -84,10 +84,8 @@ impl<T: Topology> Maestro<T> {
                 self.topology.name(),
             );
         }
-        debug!("Running score {score:?}");
+        debug!("Interpreting score {score:?}");
-        let interpret = score.create_interpret();
+        let result = score.interpret(&self.inventory, &self.topology).await;
-        debug!("Launching interpret {interpret:?}");
-        let result = interpret.execute(&self.inventory, &self.topology).await;
         debug!("Got result {result:?}");
         result
     }

harmony/src/domain/score.rs

@@ -1,15 +1,32 @@
 use std::collections::BTreeMap;
 
+use async_trait::async_trait;
 use serde::Serialize;
 use serde_value::Value;
 
-use super::{interpret::Interpret, topology::Topology};
+use super::{
+    interpret::{Interpret, InterpretError, Outcome},
+    inventory::Inventory,
+    topology::Topology,
+};
 
+#[async_trait]
 pub trait Score<T: Topology>:
     std::fmt::Debug + ScoreToString<T> + Send + Sync + CloneBoxScore<T> + SerializeScore<T>
 {
-    fn create_interpret(&self) -> Box<dyn Interpret<T>>;
+    async fn interpret(
+        &self,
+        inventory: &Inventory,
+        topology: &T,
+    ) -> Result<Outcome, InterpretError> {
+        let interpret = self.create_interpret();
+        interpret.execute(inventory, topology).await
+    }
+
     fn name(&self) -> String;
+
+    #[doc(hidden)]
+    fn create_interpret(&self) -> Box<dyn Interpret<T>>;
 }
 
 pub trait SerializeScore<T: Topology> {

harmony/src/domain/topology/k8s_anywhere.rs

@@ -86,8 +86,7 @@ impl PrometheusApplicationMonitoring<CRDPrometheus> for K8sAnywhereTopology {
         let result = self
             .get_k8s_prometheus_application_score(sender.clone(), receivers)
             .await
-            .create_interpret()
+            .interpret(inventory, self)
-            .execute(inventory, self)
             .await;
 
         match result {
@@ -173,8 +172,7 @@ impl K8sAnywhereTopology {
     async fn try_install_k3d(&self) -> Result<(), PreparationError> {
         let result = self
             .get_k3d_installation_score()
-            .create_interpret()
+            .interpret(&Inventory::empty(), self)
-            .execute(&Inventory::empty(), self)
             .await;
 
         match result {
@@ -293,10 +291,7 @@ impl K8sAnywhereTopology {
                         debug!("installing prometheus operator");
                         let op_score =
                             prometheus_operator_helm_chart_score(sender.namespace.clone());
-                        let result = op_score
+                        let result = op_score.interpret(&Inventory::empty(), self).await;
-                            .create_interpret()
-                            .execute(&Inventory::empty(), self)
-                            .await;
 
                         return match result {
                             Ok(outcome) => match outcome.status {

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

@@ -236,7 +236,7 @@ impl K8sTenantManager {
                       //need to find a way to automatically detect the ip address from the docker
                       //network
                 "ipBlock": {
-                    "cidr": "172.24.0.0/16",
+                    "cidr": "172.18.0.0/16",
                     }
                   }
                 ]

harmony/src/modules/application/features/continuous_delivery.rs

@@ -193,8 +193,7 @@ impl<
                     })],
                 };
                 score
-                    .create_interpret()
+                    .interpret(&Inventory::empty(), topology)
-                    .execute(&Inventory::empty(), topology)
                     .await
                     .unwrap();
             }

harmony/src/modules/application/features/helm_argocd_score.rs

@@ -51,10 +51,7 @@ impl<T: Topology + K8sclient + HelmCommand> Interpret<T> for ArgoInterpret {
         topology: &T,
     ) -> Result<Outcome, InterpretError> {
         error!("Uncomment below, only disabled for debugging");
-        self.score
+        self.score.interpret(inventory, topology).await?;
-            .create_interpret()
-            .execute(inventory, topology)
-            .await?;
 
         let k8s_client = topology.k8s_client().await?;
         k8s_client

harmony/src/modules/application/features/monitoring.rs

@@ -57,8 +57,7 @@ impl<
             namespace: namespace.clone(),
             host: "localhost".to_string(),
         };
-        ntfy.create_interpret()
+        ntfy.interpret(&Inventory::empty(), topology)
-            .execute(&Inventory::empty(), topology)
             .await
             .expect("couldn't create interpret for ntfy");
 
@@ -95,8 +94,7 @@ impl<
 
         alerting_score.receivers.push(Box::new(ntfy_receiver));
         alerting_score
-            .create_interpret()
+            .interpret(&Inventory::empty(), topology)
-            .execute(&Inventory::empty(), topology)
             .await
             .unwrap();
         Ok(())

harmony/src/modules/lamp.rs

@@ -128,10 +128,7 @@ impl<T: Topology + K8sclient + HelmCommand> Interpret<T> for LAMPInterpret {
 
         info!("Deploying score {deployment_score:#?}");
 
-        deployment_score
+        deployment_score.interpret(inventory, topology).await?;
-            .create_interpret()
-            .execute(inventory, topology)
-            .await?;
 
         info!("LAMP deployment_score {deployment_score:?}");
 
@@ -153,10 +150,7 @@ impl<T: Topology + K8sclient + HelmCommand> Interpret<T> for LAMPInterpret {
                 .map(|nbs| fqdn!(nbs.to_string().as_str())),
         };
 
-        lamp_ingress
+        lamp_ingress.interpret(inventory, topology).await?;
-            .create_interpret()
-            .execute(inventory, topology)
-            .await?;
 
         info!("LAMP lamp_ingress {lamp_ingress:?}");
 
@@ -215,7 +209,7 @@ impl LAMPInterpret {
             repository: None,
         };
 
-        score.create_interpret().execute(inventory, topology).await
+        score.interpret(inventory, topology).await
     }
     fn build_dockerfile(&self, score: &LAMPScore) -> Result<PathBuf, Box<dyn std::error::Error>> {
         let mut dockerfile = Dockerfile::new();

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

@@ -119,8 +119,7 @@ impl KubePrometheus {
         topology: &T,
     ) -> Result<Outcome, InterpretError> {
         kube_prometheus_helm_chart_score(self.config.clone())
-            .create_interpret()
+            .interpret(inventory, topology)
-            .execute(inventory, topology)
             .await
     }
 }

harmony/src/modules/monitoring/ntfy/ntfy.rs

@@ -96,8 +96,7 @@ impl<T: Topology + HelmCommand + K8sclient> Interpret<T> for NtfyInterpret {
         topology: &T,
     ) -> Result<Outcome, InterpretError> {
         ntfy_helm_chart_score(self.score.namespace.clone(), self.score.host.clone())
-            .create_interpret()
+            .interpret(inventory, topology)
-            .execute(inventory, topology)
             .await?;
 
         debug!("installed ntfy helm chart");

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

@@ -100,8 +100,7 @@ impl Prometheus {
         topology: &T,
     ) -> Result<Outcome, InterpretError> {
         prometheus_helm_chart_score(self.config.clone())
-            .create_interpret()
+            .interpret(inventory, topology)
-            .execute(inventory, topology)
             .await
     }
     pub async fn install_grafana<T: Topology + HelmCommand + Send + Sync>(
@@ -116,8 +115,7 @@ impl Prometheus {
 
         if let Some(ns) = namespace.as_deref() {
             grafana_helm_chart_score(ns)
-                .create_interpret()
+                .interpret(inventory, topology)
-                .execute(inventory, topology)
                 .await
         } else {
             Err(InterpretError::new(