ensure event handlers are properly subscribed on init, extract duplicated progress functions, cleanup duplication

harmony_cli/src/cli_logger.rs

@@ -1,28 +1,68 @@
 use harmony::instrumentation::{self, HarmonyEvent};
-use indicatif::ProgressBar;
-use std::sync::{Arc, Mutex};
+use indicatif::{MultiProgress, ProgressBar};
+use indicatif_log_bridge::LogWrapper;
+use std::{
+    collections::{HashMap, hash_map},
+    sync::{Arc, Mutex},
+};
 
-pub async fn init() {
-    instrumentation::subscribe("CLI Logger", {
-        let current_spinner = Arc::new(Mutex::new(None::<ProgressBar>));
+pub fn init() -> tokio::task::JoinHandle<()> {
+    configure_logger();
+    let handle = tokio::spawn(handle_events());
+
+    loop {
+        if instrumentation::instrument(HarmonyEvent::HarmonyStarted).is_ok() {
+            break;
+        }
+    }
+
+    handle
+}
+
+fn configure_logger() {
+    let logger =
+        env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).build();
+    let level = logger.filter();
+    let multi = MultiProgress::new();
+    LogWrapper::new(multi.clone(), logger).try_init().unwrap();
+    log::set_max_level(level);
+}
+
+async fn handle_events() {
+    instrumentation::subscribe("Harmony CLI Logger", {
+        let progresses: Arc<Mutex<HashMap<String, MultiProgress>>> =
+            Arc::new(Mutex::new(HashMap::new()));
+        let topology_prepare_progress = Arc::new(Mutex::new(None::<ProgressBar>));
 
         move |event| {
-            let spinner_clone = Arc::clone(&current_spinner);
+            let progresses_clone = Arc::clone(&progresses);
+            let topology_prepare_progress_clone = Arc::clone(&topology_prepare_progress);
 
             async move {
-                let mut spinner_guard = spinner_clone.lock().unwrap();
+                let mut progresses = progresses_clone.lock().unwrap();
+                let mut topology_prepare_progress = topology_prepare_progress_clone.lock().unwrap();
 
                 match event {
+                    HarmonyEvent::HarmonyStarted => {}
                     HarmonyEvent::PrepareTopologyStarted { name } => {
-                        println!(
+                        let multi_progress = crate::progress::new_section(format!(
                             "{} Preparing environment: {name}...",
-                            crate::theme::EMOJI_TOPOLOGY
-                        );
+                            crate::theme::EMOJI_TOPOLOGY,
+                        ));
+                        (*progresses).insert(name, multi_progress);
                     }
+                    HarmonyEvent::TopologyPrepared { name, status } => match status {
+                        harmony::interpret::InterpretStatus::SUCCESS => todo!(),
+                        harmony::interpret::InterpretStatus::FAILURE => todo!(),
+                        harmony::interpret::InterpretStatus::RUNNING => todo!(),
+                        harmony::interpret::InterpretStatus::QUEUED => todo!(),
+                        harmony::interpret::InterpretStatus::BLOCKED => todo!(),
+                        harmony::interpret::InterpretStatus::NOOP => todo!(),
+                    },
                 }
                 true
             }
         }
     })
-    .await
+    .await;
 }

harmony_cli/src/lib.rs

@@ -5,6 +5,7 @@ use harmony::{score::Score, topology::Topology};
 use inquire::Confirm;
 
 pub mod cli_logger; // FIXME: Don't make me pub
+pub mod progress;
 pub mod theme;
 
 #[cfg(feature = "tui")]

harmony_cli/src/progress.rs

@@ -0,0 +1,40 @@
+use std::time::Duration;
+
+use indicatif::{MultiProgress, ProgressBar};
+
+pub fn new_section(title: String) -> MultiProgress {
+    let multi_progress = MultiProgress::new();
+    let _ = multi_progress.println(title);
+
+    multi_progress
+}
+
+pub fn add_spinner(multi_progress: &MultiProgress, message: String) -> ProgressBar {
+    let progress = multi_progress.add(ProgressBar::new_spinner());
+
+    progress.set_style(crate::theme::SPINNER_STYLE.clone());
+    progress.set_message(message);
+    progress.enable_steady_tick(Duration::from_millis(100));
+
+    progress
+}
+
+pub fn success(multi_progress: &MultiProgress, progress: Option<ProgressBar>, message: String) {
+    if let Some(progress) = progress {
+        multi_progress.remove(&progress)
+    }
+
+    let progress = multi_progress.add(ProgressBar::new_spinner());
+    progress.set_style(crate::theme::SUCCESS_SPINNER_STYLE.clone());
+    progress.finish_with_message(message);
+}
+
+pub fn error(multi_progress: &MultiProgress, progress: Option<ProgressBar>, message: String) {
+    if let Some(progress) = progress {
+        multi_progress.remove(&progress)
+    }
+
+    let progress = multi_progress.add(ProgressBar::new_spinner());
+    progress.set_style(crate::theme::ERROR_SPINNER_STYLE.clone());
+    progress.finish_with_message(message);
+}