group related scores together

harmony/src/modules/application/mod.rs

@@ -60,7 +60,7 @@ impl<A: Application, T: Topology + std::fmt::Debug> Interpret<T> for Application
                 }
             };
         }
-        Ok(Outcome::success("successfully created app".to_string()))
+        Ok(Outcome::success("Application created".to_string()))
     }
 
     fn get_name(&self) -> InterpretName {

harmony/src/modules/helm/chart.rs

@@ -225,19 +225,20 @@ impl<T: Topology + HelmCommand> Interpret<T> for HelmChartInterpret {
         match status {
             helm_wrapper_rs::HelmDeployStatus::Deployed => Ok(Outcome::new(
                 InterpretStatus::SUCCESS,
-                "Helm Chart deployed".to_string(),
+                format!("Helm Chart {} deployed", self.score.release_name),
             )),
             helm_wrapper_rs::HelmDeployStatus::PendingInstall => Ok(Outcome::new(
                 InterpretStatus::RUNNING,
-                "Helm Chart Pending install".to_string(),
+                format!("Helm Chart {} pending install...", self.score.release_name),
             )),
             helm_wrapper_rs::HelmDeployStatus::PendingUpgrade => Ok(Outcome::new(
                 InterpretStatus::RUNNING,
-                "Helm Chart pending upgrade".to_string(),
+                format!("Helm Chart {} pending upgrade...", self.score.release_name),
-            )),
-            helm_wrapper_rs::HelmDeployStatus::Failed => Err(InterpretError::new(
-                "Failed to install helm chart".to_string(),
             )),
+            helm_wrapper_rs::HelmDeployStatus::Failed => Err(InterpretError::new(format!(
+                "Helm Chart {} installation failed",
+                self.score.release_name
+            ))),
         }
     }
 

harmony/src/modules/prometheus/k8s_prometheus_alerting_score.rs

@@ -93,7 +93,9 @@ impl<T: Topology + K8sclient + PrometheusApplicationMonitoring<CRDPrometheus>> I
         self.install_rules(&self.prometheus_rules, &client).await?;
         self.install_monitors(self.service_monitors.clone(), &client)
             .await?;
-        Ok(Outcome::success("K8s components installed".to_string()))
+        Ok(Outcome::success(
+            "K8s monitoring components installed".to_string(),
+        ))
     }
 
     fn get_name(&self) -> InterpretName {

harmony_cli/src/cli_logger.rs

@@ -38,14 +38,17 @@ fn configure_logger() -> MultiProgress {
 async fn handle_events(base_progress: MultiProgress) {
     let progress_tracker = Arc::new(IndicatifProgressTracker::new(base_progress.clone()));
     let preparing_topology = Arc::new(Mutex::new(false));
+    let current_score: Arc<Mutex<Option<String>>> = Arc::new(Mutex::new(None));
 
     instrumentation::subscribe("Harmony CLI Logger", {
         move |event| {
             let progress_tracker = Arc::clone(&progress_tracker);
             let preparing_topology = Arc::clone(&preparing_topology);
+            let current_score = Arc::clone(&current_score);
 
             async move {
                 let mut preparing_topology = preparing_topology.lock().unwrap();
+                let mut current_score = current_score.lock().unwrap();
 
                 match event {
                     HarmonyEvent::HarmonyStarted => {}
@@ -103,13 +106,21 @@ async fn handle_events(base_progress: MultiProgress) {
                         score,
                         message,
                     } => {
-                        let section_key = if (*preparing_topology)
+                        let is_key_topology = (*preparing_topology)
-                            && progress_tracker.contains_section(&topology_key(&topology))
+                            && progress_tracker.contains_section(&topology_key(&topology));
-                        {
+                        let is_key_current_score = current_score.is_some()
+                            && progress_tracker
+                                .contains_section(&score_key(&current_score.clone().unwrap()));
+                        let is_key_score = progress_tracker.contains_section(&score_key(&score));
+
+                        let section_key = if is_key_topology {
                             topology_key(&topology)
-                        } else if progress_tracker.contains_section(&score_key(&score)) {
+                        } else if is_key_current_score {
+                            score_key(&current_score.clone().unwrap())
+                        } else if is_key_score {
                             score_key(&score)
                         } else {
+                            (*current_score) = Some(score.clone());
                             let key = score_key(&score);
                             progress_tracker.add_section(
                                 &key,
@@ -127,22 +138,28 @@ async fn handle_events(base_progress: MultiProgress) {
                         execution_id: task_key,
                         topology: _,
                         interpret: _,
-                        score: _,
+                        score,
                         outcome,
-                    } => match outcome {
+                    } => {
-                        Ok(outcome) => match outcome.status {
+                        if current_score.is_some() && current_score.clone().unwrap() == score {
-                            harmony::interpret::InterpretStatus::SUCCESS => {
+                            (*current_score) = None;
-                                progress_tracker.finish_task(&task_key, &outcome.message);
-                            }
-                            harmony::interpret::InterpretStatus::NOOP => {
-                                progress_tracker.skip_task(&task_key, &outcome.message);
-                            }
-                            _ => progress_tracker.fail_task(&task_key, &outcome.message),
-                        },
-                        Err(err) => {
-                            progress_tracker.fail_task(&task_key, &err.to_string());
                         }
-                    },
+
+                        match outcome {
+                            Ok(outcome) => match outcome.status {
+                                harmony::interpret::InterpretStatus::SUCCESS => {
+                                    progress_tracker.finish_task(&task_key, &outcome.message);
+                                }
+                                harmony::interpret::InterpretStatus::NOOP => {
+                                    progress_tracker.skip_task(&task_key, &outcome.message);
+                                }
+                                _ => progress_tracker.fail_task(&task_key, &outcome.message),
+                            },
+                            Err(err) => {
+                                progress_tracker.fail_task(&task_key, &err.to_string());
+                            }
+                        }
+                    }
                 }
                 true
             }