Merge pull request 'fix: bring back the TUI' (#110) from fix-tui into master

Reviewed-on: #110

.gitea/workflows/check.yml

@@ -9,7 +9,7 @@ jobs:
   check:
     runs-on: docker
     container:
-      image: hub.nationtech.io/harmony/harmony_composer:latest@sha256:eb0406fcb95c63df9b7c4b19bc50ad7914dd8232ce98e9c9abef628e07c69386
+      image: hub.nationtech.io/harmony/harmony_composer:latest
     steps:
       - name: Checkout code
         uses: actions/checkout@v4

.gitea/workflows/harmony_composer.yaml

@@ -7,7 +7,7 @@ on:
 jobs:
   package_harmony_composer:
     container:
-      image: hub.nationtech.io/harmony/harmony_composer:latest@sha256:eb0406fcb95c63df9b7c4b19bc50ad7914dd8232ce98e9c9abef628e07c69386
+      image: hub.nationtech.io/harmony/harmony_composer:latest
     runs-on: dind
     steps:
       - name: Checkout code
@@ -45,14 +45,14 @@ jobs:
             -H "Authorization: token ${{ secrets.GITEATOKEN }}" \
             "https://git.nationtech.io/api/v1/repos/nationtech/harmony/releases/tags/snapshot-latest" \
             | jq -r '.id // empty')
-          
+
           if [ -n "$RELEASE_ID" ]; then
             # Delete existing release
             curl -X DELETE \
               -H "Authorization: token ${{ secrets.GITEATOKEN }}" \
               "https://git.nationtech.io/api/v1/repos/nationtech/harmony/releases/$RELEASE_ID"
           fi
-          
+
           # Create new release
           RESPONSE=$(curl -X POST \
             -H "Authorization: token ${{ secrets.GITEATOKEN }}" \
@@ -65,7 +65,7 @@ jobs:
               "prerelease": true
             }' \
             "https://git.nationtech.io/api/v1/repos/nationtech/harmony/releases")
-          
+
           echo "RELEASE_ID=$(echo $RESPONSE | jq -r '.id')" >> $GITHUB_ENV
 
       - name: Upload Linux binary

Cargo.lock

@@ -1834,6 +1834,7 @@ name = "harmony_cli"
 version = "0.1.0"
 dependencies = [
  "assert_cmd",
+ "chrono",
  "clap",
  "console",
  "env_logger",

Cargo.toml

@@ -20,7 +20,7 @@ readme = "README.md"
 license = "GNU AGPL v3"
 
 [workspace.dependencies]
-log = "0.4"
+log = { version = "0.4", features = ["kv"] }
 env_logger = "0.11"
 derive-new = "0.7"
 async-trait = "0.1"

examples/nanodc/src/main.rs

@@ -8,7 +8,6 @@ use harmony::{
     hardware::{FirewallGroup, HostCategory, Location, PhysicalHost, SwitchGroup},
     infra::opnsense::OPNSenseManagementInterface,
     inventory::Inventory,
-    maestro::Maestro,
     modules::{
         http::StaticFilesHttpScore,
         ipxe::IpxeScore,
@@ -130,16 +129,21 @@ async fn main() {
         "./data/watchguard/pxe-http-files".to_string(),
     ));
     let ipxe_score = IpxeScore::new();
-    let mut maestro = Maestro::initialize(inventory, topology).await.unwrap();
+
-    maestro.register_all(vec![
+    harmony_tui::run(
-        Box::new(dns_score),
+        inventory,
-        Box::new(bootstrap_dhcp_score),
+        topology,
-        Box::new(bootstrap_load_balancer_score),
+        vec![
-        Box::new(load_balancer_score),
+            Box::new(dns_score),
-        Box::new(tftp_score),
+            Box::new(bootstrap_dhcp_score),
-        Box::new(http_score),
+            Box::new(bootstrap_load_balancer_score),
-        Box::new(ipxe_score),
+            Box::new(load_balancer_score),
-        Box::new(dhcp_score),
+            Box::new(tftp_score),
-    ]);
+            Box::new(http_score),
-    harmony_tui::init(maestro).await.unwrap();
+            Box::new(ipxe_score),
+            Box::new(dhcp_score),
+        ],
+    )
+    .await
+    .unwrap();
 }

examples/opnsense/src/main.rs

@@ -8,7 +8,6 @@ use harmony::{
     hardware::{FirewallGroup, HostCategory, Location, PhysicalHost, SwitchGroup},
     infra::opnsense::OPNSenseManagementInterface,
     inventory::Inventory,
-    maestro::Maestro,
     modules::{
         dummy::{ErrorScore, PanicScore, SuccessScore},
         http::StaticFilesHttpScore,
@@ -84,20 +83,25 @@ async fn main() {
     let http_score = StaticFilesHttpScore::new(Url::LocalFolder(
         "./data/watchguard/pxe-http-files".to_string(),
     ));
-    let mut maestro = Maestro::initialize(inventory, topology).await.unwrap();
+
-    maestro.register_all(vec![
+    harmony_tui::run(
-        Box::new(dns_score),
+        inventory,
-        Box::new(dhcp_score),
+        topology,
-        Box::new(load_balancer_score),
+        vec![
-        Box::new(tftp_score),
+            Box::new(dns_score),
-        Box::new(http_score),
+            Box::new(dhcp_score),
-        Box::new(OPNsenseShellCommandScore {
+            Box::new(load_balancer_score),
-            opnsense: opnsense.get_opnsense_config(),
+            Box::new(tftp_score),
-            command: "touch /tmp/helloharmonytouching".to_string(),
+            Box::new(http_score),
-        }),
+            Box::new(OPNsenseShellCommandScore {
-        Box::new(SuccessScore {}),
+                opnsense: opnsense.get_opnsense_config(),
-        Box::new(ErrorScore {}),
+                command: "touch /tmp/helloharmonytouching".to_string(),
-        Box::new(PanicScore {}),
+            }),
-    ]);
+            Box::new(SuccessScore {}),
-    harmony_tui::init(maestro).await.unwrap();
+            Box::new(ErrorScore {}),
+            Box::new(PanicScore {}),
+        ],
+    )
+    .await
+    .unwrap();
 }

examples/tui/src/main.rs

@@ -2,7 +2,6 @@ use std::net::{SocketAddr, SocketAddrV4};
 
 use harmony::{
     inventory::Inventory,
-    maestro::Maestro,
     modules::{
         dns::DnsScore,
         dummy::{ErrorScore, PanicScore, SuccessScore},
@@ -16,18 +15,19 @@ use harmony_macros::ipv4;
 
 #[tokio::main]
 async fn main() {
-    let inventory = Inventory::autoload();
+    harmony_tui::run(
-    let topology = DummyInfra {};
+        Inventory::autoload(),
-    let mut maestro = Maestro::initialize(inventory, topology).await.unwrap();
+        DummyInfra {},
-
+        vec![
-    maestro.register_all(vec![
+            Box::new(SuccessScore {}),
-        Box::new(SuccessScore {}),
+            Box::new(ErrorScore {}),
-        Box::new(ErrorScore {}),
+            Box::new(PanicScore {}),
-        Box::new(PanicScore {}),
+            Box::new(DnsScore::new(vec![], None)),
-        Box::new(DnsScore::new(vec![], None)),
+            Box::new(build_large_score()),
-        Box::new(build_large_score()),
+        ],
-    ]);
+    )
-    harmony_tui::init(maestro).await.unwrap();
+    .await
+    .unwrap();
 }
 
 fn build_large_score() -> LoadBalancerScore {

harmony/Cargo.toml

@@ -5,6 +5,9 @@ version.workspace = true
 readme.workspace = true
 license.workspace = true
 
+[features]
+testing = []
+
 [dependencies]
 rand = "0.9"
 hex = "0.4"

harmony/src/domain/instrumentation.rs

@@ -2,6 +2,8 @@ use log::debug;
 use once_cell::sync::Lazy;
 use tokio::sync::broadcast;
 
+use crate::modules::application::ApplicationFeatureStatus;
+
 use super::{
     interpret::{InterpretError, Outcome},
     topology::TopologyStatus,
@@ -30,6 +32,12 @@ pub enum HarmonyEvent {
         status: TopologyStatus,
         message: Option<String>,
     },
+    ApplicationFeatureStateChanged {
+        topology: String,
+        application: String,
+        feature: String,
+        status: ApplicationFeatureStatus,
+    },
 }
 
 static HARMONY_EVENT_BUS: Lazy<broadcast::Sender<HarmonyEvent>> = Lazy::new(|| {
@@ -39,9 +47,14 @@ static HARMONY_EVENT_BUS: Lazy<broadcast::Sender<HarmonyEvent>> = Lazy::new(|| {
 });
 
 pub fn instrument(event: HarmonyEvent) -> Result<(), &'static str> {
-    match HARMONY_EVENT_BUS.send(event) {
+    if cfg!(any(test, feature = "testing")) {
-        Ok(_) => Ok(()),
+        let _ = event; // Suppress the "unused variable" warning for `event`
-        Err(_) => Err("send error: no subscribers"),
+        Ok(())
+    } else {
+        match HARMONY_EVENT_BUS.send(event) {
+            Ok(_) => Ok(()),
+            Err(_) => Err("send error: no subscribers"),
+        }
     }
 }
 

harmony/src/domain/topology/ha_cluster.rs

@@ -241,7 +241,7 @@ pub struct DummyInfra;
 #[async_trait]
 impl Topology for DummyInfra {
     fn name(&self) -> &str {
-        todo!()
+        "DummyInfra"
     }
 
     async fn ensure_ready(&self) -> Result<PreparationOutcome, PreparationError> {

harmony/src/domain/topology/k8s.rs

@@ -120,7 +120,7 @@ impl K8sClient {
                     .expect("Couldn't unwrap status");
 
                 if let Some(s) = status.status {
-                    debug!("Status: {}", s);
+                    debug!("Status: {} - {:?}", s, status.details);
                     if s == "Success" { Ok(()) } else { Err(s) }
                 } else {
                     Err("Couldn't get inner status of pod exec".to_string())

harmony/src/domain/topology/k8s_anywhere.rs

@@ -28,7 +28,13 @@ use super::{
     PreparationOutcome, Topology,
     k8s::K8sClient,
     oberservability::monitoring::AlertReceiver,
-    tenant::{TenantConfig, TenantManager, k8s::K8sTenantManager},
+    tenant::{
+        TenantConfig, TenantManager,
+        k8s::K8sTenantManager,
+        network_policy::{
+            K3dNetworkPolicyStrategy, NetworkPolicyStrategy, NoopNetworkPolicyStrategy,
+        },
+    },
 };
 
 #[derive(Clone, Debug)]
@@ -250,16 +256,21 @@ impl K8sAnywhereTopology {
         Ok(Some(state))
     }
 
-    async fn ensure_k8s_tenant_manager(&self) -> Result<(), String> {
+    async fn ensure_k8s_tenant_manager(&self, k8s_state: &K8sState) -> Result<(), String> {
         if self.tenant_manager.get().is_some() {
             return Ok(());
         }
 
         self.tenant_manager
             .get_or_try_init(async || -> Result<K8sTenantManager, String> {
-                // TOOD: checker si K8s ou K3d/s tenant manager (ref. issue https://git.nationtech.io/NationTech/harmony/issues/94)
                 let k8s_client = self.k8s_client().await?;
-                Ok(K8sTenantManager::new(k8s_client))
+                let network_policy_strategy: Box<dyn NetworkPolicyStrategy> = match k8s_state.source
+                {
+                    K8sSource::LocalK3d => Box::new(K3dNetworkPolicyStrategy::new()),
+                    K8sSource::Kubeconfig => Box::new(NoopNetworkPolicyStrategy::new()),
+                };
+
+                Ok(K8sTenantManager::new(k8s_client, network_policy_strategy))
             })
             .await?;
 
@@ -390,7 +401,7 @@ impl Topology for K8sAnywhereTopology {
             "no K8s client could be found or installed".to_string(),
         ))?;
 
-        self.ensure_k8s_tenant_manager()
+        self.ensure_k8s_tenant_manager(k8s_state)
             .await
             .map_err(PreparationError::new)?;
 

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

@@ -20,24 +20,27 @@ use serde::de::DeserializeOwned;
 use serde_json::json;
 use tokio::sync::OnceCell;
 
-use super::{TenantConfig, TenantManager};
+use super::{TenantConfig, TenantManager, network_policy::NetworkPolicyStrategy};
 
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct K8sTenantManager {
     k8s_client: Arc<K8sClient>,
     k8s_tenant_config: Arc<OnceCell<TenantConfig>>,
+    network_policy_strategy: Box<dyn NetworkPolicyStrategy>,
 }
 
 impl K8sTenantManager {
-    pub fn new(client: Arc<K8sClient>) -> Self {
+    pub fn new(
+        client: Arc<K8sClient>,
+        network_policy_strategy: Box<dyn NetworkPolicyStrategy>,
+    ) -> Self {
         Self {
             k8s_client: client,
             k8s_tenant_config: Arc::new(OnceCell::new()),
+            network_policy_strategy,
         }
     }
-}
 
-impl K8sTenantManager {
     fn get_namespace_name(&self, config: &TenantConfig) -> String {
         config.name.clone()
     }
@@ -218,29 +221,6 @@ impl K8sTenantManager {
                   }
                 ]
               },
-              {
-                "to": [
-                  {
-                "ipBlock": {
-                    "cidr": "10.43.0.1/32",
-                    }
-                  }
-                ]
-              },
-              {
-                "to": [
-                  {
-                      //TODO this ip is from the docker network that k3d is running on
-                      //since k3d does not deploy kube-api-server as a pod it needs to ahve the ip
-                      //address opened up
-                      //need to find a way to automatically detect the ip address from the docker
-                      //network
-                "ipBlock": {
-                    "cidr": "172.18.0.0/16",
-                    }
-                  }
-                ]
-              },
               {
                 "to": [
                   {
@@ -410,12 +390,27 @@ impl K8sTenantManager {
     }
 }
 
+impl Clone for K8sTenantManager {
+    fn clone(&self) -> Self {
+        Self {
+            k8s_client: self.k8s_client.clone(),
+            k8s_tenant_config: self.k8s_tenant_config.clone(),
+            network_policy_strategy: self.network_policy_strategy.clone_box(),
+        }
+    }
+}
+
 #[async_trait]
 impl TenantManager for K8sTenantManager {
     async fn provision_tenant(&self, config: &TenantConfig) -> Result<(), ExecutorError> {
         let namespace = self.build_namespace(config)?;
         let resource_quota = self.build_resource_quota(config)?;
+
         let network_policy = self.build_network_policy(config)?;
+        let network_policy = self
+            .network_policy_strategy
+            .adjust_policy(network_policy, config);
+
         let resource_limit_range = self.build_limit_range(config)?;
 
         self.ensure_constraints(&namespace)?;

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

@@ -1,11 +1,11 @@
 pub mod k8s;
 mod manager;
-use std::str::FromStr;
+pub mod network_policy;
-
-pub use manager::*;
-use serde::{Deserialize, Serialize};
 
 use crate::data::Id;
+pub use manager::*;
+use serde::{Deserialize, Serialize};
+use std::str::FromStr;
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] // Assuming serde for Scores
 pub struct TenantConfig {

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

@@ -0,0 +1,120 @@
+use k8s_openapi::api::networking::v1::{
+    IPBlock, NetworkPolicy, NetworkPolicyEgressRule, NetworkPolicyPeer, NetworkPolicySpec,
+};
+
+use super::TenantConfig;
+
+pub trait NetworkPolicyStrategy: Send + Sync + std::fmt::Debug {
+    fn clone_box(&self) -> Box<dyn NetworkPolicyStrategy>;
+
+    fn adjust_policy(&self, policy: NetworkPolicy, config: &TenantConfig) -> NetworkPolicy;
+}
+
+#[derive(Clone, Debug)]
+pub struct NoopNetworkPolicyStrategy {}
+
+impl NoopNetworkPolicyStrategy {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Default for NoopNetworkPolicyStrategy {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl NetworkPolicyStrategy for NoopNetworkPolicyStrategy {
+    fn clone_box(&self) -> Box<dyn NetworkPolicyStrategy> {
+        Box::new(self.clone())
+    }
+
+    fn adjust_policy(&self, policy: NetworkPolicy, _config: &TenantConfig) -> NetworkPolicy {
+        policy
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct K3dNetworkPolicyStrategy {}
+
+impl K3dNetworkPolicyStrategy {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Default for K3dNetworkPolicyStrategy {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl NetworkPolicyStrategy for K3dNetworkPolicyStrategy {
+    fn clone_box(&self) -> Box<dyn NetworkPolicyStrategy> {
+        Box::new(self.clone())
+    }
+
+    fn adjust_policy(&self, policy: NetworkPolicy, _config: &TenantConfig) -> NetworkPolicy {
+        let mut egress = policy
+            .spec
+            .clone()
+            .unwrap_or_default()
+            .egress
+            .clone()
+            .unwrap_or_default();
+        egress.push(NetworkPolicyEgressRule {
+            to: Some(vec![NetworkPolicyPeer {
+                ip_block: Some(IPBlock {
+                    cidr: "172.18.0.0/16".into(), // TODO: query the IP range https://git.nationtech.io/NationTech/harmony/issues/108
+                    ..Default::default()
+                }),
+                ..Default::default()
+            }]),
+            ..Default::default()
+        });
+
+        NetworkPolicy {
+            spec: Some(NetworkPolicySpec {
+                egress: Some(egress),
+                ..policy.spec.unwrap_or_default()
+            }),
+            ..policy
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use k8s_openapi::api::networking::v1::{
+        IPBlock, NetworkPolicy, NetworkPolicyEgressRule, NetworkPolicyPeer, NetworkPolicySpec,
+    };
+
+    use super::{K3dNetworkPolicyStrategy, NetworkPolicyStrategy};
+
+    #[test]
+    pub fn should_add_ip_block_for_k3d_harmony_server() {
+        let strategy = K3dNetworkPolicyStrategy::new();
+
+        let policy =
+            strategy.adjust_policy(NetworkPolicy::default(), &super::TenantConfig::default());
+
+        let expected_policy = NetworkPolicy {
+            spec: Some(NetworkPolicySpec {
+                egress: Some(vec![NetworkPolicyEgressRule {
+                    to: Some(vec![NetworkPolicyPeer {
+                        ip_block: Some(IPBlock {
+                            cidr: "172.18.0.0/16".into(),
+                            ..Default::default()
+                        }),
+                        ..Default::default()
+                    }]),
+                    ..Default::default()
+                }]),
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+        assert_eq!(expected_policy, policy);
+    }
+}

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

@@ -1,7 +1,7 @@
 use std::{io::Write, process::Command, sync::Arc};
 
 use async_trait::async_trait;
-use log::{debug, error};
+use log::info;
 use serde_yaml::Value;
 use tempfile::NamedTempFile;
 
@@ -56,14 +56,11 @@ impl<A: OCICompliant + HelmPackage> ContinuousDelivery<A> {
         chart_url: String,
         image_name: String,
     ) -> Result<(), String> {
-        error!(
+        // TODO: This works only with local k3d installations, which is fine only for current demo purposes. We assume usage of K8sAnywhereTopology"
-            "FIXME This works only with local k3d installations, which is fine only for current demo purposes. We assume usage of K8sAnywhereTopology"
+        // https://git.nationtech.io/NationTech/harmony/issues/106
-        );
-
-        error!("TODO hardcoded k3d bin path is wrong");
         let k3d_bin_path = (*HARMONY_DATA_DIR).join("k3d").join("k3d");
         // --- 1. Import the container image into the k3d cluster ---
-        debug!(
+        info!(
             "Importing image '{}' into k3d cluster 'harmony'",
             image_name
         );
@@ -80,7 +77,7 @@ impl<A: OCICompliant + HelmPackage> ContinuousDelivery<A> {
         }
 
         // --- 2. Get the kubeconfig for the k3d cluster and write it to a temp file ---
-        debug!("Retrieving kubeconfig for k3d cluster 'harmony'");
+        info!("Retrieving kubeconfig for k3d cluster 'harmony'");
         let kubeconfig_output = Command::new(&k3d_bin_path)
             .args(["kubeconfig", "get", "harmony"])
             .output()
@@ -101,7 +98,7 @@ impl<A: OCICompliant + HelmPackage> ContinuousDelivery<A> {
         let kubeconfig_path = temp_kubeconfig.path().to_str().unwrap();
 
         // --- 3. Install or upgrade the Helm chart in the cluster ---
-        debug!(
+        info!(
             "Deploying Helm chart '{}' to namespace '{}'",
             chart_url, app_name
         );
@@ -131,7 +128,7 @@ impl<A: OCICompliant + HelmPackage> ContinuousDelivery<A> {
             ));
         }
 
-        debug!("Successfully deployed '{}' to local k3d cluster.", app_name);
+        info!("Successfully deployed '{}' to local k3d cluster.", app_name);
         Ok(())
     }
 }
@@ -151,14 +148,12 @@ impl<
         // Or ask for it when unknown
 
         let helm_chart = self.application.build_push_helm_package(&image).await?;
-        debug!("Pushed new helm chart {helm_chart}");
 
-        error!("TODO Make building image configurable/skippable if image already exists (prompt)");
+        // TODO: Make building image configurable/skippable if image already exists (prompt)")
+        // https://git.nationtech.io/NationTech/harmony/issues/104
         let image = self.application.build_push_oci_image().await?;
-        debug!("Pushed new docker image {image}");
 
-        debug!("Installing ContinuousDelivery feature");
+        // TODO: this is a temporary hack for demo purposes, the deployment target should be driven
-        // TODO this is a temporary hack for demo purposes, the deployment target should be driven
         // by the topology only and we should not have to know how to perform tasks like this for
         // which the topology should be responsible.
         //
@@ -171,17 +166,20 @@ impl<
         // access it. This forces every Topology to understand the concept of targets though... So
         // instead I'll create a new Capability which is MultiTargetTopology and we'll see how it
         // goes. It still does not feel right though.
+        //
+        // https://git.nationtech.io/NationTech/harmony/issues/106
         match topology.current_target() {
             DeploymentTarget::LocalDev => {
+                info!("Deploying {} locally...", self.application.name());
                 self.deploy_to_local_k3d(self.application.name(), helm_chart, image)
                     .await?;
             }
             target => {
-                debug!("Deploying to target {target:?}");
+                info!("Deploying {} to target {target:?}", self.application.name());
                 let score = ArgoHelmScore {
-                    namespace: "harmonydemo-staging".to_string(),
+                    namespace: "harmony-example-rust-webapp".to_string(),
-                    openshift: false,
+                    openshift: true,
-                    domain: "argo.harmonydemo.apps.st.mcd".to_string(),
+                    domain: "argo.harmonydemo.apps.ncd0.harmony.mcd".to_string(),
                     argo_apps: vec![ArgoApplication::from(CDApplicationConfig {
                         // helm pull oci://hub.nationtech.io/harmony/harmony-example-rust-webapp-chart --version 0.1.0
                         version: Version::from("0.1.0").unwrap(),
@@ -189,7 +187,7 @@ impl<
                         helm_chart_name: "harmony-example-rust-webapp-chart".to_string(),
                         values_overrides: None,
                         name: "harmony-demo-rust-webapp".to_string(),
-                        namespace: "harmonydemo-staging".to_string(),
+                        namespace: "harmony-example-rust-webapp".to_string(),
                     })],
                 };
                 score

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

@@ -1,5 +1,4 @@
 use async_trait::async_trait;
-use log::error;
 use non_blank_string_rs::NonBlankString;
 use serde::Serialize;
 use std::str::FromStr;
@@ -50,7 +49,6 @@ impl<T: Topology + K8sclient + HelmCommand> Interpret<T> for ArgoInterpret {
         inventory: &Inventory,
         topology: &T,
     ) -> Result<Outcome, InterpretError> {
-        error!("Uncomment below, only disabled for debugging");
         self.score.interpret(inventory, topology).await?;
 
         let k8s_client = topology.k8s_client().await?;
@@ -58,9 +56,14 @@ impl<T: Topology + K8sclient + HelmCommand> Interpret<T> for ArgoInterpret {
             .apply_yaml_many(&self.argo_apps.iter().map(|a| a.to_yaml()).collect(), None)
             .await
             .unwrap();
+
         Ok(Outcome::success(format!(
-            "ArgoCD installed with {} applications",
+            "ArgoCD installed with {} {}",
-            self.argo_apps.len()
+            self.argo_apps.len(),
+            match self.argo_apps.len() {
+                1 => "application",
+                _ => "applications",
+            }
         )))
     }
 

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

@@ -4,6 +4,7 @@ use crate::modules::application::{Application, ApplicationFeature};
 use crate::modules::monitoring::application_monitoring::application_monitoring_score::ApplicationMonitoringScore;
 use crate::modules::monitoring::kube_prometheus::crd::crd_alertmanager_config::CRDPrometheus;
 
+use crate::topology::MultiTargetTopology;
 use crate::{
     inventory::Inventory,
     modules::monitoring::{
@@ -33,6 +34,7 @@ impl<
         + 'static
         + TenantManager
         + K8sclient
+        + MultiTargetTopology
         + std::fmt::Debug
         + PrometheusApplicationMonitoring<CRDPrometheus>,
 > ApplicationFeature<T> for Monitoring
@@ -55,11 +57,11 @@ impl<
         };
         let ntfy = NtfyScore {
             namespace: namespace.clone(),
-            host: "localhost".to_string(),
+            host: "ntfy.harmonydemo.apps.ncd0.harmony.mcd".to_string(),
         };
         ntfy.interpret(&Inventory::empty(), topology)
             .await
-            .expect("couldn't create interpret for ntfy");
+            .map_err(|e| e.to_string())?;
 
         let ntfy_default_auth_username = "harmony";
         let ntfy_default_auth_password = "harmony";
@@ -96,7 +98,7 @@ impl<
         alerting_score
             .interpret(&Inventory::empty(), topology)
             .await
-            .unwrap();
+            .map_err(|e| e.to_string())?;
         Ok(())
     }
     fn name(&self) -> String {

harmony/src/modules/application/mod.rs

@@ -14,11 +14,19 @@ use serde::Serialize;
 
 use crate::{
     data::{Id, Version},
+    instrumentation::{self, HarmonyEvent},
     interpret::{Interpret, InterpretError, InterpretName, InterpretStatus, Outcome},
     inventory::Inventory,
     topology::Topology,
 };
 
+#[derive(Clone, Debug)]
+pub enum ApplicationFeatureStatus {
+    Installing,
+    Installed,
+    Failed { details: String },
+}
+
 pub trait Application: std::fmt::Debug + Send + Sync {
     fn name(&self) -> String;
 }
@@ -47,13 +55,34 @@ impl<A: Application, T: Topology + std::fmt::Debug> Interpret<T> for Application
                 .join(", ")
         );
         for feature in self.features.iter() {
-            debug!(
+            instrumentation::instrument(HarmonyEvent::ApplicationFeatureStateChanged {
-                "Installing feature {} for application {app_name}",
+                topology: topology.name().into(),
-                feature.name()
+                application: self.application.name(),
-            );
+                feature: feature.name(),
+                status: ApplicationFeatureStatus::Installing,
+            })
+            .unwrap();
+
             let _ = match feature.ensure_installed(topology).await {
-                Ok(()) => (),
+                Ok(()) => {
+                    instrumentation::instrument(HarmonyEvent::ApplicationFeatureStateChanged {
+                        topology: topology.name().into(),
+                        application: self.application.name(),
+                        feature: feature.name(),
+                        status: ApplicationFeatureStatus::Installed,
+                    })
+                    .unwrap();
+                }
                 Err(msg) => {
+                    instrumentation::instrument(HarmonyEvent::ApplicationFeatureStateChanged {
+                        topology: topology.name().into(),
+                        application: self.application.name(),
+                        feature: feature.name(),
+                        status: ApplicationFeatureStatus::Failed {
+                            details: msg.clone(),
+                        },
+                    })
+                    .unwrap();
                     return Err(InterpretError::new(format!(
                         "Application Interpret failed to install feature : {msg}"
                     )));

harmony/src/modules/application/rust.rs

@@ -10,7 +10,7 @@ use dockerfile_builder::Dockerfile;
 use dockerfile_builder::instruction::{CMD, COPY, ENV, EXPOSE, FROM, RUN, USER, WORKDIR};
 use dockerfile_builder::instruction_builder::CopyBuilder;
 use futures_util::StreamExt;
-use log::{debug, error, log_enabled};
+use log::{debug, info, log_enabled};
 use serde::Serialize;
 use tar::Archive;
 
@@ -73,19 +73,19 @@ impl Application for RustWebapp {
 #[async_trait]
 impl HelmPackage for RustWebapp {
     async fn build_push_helm_package(&self, image_url: &str) -> Result<String, String> {
-        debug!("Starting Helm chart build and push for '{}'", self.name);
+        info!("Starting Helm chart build and push for '{}'", self.name);
 
         // 1. Create the Helm chart files on disk.
         let chart_dir = self
             .create_helm_chart_files(image_url)
             .map_err(|e| format!("Failed to create Helm chart files: {}", e))?;
-        debug!("Successfully created Helm chart files in {:?}", chart_dir);
+        info!("Successfully created Helm chart files in {:?}", chart_dir);
 
         // 2. Package the chart into a .tgz archive.
         let packaged_chart_path = self
             .package_helm_chart(&chart_dir)
             .map_err(|e| format!("Failed to package Helm chart: {}", e))?;
-        debug!(
+        info!(
             "Successfully packaged Helm chart: {}",
             packaged_chart_path.to_string_lossy()
         );
@@ -94,7 +94,7 @@ impl HelmPackage for RustWebapp {
         let oci_chart_url = self
             .push_helm_chart(&packaged_chart_path)
             .map_err(|e| format!("Failed to push Helm chart: {}", e))?;
-        debug!("Successfully pushed Helm chart to: {}", oci_chart_url);
+        info!("Successfully pushed Helm chart to: {}", oci_chart_url);
 
         Ok(oci_chart_url)
     }
@@ -107,20 +107,20 @@ impl OCICompliant for RustWebapp {
     async fn build_push_oci_image(&self) -> Result<String, String> {
         // This function orchestrates the build and push process.
         // It's async to match the trait definition, though the underlying docker commands are blocking.
-        debug!("Starting OCI image build and push for '{}'", self.name);
+        info!("Starting OCI image build and push for '{}'", self.name);
 
         // 1. Build the image by calling the synchronous helper function.
         let image_tag = self.image_name();
         self.build_docker_image(&image_tag)
             .await
             .map_err(|e| format!("Failed to build Docker image: {}", e))?;
-        debug!("Successfully built Docker image: {}", image_tag);
+        info!("Successfully built Docker image: {}", image_tag);
 
         // 2. Push the image to the registry.
         self.push_docker_image(&image_tag)
             .await
             .map_err(|e| format!("Failed to push Docker image: {}", e))?;
-        debug!("Successfully pushed Docker image to: {}", image_tag);
+        info!("Successfully pushed Docker image to: {}", image_tag);
 
         Ok(image_tag)
     }
@@ -195,7 +195,7 @@ impl RustWebapp {
         );
 
         while let Some(msg) = image_build_stream.next().await {
-            println!("Message: {msg:?}");
+            debug!("Message: {msg:?}");
         }
 
         Ok(image_name.to_string())
@@ -219,7 +219,7 @@ impl RustWebapp {
         );
 
         while let Some(msg) = push_image_stream.next().await {
-            println!("Message: {msg:?}");
+            debug!("Message: {msg:?}");
         }
 
         Ok(image_tag.to_string())
@@ -288,9 +288,8 @@ impl RustWebapp {
                         .unwrap(),
                 );
                 // Copy the compiled binary from the builder stage.
-                error!(
+                // TODO: Should not be using score name here, instead should use name from Cargo.toml
-                    "FIXME Should not be using score name here, instead should use name from Cargo.toml"
+                // https://git.nationtech.io/NationTech/harmony/issues/105
-                );
                 let binary_path_in_builder = format!("/app/target/release/{}", self.name);
                 let binary_path_in_final = format!("/home/appuser/{}", self.name);
                 dockerfile.push(
@@ -328,9 +327,8 @@ impl RustWebapp {
                 ));
 
                 // Copy only the compiled binary from the builder stage.
-                error!(
+                // TODO: Should not be using score name here, instead should use name from Cargo.toml
-                    "FIXME Should not be using score name here, instead should use name from Cargo.toml"
+                // https://git.nationtech.io/NationTech/harmony/issues/105
-                );
                 let binary_path_in_builder = format!("/app/target/release/{}", self.name);
                 let binary_path_in_final = format!("/usr/local/bin/{}", self.name);
                 dockerfile.push(

harmony/src/modules/k3d/install.rs

@@ -29,7 +29,7 @@ impl Default for K3DInstallationScore {
 }
 
 impl<T: Topology> Score<T> for K3DInstallationScore {
-    fn create_interpret(&self) -> Box<dyn crate::interpret::Interpret<T>> {
+    fn create_interpret(&self) -> Box<dyn Interpret<T>> {
         Box::new(K3dInstallationInterpret {
             score: self.clone(),
         })

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

@@ -1,9 +1,25 @@
 use non_blank_string_rs::NonBlankString;
 use std::str::FromStr;
 
-use crate::modules::helm::chart::{HelmChartScore, HelmRepository};
+use crate::{modules::helm::chart::HelmChartScore, topology::DeploymentTarget};
+
+pub fn ntfy_helm_chart_score(
+    namespace: String,
+    host: String,
+    target: DeploymentTarget,
+) -> HelmChartScore {
+    // TODO not actually the correct logic, this should be fixed by using an ingresss which is the
+    // correct k8s standard.
+    //
+    // Another option is to delegate to the topology the ingress technology it wants to use Route,
+    // Ingress or other
+    let route_enabled = match target {
+        DeploymentTarget::LocalDev => false,
+        DeploymentTarget::Staging => true,
+        DeploymentTarget::Production => true,
+    };
+    let ingress_enabled = !route_enabled;
 
-pub fn ntfy_helm_chart_score(namespace: String, host: String) -> HelmChartScore {
     let values = format!(
         r#"
 replicaCount: 1
@@ -25,23 +41,14 @@ serviceAccount:
 
 service:
   type: ClusterIP
-  port: 80
+  port: 8080
 
 ingress:
-  enabled: true
+  enabled: {ingress_enabled}
-#  annotations:
-    # kubernetes.io/ingress.class: nginx
-    # kubernetes.io/tls-acme: "true"
-  hosts:
-    - host: {host}
-      paths:
-        - path: /
-          pathType: ImplementationSpecific
-  tls: []
-  #  - secretName: chart-example-tls
-  #    hosts:
-  #      - chart-example.local
 
+route:
+  enabled: {route_enabled}
+  host: {host}
 
 autoscaling:
   enabled: false
@@ -49,7 +56,7 @@ autoscaling:
 config:
   enabled: true
   data:
-#    base-url: "https://ntfy.something.com"
+    base-url: "https://{host}"
     auth-file: "/var/cache/ntfy/user.db"
     auth-default-access: "deny-all"
     cache-file: "/var/cache/ntfy/cache.db"
@@ -59,6 +66,7 @@ config:
     enable-signup: false
     enable-login: "true"
     enable-metrics: "true"
+    listen-http: ":8080"
 
 persistence:
   enabled: true
@@ -69,16 +77,12 @@ persistence:
     HelmChartScore {
         namespace: Some(NonBlankString::from_str(&namespace).unwrap()),
         release_name: NonBlankString::from_str("ntfy").unwrap(),
-        chart_name: NonBlankString::from_str("sarab97/ntfy").unwrap(),
+        chart_name: NonBlankString::from_str("oci://hub.nationtech.io/harmony/ntfy").unwrap(),
-        chart_version: Some(NonBlankString::from_str("0.1.7").unwrap()),
+        chart_version: Some(NonBlankString::from_str("0.1.7-nationtech.1").unwrap()),
         values_overrides: None,
         values_yaml: Some(values.to_string()),
         create_namespace: true,
         install_only: false,
-        repository: Some(HelmRepository::new(
+        repository: None,
-            "sarab97".to_string(),
-            url::Url::parse("https://charts.sarabsingh.com").unwrap(),
-            true,
-        )),
     }
 }

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

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use log::debug;
+use log::info;
 use serde::Serialize;
 use strum::{Display, EnumString};
 
@@ -11,7 +11,7 @@ use crate::{
     inventory::Inventory,
     modules::monitoring::ntfy::helm::ntfy_helm_chart::ntfy_helm_chart_score,
     score::Score,
-    topology::{HelmCommand, K8sclient, Topology, k8s::K8sClient},
+    topology::{HelmCommand, K8sclient, MultiTargetTopology, Topology, k8s::K8sClient},
 };
 
 #[derive(Debug, Clone, Serialize)]
@@ -20,7 +20,7 @@ pub struct NtfyScore {
     pub host: String,
 }
 
-impl<T: Topology + HelmCommand + K8sclient> Score<T> for NtfyScore {
+impl<T: Topology + HelmCommand + K8sclient + MultiTargetTopology> Score<T> for NtfyScore {
     fn create_interpret(&self) -> Box<dyn Interpret<T>> {
         Box::new(NtfyInterpret {
             score: self.clone(),
@@ -77,7 +77,7 @@ impl NtfyInterpret {
                 vec![
                     "sh",
                     "-c",
-                    format!("NTFY_PASSWORD={password} ntfy user add --role={role} {username}")
+                    format!("NTFY_PASSWORD={password} ntfy user add --role={role} --ignore-exists {username}")
                         .as_str(),
                 ],
             )
@@ -89,22 +89,27 @@ impl NtfyInterpret {
 
 /// We need a ntfy interpret to wrap the HelmChartScore in order to run the score, and then bootstrap the config inside ntfy
 #[async_trait]
-impl<T: Topology + HelmCommand + K8sclient> Interpret<T> for NtfyInterpret {
+impl<T: Topology + HelmCommand + K8sclient + MultiTargetTopology> Interpret<T> for NtfyInterpret {
     async fn execute(
         &self,
         inventory: &Inventory,
         topology: &T,
     ) -> Result<Outcome, InterpretError> {
-        ntfy_helm_chart_score(self.score.namespace.clone(), self.score.host.clone())
+        ntfy_helm_chart_score(
-            .interpret(inventory, topology)
+            self.score.namespace.clone(),
-            .await?;
+            self.score.host.clone(),
+            topology.current_target(),
+        )
+        .interpret(inventory, topology)
+        .await?;
 
-        debug!("installed ntfy helm chart");
+        info!("installed ntfy helm chart");
         let client = topology
             .k8s_client()
             .await
             .expect("couldn't get k8s client");
 
+        info!("deploying ntfy...");
         client
             .wait_until_deployment_ready(
                 "ntfy".to_string(),
@@ -112,12 +117,12 @@ impl<T: Topology + HelmCommand + K8sclient> Interpret<T> for NtfyInterpret {
                 None,
             )
             .await?;
-        debug!("created k8s client");
+        info!("ntfy deployed");
 
+        info!("adding user harmony");
         self.add_user(client, "harmony", "harmony", Some(NtfyRole::Admin))
             .await?;
-
+        info!("user added");
-        debug!("exec into pod done");
 
         Ok(Outcome::success("Ntfy installed".to_string()))
     }

harmony/src/modules/prometheus/k8s_prometheus_alerting_score.rs

@@ -166,7 +166,8 @@ impl K8sPrometheusCRDAlertingInterpret {
 
         let install_output = Command::new("helm")
             .args([
-                "install",
+                "upgrade",
+                "--install",
                 &chart_name,
                 tgz_path.to_str().unwrap(),
                 "--namespace",

harmony_cli/Cargo.toml

@@ -5,6 +5,10 @@ version.workspace = true
 readme.workspace = true
 license.workspace = true
 
+[features]
+default = ["tui"]
+tui = ["dep:harmony_tui"]
+
 [dependencies]
 assert_cmd = "2.0.17"
 clap = { version = "4.5.35", features = ["derive"] }
@@ -18,8 +22,7 @@ indicatif = "0.18.0"
 lazy_static = "1.5.0"
 log.workspace = true
 indicatif-log-bridge = "0.2.3"
+chrono.workspace = true
 
-
+[dev-dependencies]
-[features]
+harmony = { path = "../harmony", features = ["testing"] }
-default = ["tui"]
-tui = ["dep:harmony_tui"]

harmony_cli/src/cli_logger.rs

@@ -1,16 +1,17 @@
+use chrono::Local;
+use console::style;
 use harmony::{
     instrumentation::{self, HarmonyEvent},
+    modules::application::ApplicationFeatureStatus,
     topology::TopologyStatus,
 };
-use indicatif::MultiProgress;
+use log::{error, info, log_enabled};
-use indicatif_log_bridge::LogWrapper;
+use std::io::Write;
 use std::sync::{Arc, Mutex};
 
-use crate::progress::{IndicatifProgressTracker, ProgressTracker};
-
 pub fn init() -> tokio::task::JoinHandle<()> {
-    let base_progress = configure_logger();
+    configure_logger();
-    let handle = tokio::spawn(handle_events(base_progress));
+    let handle = tokio::spawn(handle_events());
 
     loop {
         if instrumentation::instrument(HarmonyEvent::HarmonyStarted).is_ok() {
@@ -21,28 +22,76 @@ pub fn init() -> tokio::task::JoinHandle<()> {
     handle
 }
 
-fn configure_logger() -> MultiProgress {
+fn configure_logger() {
-    let logger =
+    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info"))
-        env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).build();
+        .format(|buf, record| {
-    let level = logger.filter();
+            let debug_mode = log_enabled!(log::Level::Debug);
-    let progress = MultiProgress::new();
+            let timestamp = Local::now().format("%Y-%m-%d %H:%M:%S");
 
-    LogWrapper::new(progress.clone(), logger)
+            let level = match record.level() {
-        .try_init()
+                log::Level::Error => style("ERROR").red(),
-        .unwrap();
+                log::Level::Warn => style("WARN").yellow(),
-    log::set_max_level(level);
+                log::Level::Info => style("INFO").green(),
-
+                log::Level::Debug => style("DEBUG").blue(),
-    progress
+                log::Level::Trace => style("TRACE").magenta(),
+            };
+            if let Some(status) = record.key_values().get(log::kv::Key::from("status")) {
+                let status = status.to_borrowed_str().unwrap();
+                let emoji = match status {
+                    "finished" => style(crate::theme::EMOJI_SUCCESS.to_string()).green(),
+                    "skipped" => style(crate::theme::EMOJI_SKIP.to_string()).yellow(),
+                    "failed" => style(crate::theme::EMOJI_ERROR.to_string()).red(),
+                    _ => style("".into()),
+                };
+                if debug_mode {
+                    writeln!(
+                        buf,
+                        "[{} {:<5} {}] {} {}",
+                        timestamp,
+                        level,
+                        record.target(),
+                        emoji,
+                        record.args()
+                    )
+                } else {
+                    writeln!(buf, "[{:<5}] {} {}", level, emoji, record.args())
+                }
+            } else if let Some(emoji) = record.key_values().get(log::kv::Key::from("emoji")) {
+                if debug_mode {
+                    writeln!(
+                        buf,
+                        "[{} {:<5} {}] {} {}",
+                        timestamp,
+                        level,
+                        record.target(),
+                        emoji,
+                        record.args()
+                    )
+                } else {
+                    writeln!(buf, "[{:<5}] {} {}", level, emoji, record.args())
+                }
+            } else if debug_mode {
+                writeln!(
+                    buf,
+                    "[{} {:<5} {}] {}",
+                    timestamp,
+                    level,
+                    record.target(),
+                    record.args()
+                )
+            } else {
+                writeln!(buf, "[{:<5}] {}", level, record.args())
+            }
+        })
+        .init();
 }
 
-async fn handle_events(base_progress: MultiProgress) {
+async fn handle_events() {
-    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);
 
@@ -53,89 +102,57 @@ async fn handle_events(base_progress: MultiProgress) {
                 match event {
                     HarmonyEvent::HarmonyStarted => {}
                     HarmonyEvent::HarmonyFinished => {
-                        progress_tracker.add_section(
+                        let emoji = crate::theme::EMOJI_HARMONY.to_string();
-                            "harmony-summary",
+                        info!(emoji = emoji.as_str(); "Harmony completed");
-                            &format!("\n{} Harmony completed\n\n", crate::theme::EMOJI_HARMONY),
-                        );
-                        progress_tracker.add_section("harmony-finished", "\n\n");
                         return false;
                     }
                     HarmonyEvent::TopologyStateChanged {
                         topology,
                         status,
                         message,
-                    } => {
+                    } => match status {
-                        let section_key = topology_key(&topology);
+                        TopologyStatus::Queued => {}
-
+                        TopologyStatus::Preparing => {
-                        match status {
+                            let emoji = format!("{}", style(crate::theme::EMOJI_TOPOLOGY.to_string()).yellow());
-                            TopologyStatus::Queued => {}
+                            info!(emoji = emoji.as_str(); "Preparing environment: {topology}...");
-                            TopologyStatus::Preparing => {
+                            (*preparing_topology) = true;
-                                progress_tracker.add_section(
+                        }
-                                    &section_key,
+                        TopologyStatus::Success => {
-                                    &format!(
+                            (*preparing_topology) = false;
-                                        "\n{} Preparing environment: {topology}...",
+                            if let Some(message) = message {
-                                        crate::theme::EMOJI_TOPOLOGY
+                                info!(status = "finished"; "{message}");
-                                    ),
-                                );
-                                (*preparing_topology) = true;
-                            }
-                            TopologyStatus::Success => {
-                                (*preparing_topology) = false;
-                                progress_tracker.add_task(&section_key, "topology-success", "");
-                                progress_tracker
-                                    .finish_task("topology-success", &message.unwrap_or("".into()));
-                            }
-                            TopologyStatus::Noop => {
-                                (*preparing_topology) = false;
-                                progress_tracker.add_task(&section_key, "topology-skip", "");
-                                progress_tracker
-                                    .skip_task("topology-skip", &message.unwrap_or("".into()));
-                            }
-                            TopologyStatus::Error => {
-                                progress_tracker.add_task(&section_key, "topology-error", "");
-                                (*preparing_topology) = false;
-                                progress_tracker
-                                    .fail_task("topology-error", &message.unwrap_or("".into()));
                             }
                         }
-                    }
+                        TopologyStatus::Noop => {
+                            (*preparing_topology) = false;
+                            if let Some(message) = message {
+                                info!(status = "skipped"; "{message}");
+                            }
+                        }
+                        TopologyStatus::Error => {
+                            (*preparing_topology) = false;
+                            if let Some(message) = message {
+                                error!(status = "failed"; "{message}");
+                            }
+                        }
+                    },
                     HarmonyEvent::InterpretExecutionStarted {
-                        execution_id: task_key,
+                        execution_id: _,
-                        topology,
+                        topology: _,
                         interpret: _,
                         score,
                         message,
                     } => {
-                        let is_key_topology = (*preparing_topology)
+                        if *preparing_topology || current_score.is_some() {
-                            && progress_tracker.contains_section(&topology_key(&topology));
+                            info!("{message}");
-                        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 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);
+                            let emoji = format!("{}", style(crate::theme::EMOJI_SCORE).blue());
-                            progress_tracker.add_section(
+                            info!(emoji = emoji.as_str(); "Interpreting score: {score}...");
-                                &key,
+                        }
-                                &format!(
-                                    "{} Interpreting score: {score}...",
-                                    crate::theme::EMOJI_SCORE
-                                ),
-                            );
-                            key
-                        };
-
-                        progress_tracker.add_task(&section_key, &task_key, &message);
                     }
                     HarmonyEvent::InterpretExecutionFinished {
-                        execution_id: task_key,
+                        execution_id: _,
                         topology: _,
                         interpret: _,
                         score,
@@ -148,18 +165,36 @@ async fn handle_events(base_progress: MultiProgress) {
                         match outcome {
                             Ok(outcome) => match outcome.status {
                                 harmony::interpret::InterpretStatus::SUCCESS => {
-                                    progress_tracker.finish_task(&task_key, &outcome.message);
+                                    info!(status = "finished"; "{}", outcome.message);
                                 }
                                 harmony::interpret::InterpretStatus::NOOP => {
-                                    progress_tracker.skip_task(&task_key, &outcome.message);
+                                    info!(status = "skipped"; "{}", outcome.message);
+                                }
+                                _ => {
+                                    error!(status = "failed"; "{}", outcome.message);
                                 }
-                                _ => progress_tracker.fail_task(&task_key, &outcome.message),
                             },
                             Err(err) => {
-                                progress_tracker.fail_task(&task_key, &err.to_string());
+                                error!(status = "failed"; "{}", err);
                             }
                         }
                     }
+                    HarmonyEvent::ApplicationFeatureStateChanged {
+                        topology: _,
+                        application,
+                        feature,
+                        status,
+                    } => match status {
+                        ApplicationFeatureStatus::Installing => {
+                            info!("Installing feature '{}' for '{}'...", feature, application);
+                        }
+                        ApplicationFeatureStatus::Installed => {
+                            info!(status = "finished"; "Feature '{}' installed", feature);
+                        }
+                        ApplicationFeatureStatus::Failed { details } => {
+                            error!(status = "failed"; "Feature '{}' installation failed: {}", feature, details);
+                        }
+                    },
                 }
                 true
             }
@@ -167,11 +202,3 @@ async fn handle_events(base_progress: MultiProgress) {
     })
     .await;
 }
-
-fn topology_key(topology: &str) -> String {
-    format!("topology-{topology}")
-}
-
-fn score_key(score: &str) -> String {
-    format!("score-{score}")
-}

harmony_cli/src/lib.rs

@@ -90,13 +90,37 @@ pub async fn run<T: Topology + Send + Sync + 'static>(
     topology: T,
     scores: Vec<Box<dyn Score<T>>>,
     args_struct: Option<Args>,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let args = match args_struct {
+        Some(args) => args,
+        None => Args::parse(),
+    };
+
+    #[cfg(not(feature = "tui"))]
+    if args.interactive {
+        return Err("Not compiled with interactive support".into());
+    }
+
+    #[cfg(feature = "tui")]
+    if args.interactive {
+        return harmony_tui::run(inventory, topology, scores).await;
+    }
+
+    run_cli(inventory, topology, scores, args).await
+}
+
+pub async fn run_cli<T: Topology + Send + Sync + 'static>(
+    inventory: Inventory,
+    topology: T,
+    scores: Vec<Box<dyn Score<T>>>,
+    args: Args,
 ) -> Result<(), Box<dyn std::error::Error>> {
     let cli_logger_handle = cli_logger::init();
 
     let mut maestro = Maestro::initialize(inventory, topology).await.unwrap();
     maestro.register_all(scores);
 
-    let result = init(maestro, args_struct).await;
+    let result = init(maestro, args).await;
 
     instrumentation::instrument(instrumentation::HarmonyEvent::HarmonyFinished).unwrap();
     let _ = tokio::try_join!(cli_logger_handle);
@@ -105,23 +129,8 @@ pub async fn run<T: Topology + Send + Sync + 'static>(
 
 async fn init<T: Topology + Send + Sync + 'static>(
     maestro: harmony::maestro::Maestro<T>,
-    args_struct: Option<Args>,
+    args: Args,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    let args = match args_struct {
-        Some(args) => args,
-        None => Args::parse(),
-    };
-
-    #[cfg(feature = "tui")]
-    if args.interactive {
-        return harmony_tui::init(maestro).await;
-    }
-
-    #[cfg(not(feature = "tui"))]
-    if args.interactive {
-        return Err("Not compiled with interactive support".into());
-    }
-
     let _ = env_logger::builder().try_init();
 
     let scores_vec = maestro_scores_filter(&maestro, args.all, args.filter, args.number);
@@ -132,8 +141,9 @@ async fn init<T: Topology + Send + Sync + 'static>(
 
     // if list option is specified, print filtered list and exit
     if args.list {
-        println!("Available scores:");
+        let num_scores = scores_vec.len();
-        println!("{}", list_scores_with_index(&scores_vec));
+        println!("Available scores {num_scores}:");
+        println!("{}\n\n", list_scores_with_index(&scores_vec));
         return Ok(());
     }
 
@@ -165,7 +175,7 @@ async fn init<T: Topology + Send + Sync + 'static>(
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
     use harmony::{
         inventory::Inventory,
         maestro::Maestro,
@@ -192,14 +202,14 @@ mod test {
         let maestro = init_test_maestro();
         let res = crate::init(
             maestro,
-            Some(crate::Args {
+            crate::Args {
                 yes: true,
                 filter: Some("SuccessScore".to_owned()),
                 interactive: false,
                 all: true,
                 number: 0,
                 list: false,
-            }),
+            },
         )
         .await;
 
@@ -212,14 +222,14 @@ mod test {
 
         let res = crate::init(
             maestro,
-            Some(crate::Args {
+            crate::Args {
                 yes: true,
                 filter: Some("ErrorScore".to_owned()),
                 interactive: false,
                 all: true,
                 number: 0,
                 list: false,
-            }),
+            },
         )
         .await;
 
@@ -232,14 +242,14 @@ mod test {
 
         let res = crate::init(
             maestro,
-            Some(crate::Args {
+            crate::Args {
                 yes: true,
                 filter: None,
                 interactive: false,
                 all: false,
                 number: 0,
                 list: false,
-            }),
+            },
         )
         .await;
 

harmony_cli/src/progress.rs

@@ -33,29 +33,13 @@ pub struct IndicatifProgressTracker {
 
 impl IndicatifProgressTracker {
     pub fn new(base: MultiProgress) -> Self {
-        // The indicatif log bridge will insert a progress bar at the top.
+        let sections = HashMap::new();
-        // To prevent our first section from being erased, we need to create
+        let tasks = HashMap::new();
-        // a dummy progress bar as our first progress bar.
-        let _ = base.clear();
-        let log_pb = base.add(ProgressBar::new(1));
-
-        let mut sections = HashMap::new();
-        sections.insert(
-            "__log__".into(),
-            Section {
-                header_index: 0,
-                task_count: 0,
-                pb: log_pb.clone(),
-            },
-        );
-
-        let mut tasks = HashMap::new();
-        tasks.insert("__log__".into(), log_pb);
 
         let state = Arc::new(Mutex::new(IndicatifProgressTrackerState {
             sections,
             tasks,
-            pb_count: 1,
+            pb_count: 0,
         }));
 
         Self { mp: base, state }

harmony_cli/src/theme.rs

@@ -21,10 +21,14 @@ lazy_static! {
     pub static ref SUCCESS_SPINNER_STYLE: ProgressStyle = SPINNER_STYLE
         .clone()
         .tick_strings(&[format!("{}", EMOJI_SUCCESS).as_str()]);
-    pub static ref SKIP_SPINNER_STYLE: ProgressStyle = SPINNER_STYLE
+    pub static ref SKIP_SPINNER_STYLE: ProgressStyle = ProgressStyle::default_spinner()
+        .template("    {spinner:.orange} {wide_msg}")
+        .unwrap()
         .clone()
         .tick_strings(&[format!("{}", EMOJI_SKIP).as_str()]);
-    pub static ref ERROR_SPINNER_STYLE: ProgressStyle = SPINNER_STYLE
+    pub static ref ERROR_SPINNER_STYLE: ProgressStyle = ProgressStyle::default_spinner()
+        .template("    {spinner:.red} {wide_msg}")
+        .unwrap()
         .clone()
         .tick_strings(&[format!("{}", EMOJI_ERROR).as_str()]);
 }

harmony_composer/src/harmony_composer_logger.rs

@@ -1,6 +1,5 @@
 use harmony_cli::progress::{IndicatifProgressTracker, ProgressTracker};
 use indicatif::MultiProgress;
-use log::error;
 use std::sync::Arc;
 
 use crate::instrumentation::{self, HarmonyComposerEvent};
@@ -53,15 +52,13 @@ pub async fn handle_events() {
                         progress_tracker.finish_task(COMPILTATION_TASK, "project compiled");
                     }
                     HarmonyComposerEvent::ProjectCompilationFailed { details } => {
-                        progress_tracker.fail_task(COMPILTATION_TASK, "failed to compile project");
+                        progress_tracker.fail_task(COMPILTATION_TASK, &format!("failed to compile project:\n{details}"));
-
-                        error!("{details}");
                     }
-                    HarmonyComposerEvent::DeploymentStarted { target } => {
+                    HarmonyComposerEvent::DeploymentStarted { target, profile } => {
                         progress_tracker.add_section(
                             PROGRESS_DEPLOYMENT,
                             &format!(
-                                "\n{} Deploying project to {target}...\n",
+                                "\n{} Deploying project on target '{target}' with profile '{profile}'...\n",
                                 harmony_cli::theme::EMOJI_DEPLOY,
                             ),
                         );
@@ -69,6 +66,10 @@ pub async fn handle_events() {
                     HarmonyComposerEvent::DeploymentCompleted => {
                         progress_tracker.clear();
                     }
+                    HarmonyComposerEvent::DeploymentFailed { details } => {
+                        progress_tracker.add_task(PROGRESS_DEPLOYMENT, "deployment-failed", "");
+                        progress_tracker.fail_task("deployment-failed", &details);
+                    },
                     HarmonyComposerEvent::Shutdown => {
                         return false;
                     }

harmony_composer/src/instrumentation.rs

@@ -2,16 +2,28 @@ use log::debug;
 use once_cell::sync::Lazy;
 use tokio::sync::broadcast;
 
+use crate::{HarmonyProfile, HarmonyTarget};
+
 #[derive(Debug, Clone)]
 pub enum HarmonyComposerEvent {
     HarmonyComposerStarted,
     ProjectInitializationStarted,
     ProjectInitialized,
-    ProjectCompilationStarted { details: String },
+    ProjectCompilationStarted {
+        details: String,
+    },
     ProjectCompiled,
-    ProjectCompilationFailed { details: String },
+    ProjectCompilationFailed {
-    DeploymentStarted { target: String },
+        details: String,
+    },
+    DeploymentStarted {
+        target: HarmonyTarget,
+        profile: HarmonyProfile,
+    },
     DeploymentCompleted,
+    DeploymentFailed {
+        details: String,
+    },
     Shutdown,
 }
 
@@ -23,9 +35,18 @@ static HARMONY_COMPOSER_EVENT_BUS: Lazy<broadcast::Sender<HarmonyComposerEvent>>
     });
 
 pub fn instrument(event: HarmonyComposerEvent) -> Result<(), &'static str> {
-    match HARMONY_COMPOSER_EVENT_BUS.send(event) {
+    #[cfg(not(test))]
-        Ok(_) => Ok(()),
+    {
-        Err(_) => Err("send error: no subscribers"),
+        match HARMONY_COMPOSER_EVENT_BUS.send(event) {
+            Ok(_) => Ok(()),
+            Err(_) => Err("send error: no subscribers"),
+        }
+    }
+
+    #[cfg(test)]
+    {
+        let _ = event; // Suppress the "unused variable" warning for `event`
+        Ok(())
     }
 }
 

harmony_composer/src/main.rs

@@ -49,14 +49,11 @@ struct CheckArgs {
 
 #[derive(Args, Clone, Debug)]
 struct DeployArgs {
-    #[arg(long, default_value_t = false)]
+    #[arg(long = "target", short = 't', default_value = "local")]
-    staging: bool,
+    harmony_target: HarmonyTarget,
 
-    #[arg(long, default_value_t = false)]
+    #[arg(long = "profile", short = 'p', default_value = "dev")]
-    prod: bool,
+    harmony_profile: HarmonyProfile,
-
-    #[arg(long, default_value_t = false)]
-    smoke_test: bool,
 }
 
 #[derive(Args, Clone, Debug)]
@@ -68,6 +65,38 @@ struct AllArgs {
     deploy: DeployArgs,
 }
 
+#[derive(Clone, Debug, clap::ValueEnum)]
+enum HarmonyTarget {
+    Local,
+    Remote,
+}
+
+impl std::fmt::Display for HarmonyTarget {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            HarmonyTarget::Local => f.write_str("local"),
+            HarmonyTarget::Remote => f.write_str("remote"),
+        }
+    }
+}
+
+#[derive(Clone, Debug, clap::ValueEnum)]
+enum HarmonyProfile {
+    Dev,
+    Staging,
+    Production,
+}
+
+impl std::fmt::Display for HarmonyProfile {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            HarmonyProfile::Dev => f.write_str("dev"),
+            HarmonyProfile::Staging => f.write_str("staging"),
+            HarmonyProfile::Production => f.write_str("production"),
+        }
+    }
+}
+
 #[tokio::main]
 async fn main() {
     let hc_logger_handle = harmony_composer_logger::init();
@@ -122,26 +151,39 @@ async fn main() {
                 );
             }
             Commands::Deploy(args) => {
-                let deploy = if args.staging {
+                instrumentation::instrument(HarmonyComposerEvent::DeploymentStarted {
-                    instrumentation::instrument(HarmonyComposerEvent::DeploymentStarted {
+                    target: args.harmony_target.clone(),
-                        target: "staging".to_string(),
+                    profile: args.harmony_profile.clone(),
-                    })
+                })
-                    .unwrap();
+                .unwrap();
-                    todo!("implement staging deployment")
+
-                } else if args.prod {
+                if matches!(args.harmony_profile, HarmonyProfile::Dev)
-                    instrumentation::instrument(HarmonyComposerEvent::DeploymentStarted {
+                    && !matches!(args.harmony_target, HarmonyTarget::Local)
-                        target: "prod".to_string(),
+                {
-                    })
+                    instrumentation::instrument(HarmonyComposerEvent::DeploymentFailed {
-                    .unwrap();
+                        details: format!(
-                    todo!("implement prod deployment")
+                            "Cannot run profile '{}' on target '{}'. Profile '{}' can run locally only.",
-                } else {
+                            args.harmony_profile, args.harmony_target, args.harmony_profile
-                    instrumentation::instrument(HarmonyComposerEvent::DeploymentStarted {
+                        ),
-                        target: "dev".to_string(),
+                    }).unwrap();
-                    })
+                    return;
-                    .unwrap();
-                    Command::new(harmony_bin_path).arg("-y").arg("-a").spawn()
                 }
-                .expect("failed to run harmony deploy");
+
+                let use_local_k3d = match args.harmony_target {
+                    HarmonyTarget::Local => true,
+                    HarmonyTarget::Remote => false,
+                };
+
+                let mut command = Command::new(harmony_bin_path);
+                command
+                    .env("HARMONY_USE_LOCAL_K3D", format!("{use_local_k3d}"))
+                    .env("HARMONY_PROFILE", format!("{}", args.harmony_profile))
+                    .arg("-y")
+                    .arg("-a");
+
+                info!("{:?}", command);
+
+                let deploy = command.spawn().expect("failed to run harmony deploy");
 
                 let deploy_output = deploy.wait_with_output().unwrap();
                 debug!("{}", String::from_utf8(deploy_output.stdout).unwrap());

harmony_tui/src/lib.rs

@@ -9,7 +9,13 @@ use widget::{help::HelpWidget, score::ScoreListWidget};
 use std::{panic, sync::Arc, time::Duration};
 
 use crossterm::event::{Event, EventStream, KeyCode, KeyEventKind};
-use harmony::{maestro::Maestro, score::Score, topology::Topology};
+use harmony::{
+    instrumentation::{self, HarmonyEvent},
+    inventory::Inventory,
+    maestro::Maestro,
+    score::Score,
+    topology::Topology,
+};
 use ratatui::{
     self, Frame,
     layout::{Constraint, Layout, Position},
@@ -39,22 +45,62 @@ pub mod tui {
 ///
 /// #[tokio::main]
 /// async fn main() {
-///     let inventory = Inventory::autoload();
+///     harmony_tui::run(
-///     let topology = HAClusterTopology::autoload();
+///         Inventory::autoload(),
-///     let mut maestro = Maestro::new_without_initialization(inventory, topology);
+///         HAClusterTopology::autoload(),
-///
+///         vec![
-///     maestro.register_all(vec![
+///             Box::new(SuccessScore {}),
-///         Box::new(SuccessScore {}),
+///             Box::new(ErrorScore {}),
-///         Box::new(ErrorScore {}),
+///             Box::new(PanicScore {}),
-///         Box::new(PanicScore {}),
+///         ]
-///     ]);
+///     ).await.unwrap();
-///     harmony_tui::init(maestro).await.unwrap();
 /// }
 /// ```
-pub async fn init<T: Topology + Send + Sync + 'static>(
+pub async fn run<T: Topology + Send + Sync + 'static>(
+    inventory: Inventory,
+    topology: T,
+    scores: Vec<Box<dyn Score<T>>>,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let handle = init_instrumentation().await;
+
+    let mut maestro = Maestro::initialize(inventory, topology).await.unwrap();
+    maestro.register_all(scores);
+
+    let result = init(maestro).await;
+
+    let _ = tokio::try_join!(handle);
+    result
+}
+
+async fn init<T: Topology + Send + Sync + 'static>(
     maestro: Maestro<T>,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    HarmonyTUI::new(maestro).init().await
+    let result = HarmonyTUI::new(maestro).init().await;
+
+    instrumentation::instrument(HarmonyEvent::HarmonyFinished).unwrap();
+    result
+}
+
+async fn init_instrumentation() -> tokio::task::JoinHandle<()> {
+    let handle = tokio::spawn(handle_harmony_events());
+
+    loop {
+        if instrumentation::instrument(HarmonyEvent::HarmonyStarted).is_ok() {
+            break;
+        }
+    }
+
+    handle
+}
+
+async fn handle_harmony_events() {
+    instrumentation::subscribe("Harmony TUI Logger", async |event| {
+        if let HarmonyEvent::HarmonyFinished = event {
+            return false;
+        };
+        true
+    })
+    .await;
 }
 
 pub struct HarmonyTUI<T: Topology> {