group related scores together

.gitea/workflows/check.yml

@@ -9,7 +9,7 @@ jobs:
   check:
     runs-on: docker
     container:
-      image: hub.nationtech.io/harmony/harmony_composer:latest
+      image: hub.nationtech.io/harmony/harmony_composer:latest@sha256:eb0406fcb95c63df9b7c4b19bc50ad7914dd8232ce98e9c9abef628e07c69386
     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
+      image: hub.nationtech.io/harmony/harmony_composer:latest@sha256:eb0406fcb95c63df9b7c4b19bc50ad7914dd8232ce98e9c9abef628e07c69386
     runs-on: dind
     steps:
       - name: Checkout code

examples/remove_rook_osd/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "example_remove_rook_osd"
-edition = "2024"
-version.workspace = true
-readme.workspace = true
-license.workspace = true
-
-[dependencies]
-harmony = { version = "0.1.0", path = "../../harmony" }
-harmony_cli = { version = "0.1.0", path = "../../harmony_cli" }
-harmony_tui = { version = "0.1.0", path = "../../harmony_tui" }
-tokio.workspace = true

examples/remove_rook_osd/src/main.rs

@@ -1,18 +0,0 @@
-use harmony::{
-    inventory::Inventory, modules::storage::ceph::ceph_remove_osd_score::CephRemoveOsd,
-    topology::K8sAnywhereTopology,
-};
-
-#[tokio::main]
-async fn main() {
-    let ceph_score = CephRemoveOsd {
-        osd_deployment_name: "rook-ceph-osd-2".to_string(),
-        rook_ceph_namespace: "rook-ceph".to_string(),
-    };
-
-    let topology = K8sAnywhereTopology::from_env();
-    let inventory = Inventory::autoload();
-    harmony_cli::run(inventory, topology, vec![Box::new(ceph_score)], None)
-        .await
-        .unwrap();
-}

harmony/Cargo.toml

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

harmony/src/domain/instrumentation.rs

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

harmony/src/domain/topology/k8s.rs

@@ -5,7 +5,7 @@ use k8s_openapi::{
 };
 use kube::{
     Client, Config, Error, Resource,
-    api::{Api, AttachParams, DeleteParams, ListParams, Patch, PatchParams, ResourceExt},
+    api::{Api, AttachParams, ListParams, Patch, PatchParams, ResourceExt},
     config::{KubeConfigOptions, Kubeconfig},
     core::ErrorResponse,
     runtime::reflector::Lookup,
@@ -17,9 +17,7 @@ use kube::{
 };
 use log::{debug, error, trace};
 use serde::{Serialize, de::DeserializeOwned};
-use serde_json::json;
 use similar::TextDiff;
-use tokio::io::AsyncReadExt;
 
 #[derive(new, Clone)]
 pub struct K8sClient {
@@ -53,66 +51,6 @@ impl K8sClient {
         })
     }
 
-    pub async fn get_deployment(
-        &self,
-        name: &str,
-        namespace: Option<&str>,
-    ) -> Result<Option<Deployment>, Error> {
-        let deps: Api<Deployment> = if let Some(ns) = namespace {
-            Api::namespaced(self.client.clone(), ns)
-        } else {
-            Api::default_namespaced(self.client.clone())
-        };
-        Ok(deps.get_opt(name).await?)
-    }
-
-    pub async fn get_pod(&self, name: &str, namespace: Option<&str>) -> Result<Option<Pod>, Error> {
-        let pods: Api<Pod> = if let Some(ns) = namespace {
-            Api::namespaced(self.client.clone(), ns)
-        } else {
-            Api::default_namespaced(self.client.clone())
-        };
-        Ok(pods.get_opt(name).await?)
-    }
-
-    pub async fn scale_deployment(
-        &self,
-        name: &str,
-        namespace: Option<&str>,
-        replicas: u32,
-    ) -> Result<(), Error> {
-        let deployments: Api<Deployment> = if let Some(ns) = namespace {
-            Api::namespaced(self.client.clone(), ns)
-        } else {
-            Api::default_namespaced(self.client.clone())
-        };
-
-        let patch = json!({
-            "spec": {
-                "replicas": replicas
-            }
-        });
-        let pp = PatchParams::default();
-        let scale = Patch::Apply(&patch);
-        deployments.patch_scale(name, &pp, &scale).await?;
-        Ok(())
-    }
-
-    pub async fn delete_deployment(
-        &self,
-        name: &str,
-        namespace: Option<&str>,
-    ) -> Result<(), Error> {
-        let deployments: Api<Deployment> = if let Some(ns) = namespace {
-            Api::namespaced(self.client.clone(), ns)
-        } else {
-            Api::default_namespaced(self.client.clone())
-        };
-        let delete_params = DeleteParams::default();
-        deployments.delete(name, &delete_params).await?;
-        Ok(())
-    }
-
     pub async fn wait_until_deployment_ready(
         &self,
         name: String,
@@ -138,68 +76,6 @@ impl K8sClient {
         }
     }
 
-    /// Will execute a commond in the first pod found that matches the specified label
-    /// '{label}={name}'
-    pub async fn exec_app_capture_output(
-        &self,
-        name: String,
-        label: String,
-        namespace: Option<&str>,
-        command: Vec<&str>,
-    ) -> Result<String, String> {
-        let api: Api<Pod>;
-
-        if let Some(ns) = namespace {
-            api = Api::namespaced(self.client.clone(), ns);
-        } else {
-            api = Api::default_namespaced(self.client.clone());
-        }
-        let pod_list = api
-            .list(&ListParams::default().labels(format!("{label}={name}").as_str()))
-            .await
-            .expect("couldn't get list of pods");
-
-        let res = api
-            .exec(
-                pod_list
-                    .items
-                    .first()
-                    .expect("couldn't get pod")
-                    .name()
-                    .expect("couldn't get pod name")
-                    .into_owned()
-                    .as_str(),
-                command,
-                &AttachParams::default().stdout(true).stderr(true),
-            )
-            .await;
-        match res {
-            Err(e) => Err(e.to_string()),
-            Ok(mut process) => {
-                let status = process
-                    .take_status()
-                    .expect("Couldn't get status")
-                    .await
-                    .expect("Couldn't unwrap status");
-
-                if let Some(s) = status.status {
-                    let mut stdout_buf = String::new();
-                    if let Some(mut stdout) = process.stdout().take() {
-                        stdout.read_to_string(&mut stdout_buf).await;
-                    }
-                    debug!("Status: {} - {:?}", s, status.details);
-                    if s == "Success" {
-                        Ok(stdout_buf)
-                    } else {
-                        Err(s)
-                    }
-                } else {
-                    Err("Couldn't get inner status of pod exec".to_string())
-                }
-            }
-        }
-    }
-
     /// Will execute a command in the first pod found that matches the label `app.kubernetes.io/name={name}`
     pub async fn exec_app(
         &self,
@@ -244,7 +120,7 @@ impl K8sClient {
                     .expect("Couldn't unwrap status");
 
                 if let Some(s) = status.status {
-                    debug!("Status: {} - {:?}", s, status.details);
+                    debug!("Status: {}", s);
                     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,13 +28,7 @@ use super::{
     PreparationOutcome, Topology,
     k8s::K8sClient,
     oberservability::monitoring::AlertReceiver,
-    tenant::{
+    tenant::{TenantConfig, TenantManager, k8s::K8sTenantManager},
-        TenantConfig, TenantManager,
-        k8s::K8sTenantManager,
-        network_policy::{
-            K3dNetworkPolicyStrategy, NetworkPolicyStrategy, NoopNetworkPolicyStrategy,
-        },
-    },
 };
 
 #[derive(Clone, Debug)]
@@ -256,21 +250,16 @@ impl K8sAnywhereTopology {
         Ok(Some(state))
     }
 
-    async fn ensure_k8s_tenant_manager(&self, k8s_state: &K8sState) -> Result<(), String> {
+    async fn ensure_k8s_tenant_manager(&self) -> 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?;
-                let network_policy_strategy: Box<dyn NetworkPolicyStrategy> = match k8s_state.source
+                Ok(K8sTenantManager::new(k8s_client))
-                {
-                    K8sSource::LocalK3d => Box::new(K3dNetworkPolicyStrategy::new()),
-                    K8sSource::Kubeconfig => Box::new(NoopNetworkPolicyStrategy::new()),
-                };
-
-                Ok(K8sTenantManager::new(k8s_client, network_policy_strategy))
             })
             .await?;
 
@@ -401,7 +390,7 @@ impl Topology for K8sAnywhereTopology {
             "no K8s client could be found or installed".to_string(),
         ))?;
 
-        self.ensure_k8s_tenant_manager(k8s_state)
+        self.ensure_k8s_tenant_manager()
             .await
             .map_err(PreparationError::new)?;
 

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

@@ -20,27 +20,24 @@ use serde::de::DeserializeOwned;
 use serde_json::json;
 use tokio::sync::OnceCell;
 
-use super::{TenantConfig, TenantManager, network_policy::NetworkPolicyStrategy};
+use super::{TenantConfig, TenantManager};
 
-#[derive(Debug)]
+#[derive(Clone, 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(
+    pub fn new(client: Arc<K8sClient>) -> Self {
-        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()
     }
@@ -221,6 +218,29 @@ 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": [
                   {
@@ -390,27 +410,12 @@ 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;
-pub mod network_policy;
+use std::str::FromStr;
 
-use crate::data::Id;
 pub use manager::*;
 use serde::{Deserialize, Serialize};
-use std::str::FromStr;
+
+use crate::data::Id;
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] // Assuming serde for Scores
 pub struct TenantConfig {

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

@@ -1,120 +0,0 @@
-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::info;
+use log::{debug, error};
 use serde_yaml::Value;
 use tempfile::NamedTempFile;
 
@@ -56,11 +56,14 @@ impl<A: OCICompliant + HelmPackage> ContinuousDelivery<A> {
         chart_url: String,
         image_name: String,
     ) -> Result<(), String> {
-        // TODO: This works only with local k3d installations, which is fine only for current demo purposes. We assume usage of K8sAnywhereTopology"
+        error!(
-        // https://git.nationtech.io/NationTech/harmony/issues/106
+            "FIXME This works only with local k3d installations, which is fine only for current demo purposes. We assume usage of K8sAnywhereTopology"
+        );
+
+        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 ---
-        info!(
+        debug!(
             "Importing image '{}' into k3d cluster 'harmony'",
             image_name
         );
@@ -77,7 +80,7 @@ impl<A: OCICompliant + HelmPackage> ContinuousDelivery<A> {
         }
 
         // --- 2. Get the kubeconfig for the k3d cluster and write it to a temp file ---
-        info!("Retrieving kubeconfig for k3d cluster 'harmony'");
+        debug!("Retrieving kubeconfig for k3d cluster 'harmony'");
         let kubeconfig_output = Command::new(&k3d_bin_path)
             .args(["kubeconfig", "get", "harmony"])
             .output()
@@ -98,7 +101,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 ---
-        info!(
+        debug!(
             "Deploying Helm chart '{}' to namespace '{}'",
             chart_url, app_name
         );
@@ -128,7 +131,7 @@ impl<A: OCICompliant + HelmPackage> ContinuousDelivery<A> {
             ));
         }
 
-        info!("Successfully deployed '{}' to local k3d cluster.", app_name);
+        debug!("Successfully deployed '{}' to local k3d cluster.", app_name);
         Ok(())
     }
 }
@@ -148,12 +151,14 @@ 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}");
 
-        // TODO: Make building image configurable/skippable if image already exists (prompt)")
+        error!("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}");
 
-        // TODO: this is a temporary hack for demo purposes, the deployment target should be driven
+        debug!("Installing ContinuousDelivery feature");
+        // 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.
         //
@@ -166,20 +171,17 @@ 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 => {
-                info!("Deploying {} to target {target:?}", self.application.name());
+                debug!("Deploying to target {target:?}");
                 let score = ArgoHelmScore {
-                    namespace: "harmony-example-rust-webapp".to_string(),
+                    namespace: "harmonydemo-staging".to_string(),
-                    openshift: true,
+                    openshift: false,
-                    domain: "argo.harmonydemo.apps.ncd0.harmony.mcd".to_string(),
+                    domain: "argo.harmonydemo.apps.st.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(),
@@ -187,7 +189,7 @@ impl<
                         helm_chart_name: "harmony-example-rust-webapp-chart".to_string(),
                         values_overrides: None,
                         name: "harmony-demo-rust-webapp".to_string(),
-                        namespace: "harmony-example-rust-webapp".to_string(),
+                        namespace: "harmonydemo-staging".to_string(),
                     })],
                 };
                 score

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

@@ -1,4 +1,5 @@
 use async_trait::async_trait;
+use log::error;
 use non_blank_string_rs::NonBlankString;
 use serde::Serialize;
 use std::str::FromStr;
@@ -49,6 +50,7 @@ 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?;
@@ -56,14 +58,9 @@ 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 {} {}",
+            "ArgoCD installed with {} applications",
-            self.argo_apps.len(),
+            self.argo_apps.len()
-            match self.argo_apps.len() {
-                1 => "application",
-                _ => "applications",
-            }
         )))
     }
 

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

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

harmony/src/modules/application/mod.rs

@@ -14,19 +14,11 @@ 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;
 }
@@ -55,34 +47,13 @@ impl<A: Application, T: Topology + std::fmt::Debug> Interpret<T> for Application
                 .join(", ")
         );
         for feature in self.features.iter() {
-            instrumentation::instrument(HarmonyEvent::ApplicationFeatureStateChanged {
+            debug!(
-                topology: topology.name().into(),
+                "Installing feature {} for application {app_name}",
-                application: self.application.name(),
+                feature.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, info, log_enabled};
+use log::{debug, error, 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> {
-        info!("Starting Helm chart build and push for '{}'", self.name);
+        debug!("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))?;
-        info!("Successfully created Helm chart files in {:?}", chart_dir);
+        debug!("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))?;
-        info!(
+        debug!(
             "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))?;
-        info!("Successfully pushed Helm chart to: {}", oci_chart_url);
+        debug!("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.
-        info!("Starting OCI image build and push for '{}'", self.name);
+        debug!("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))?;
-        info!("Successfully built Docker image: {}", image_tag);
+        debug!("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))?;
-        info!("Successfully pushed Docker image to: {}", image_tag);
+        debug!("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 {
-            debug!("Message: {msg:?}");
+            println!("Message: {msg:?}");
         }
 
         Ok(image_name.to_string())
@@ -219,7 +219,7 @@ impl RustWebapp {
         );
 
         while let Some(msg) = push_image_stream.next().await {
-            debug!("Message: {msg:?}");
+            println!("Message: {msg:?}");
         }
 
         Ok(image_tag.to_string())
@@ -288,8 +288,9 @@ impl RustWebapp {
                         .unwrap(),
                 );
                 // Copy the compiled binary from the builder stage.
-                // TODO: Should not be using score name here, instead should use name from Cargo.toml
+                error!(
-                // https://git.nationtech.io/NationTech/harmony/issues/105
+                    "FIXME Should not be using score name here, instead should use name from Cargo.toml"
+                );
                 let binary_path_in_builder = format!("/app/target/release/{}", self.name);
                 let binary_path_in_final = format!("/home/appuser/{}", self.name);
                 dockerfile.push(
@@ -327,8 +328,9 @@ impl RustWebapp {
                 ));
 
                 // Copy only the compiled binary from the builder stage.
-                // TODO: Should not be using score name here, instead should use name from Cargo.toml
+                error!(
-                // https://git.nationtech.io/NationTech/harmony/issues/105
+                    "FIXME Should not be using score name here, instead should use name from Cargo.toml"
+                );
                 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 Interpret<T>> {
+    fn create_interpret(&self) -> Box<dyn crate::interpret::Interpret<T>> {
         Box::new(K3dInstallationInterpret {
             score: self.clone(),
         })

harmony/src/modules/mod.rs

@@ -14,6 +14,5 @@ pub mod monitoring;
 pub mod okd;
 pub mod opnsense;
 pub mod prometheus;
-pub mod storage;
 pub mod tenant;
 pub mod tftp;

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

@@ -1,25 +1,9 @@
 use non_blank_string_rs::NonBlankString;
 use std::str::FromStr;
 
-use crate::{modules::helm::chart::HelmChartScore, topology::DeploymentTarget};
+use crate::modules::helm::chart::{HelmChartScore, HelmRepository};
-
-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
@@ -41,14 +25,23 @@ serviceAccount:
 
 service:
   type: ClusterIP
-  port: 8080
+  port: 80
 
 ingress:
-  enabled: {ingress_enabled}
+  enabled: true
+#  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
@@ -56,7 +49,7 @@ autoscaling:
 config:
   enabled: true
   data:
-    base-url: "https://{host}"
+#    base-url: "https://ntfy.something.com"
     auth-file: "/var/cache/ntfy/user.db"
     auth-default-access: "deny-all"
     cache-file: "/var/cache/ntfy/cache.db"
@@ -66,7 +59,6 @@ config:
     enable-signup: false
     enable-login: "true"
     enable-metrics: "true"
-    listen-http: ":8080"
 
 persistence:
   enabled: true
@@ -77,12 +69,16 @@ persistence:
     HelmChartScore {
         namespace: Some(NonBlankString::from_str(&namespace).unwrap()),
         release_name: NonBlankString::from_str("ntfy").unwrap(),
-        chart_name: NonBlankString::from_str("oci://hub.nationtech.io/harmony/ntfy").unwrap(),
+        chart_name: NonBlankString::from_str("sarab97/ntfy").unwrap(),
-        chart_version: Some(NonBlankString::from_str("0.1.7-nationtech.1").unwrap()),
+        chart_version: Some(NonBlankString::from_str("0.1.7").unwrap()),
         values_overrides: None,
         values_yaml: Some(values.to_string()),
         create_namespace: true,
         install_only: false,
-        repository: None,
+        repository: Some(HelmRepository::new(
+            "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::info;
+use log::debug;
 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, MultiTargetTopology, Topology, k8s::K8sClient},
+    topology::{HelmCommand, K8sclient, Topology, k8s::K8sClient},
 };
 
 #[derive(Debug, Clone, Serialize)]
@@ -20,7 +20,7 @@ pub struct NtfyScore {
     pub host: String,
 }
 
-impl<T: Topology + HelmCommand + K8sclient + MultiTargetTopology> Score<T> for NtfyScore {
+impl<T: Topology + HelmCommand + K8sclient> 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} --ignore-exists {username}")
+                    format!("NTFY_PASSWORD={password} ntfy user add --role={role} {username}")
                         .as_str(),
                 ],
             )
@@ -89,27 +89,22 @@ 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 + MultiTargetTopology> Interpret<T> for NtfyInterpret {
+impl<T: Topology + HelmCommand + K8sclient> Interpret<T> for NtfyInterpret {
     async fn execute(
         &self,
         inventory: &Inventory,
         topology: &T,
     ) -> Result<Outcome, InterpretError> {
-        ntfy_helm_chart_score(
+        ntfy_helm_chart_score(self.score.namespace.clone(), self.score.host.clone())
-            self.score.namespace.clone(),
+            .interpret(inventory, topology)
-            self.score.host.clone(),
+            .await?;
-            topology.current_target(),
-        )
-        .interpret(inventory, topology)
-        .await?;
 
-        info!("installed ntfy helm chart");
+        debug!("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(),
@@ -117,12 +112,12 @@ impl<T: Topology + HelmCommand + K8sclient + MultiTargetTopology> Interpret<T> f
                 None,
             )
             .await?;
-        info!("ntfy deployed");
+        debug!("created k8s client");
 
-        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,8 +166,7 @@ impl K8sPrometheusCRDAlertingInterpret {
 
         let install_output = Command::new("helm")
             .args([
-                "upgrade",
+                "install",
-                "--install",
                 &chart_name,
                 tgz_path.to_str().unwrap(),
                 "--namespace",

harmony/src/modules/storage/ceph/ceph_remove_osd_score.rs

@@ -1,419 +0,0 @@
-use std::{
-    process::Command,
-    sync::Arc,
-    time::{Duration, Instant},
-};
-
-use async_trait::async_trait;
-use log::{info, warn};
-use serde::{Deserialize, Serialize};
-use tokio::time::sleep;
-
-use crate::{
-    data::{Id, Version},
-    interpret::{Interpret, InterpretError, InterpretName, InterpretStatus, Outcome},
-    inventory::Inventory,
-    score::Score,
-    topology::{K8sclient, Topology, k8s::K8sClient},
-};
-
-#[derive(Debug, Clone, Serialize)]
-pub struct CephRemoveOsd {
-    pub osd_deployment_name: String,
-    pub rook_ceph_namespace: String,
-}
-
-impl<T: Topology + K8sclient> Score<T> for CephRemoveOsd {
-    fn name(&self) -> String {
-        format!("CephRemoveOsdScore")
-    }
-
-    #[doc(hidden)]
-    fn create_interpret(&self) -> Box<dyn Interpret<T>> {
-        Box::new(CephRemoveOsdInterpret {
-            score: self.clone(),
-        })
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct CephRemoveOsdInterpret {
-    score: CephRemoveOsd,
-}
-
-#[async_trait]
-impl<T: Topology + K8sclient> Interpret<T> for CephRemoveOsdInterpret {
-    async fn execute(
-        &self,
-        _inventory: &Inventory,
-        topology: &T,
-    ) -> Result<Outcome, InterpretError> {
-        let client = topology.k8s_client().await.unwrap();
-        self.verify_ceph_toolbox_exists(client.clone()).await?;
-        self.scale_deployment(client.clone()).await?;
-        self.verify_deployment_scaled(client.clone()).await?;
-        self.delete_deployment(client.clone()).await?;
-        self.verify_deployment_deleted(client.clone()).await?;
-        let osd_id_full = self.get_ceph_osd_id().unwrap();
-        self.purge_ceph_osd(client.clone(), &osd_id_full).await?;
-        self.verify_ceph_osd_removal(client.clone(), &osd_id_full)
-            .await?;
-
-        Ok(Outcome::success(format!(
-            "Successfully removed OSD {} from rook-ceph cluster by deleting deployment {}",
-            osd_id_full, self.score.osd_deployment_name
-        )))
-    }
-    fn get_name(&self) -> InterpretName {
-        todo!()
-    }
-
-    fn get_version(&self) -> Version {
-        todo!()
-    }
-
-    fn get_status(&self) -> InterpretStatus {
-        todo!()
-    }
-
-    fn get_children(&self) -> Vec<Id> {
-        todo!()
-    }
-}
-
-impl CephRemoveOsdInterpret {
-    pub fn get_ceph_osd_id(&self) -> Result<String, InterpretError> {
-        let osd_id_numeric = self
-            .score
-            .osd_deployment_name
-            .split('-')
-            .nth(3)
-            .ok_or_else(|| {
-                InterpretError::new(format!(
-                    "Could not parse OSD id from deployment name {}",
-                    self.score.osd_deployment_name
-                ))
-            })?;
-        let osd_id_full = format!("osd.{}", osd_id_numeric);
-
-        info!(
-            "Targeting Ceph OSD: {} (parsed from deployment {})",
-            osd_id_full, self.score.osd_deployment_name
-        );
-
-        Ok(osd_id_full)
-    }
-
-    pub async fn verify_ceph_toolbox_exists(
-        &self,
-        client: Arc<K8sClient>,
-    ) -> Result<Outcome, InterpretError> {
-        let toolbox_dep = "rook-ceph-tools".to_string();
-
-        match client
-            .get_deployment(&toolbox_dep, Some(&self.score.rook_ceph_namespace))
-            .await
-        {
-            Ok(Some(deployment)) => {
-                if let Some(status) = deployment.status {
-                    let ready_count = status.ready_replicas.unwrap_or(0);
-                    if ready_count >= 1 {
-                        return Ok(Outcome::success(format!(
-                            "'{}' is ready with {} replica(s).",
-                            &toolbox_dep, ready_count
-                        )));
-                    } else {
-                        return Err(InterpretError::new(
-                            "ceph-tool-box not ready in cluster".to_string(),
-                        ));
-                    }
-                } else {
-                    Err(InterpretError::new(format!(
-                        "failed to get deployment status {}",
-                        &toolbox_dep
-                    )))
-                }
-            }
-            Ok(None) => Err(InterpretError::new(format!(
-                "Deployment '{}' not found in namespace '{}'.",
-                &toolbox_dep, self.score.rook_ceph_namespace
-            ))),
-            Err(e) => Err(InterpretError::new(format!(
-                "Failed to query for deployment '{}': {}",
-                &toolbox_dep, e
-            ))),
-        }
-    }
-
-    pub async fn scale_deployment(
-        &self,
-        client: Arc<K8sClient>,
-    ) -> Result<Outcome, InterpretError> {
-        info!(
-            "Scaling down OSD deployment: {}",
-            self.score.osd_deployment_name
-        );
-        client
-            .scale_deployment(
-                &self.score.osd_deployment_name,
-                Some(&self.score.rook_ceph_namespace),
-                0,
-            )
-            .await?;
-        Ok(Outcome::success(format!(
-            "Scaled down deployment {}",
-            self.score.osd_deployment_name
-        )))
-    }
-
-    pub async fn verify_deployment_scaled(
-        &self,
-        client: Arc<K8sClient>,
-    ) -> Result<Outcome, InterpretError> {
-        let (timeout, interval, start) = self.build_timer();
-
-        info!("Waiting for OSD deployment to scale down to 0 replicas");
-        loop {
-            let dep = client
-                .get_deployment(
-                    &self.score.osd_deployment_name,
-                    Some(&self.score.rook_ceph_namespace),
-                )
-                .await?;
-
-            if let Some(deployment) = dep {
-                if let Some(status) = deployment.status {
-                    if status.replicas.unwrap_or(1) == 0 && status.ready_replicas.unwrap_or(1) == 0
-                    {
-                        return Ok(Outcome::success(
-                            "Deployment successfully scaled down.".to_string(),
-                        ));
-                    }
-                }
-            }
-
-            if start.elapsed() > timeout {
-                return Err(InterpretError::new(format!(
-                    "Timed out waiting for deployment {} to scale down",
-                    self.score.osd_deployment_name
-                )));
-            }
-            sleep(interval).await;
-        }
-    }
-
-    fn build_timer(&self) -> (Duration, Duration, Instant) {
-        let timeout = Duration::from_secs(120);
-        let interval = Duration::from_secs(5);
-        let start = Instant::now();
-        (timeout, interval, start)
-    }
-    pub async fn delete_deployment(
-        &self,
-        client: Arc<K8sClient>,
-    ) -> Result<Outcome, InterpretError> {
-        info!(
-            "Deleting OSD deployment: {}",
-            self.score.osd_deployment_name
-        );
-        client
-            .delete_deployment(
-                &self.score.osd_deployment_name,
-                Some(&self.score.rook_ceph_namespace),
-            )
-            .await?;
-        Ok(Outcome::success(format!(
-            "deployment {} deleted",
-            self.score.osd_deployment_name
-        )))
-    }
-
-    pub async fn verify_deployment_deleted(
-        &self,
-        client: Arc<K8sClient>,
-    ) -> Result<Outcome, InterpretError> {
-        let (timeout, interval, start) = self.build_timer();
-
-        info!("Waiting for OSD deployment to scale down to 0 replicas");
-        loop {
-            let dep = client
-                .get_deployment(
-                    &self.score.osd_deployment_name,
-                    Some(&self.score.rook_ceph_namespace),
-                )
-                .await?;
-
-            if dep.is_none() {
-                info!(
-                    "Deployment {} successfully deleted.",
-                    self.score.osd_deployment_name
-                );
-                return Ok(Outcome::success(format!(
-                    "Deployment {} deleted.",
-                    self.score.osd_deployment_name
-                )));
-            }
-
-            if start.elapsed() > timeout {
-                return Err(InterpretError::new(format!(
-                    "Timed out waiting for deployment {} to be deleted",
-                    self.score.osd_deployment_name
-                )));
-            }
-            sleep(interval).await;
-        }
-    }
-
-    fn get_osd_tree(&self, json: serde_json::Value) -> Result<CephOsdTree, InterpretError> {
-        let nodes = json.get("nodes").ok_or_else(|| {
-            InterpretError::new("Missing 'nodes' field in ceph osd tree JSON".to_string())
-        })?;
-        let tree: CephOsdTree = CephOsdTree {
-            nodes: serde_json::from_value(nodes.clone()).map_err(|e| {
-                InterpretError::new(format!("Failed to parse ceph osd tree JSON: {}", e))
-            })?,
-        };
-        Ok(tree)
-    }
-
-    pub async fn purge_ceph_osd(
-        &self,
-        client: Arc<K8sClient>,
-        osd_id_full: &str,
-    ) -> Result<Outcome, InterpretError> {
-        info!(
-            "Purging OSD {} from Ceph cluster and removing its auth key",
-            osd_id_full
-        );
-        client
-            .exec_app_capture_output(
-                "rook-ceph-tools".to_string(),
-                "app".to_string(),
-                Some(&self.score.rook_ceph_namespace),
-                vec![
-                    format!("ceph osd purge {osd_id_full} --yes-i-really-mean-it").as_str(),
-                    format!("ceph auth del osd.{osd_id_full}").as_str(),
-                ],
-            )
-            .await?;
-        Ok(Outcome::success(format!(
-            "osd id {} removed from osd tree",
-            osd_id_full
-        )))
-    }
-
-    pub async fn verify_ceph_osd_removal(
-        &self,
-        client: Arc<K8sClient>,
-        osd_id_full: &str,
-    ) -> Result<Outcome, InterpretError> {
-        let (timeout, interval, start) = self.build_timer();
-        info!(
-            "Verifying OSD {} has been removed from the Ceph tree...",
-            osd_id_full
-        );
-        loop {
-            let output = client
-                .exec_app_capture_output(
-                    "rook-ceph-tools".to_string(),
-                    "app".to_string(),
-                    Some(&self.score.rook_ceph_namespace),
-                    vec!["ceph osd tree -f json"],
-                )
-                .await?;
-            let tree =
-                self.get_osd_tree(serde_json::from_str(&output).expect("could not extract json"));
-
-            let osd_found = tree
-                .unwrap()
-                .nodes
-                .iter()
-                .any(|node| node.name == osd_id_full);
-
-            if !osd_found {
-                return Ok(Outcome::success(format!(
-                    "Successfully verified that OSD {} is removed from the Ceph cluster.",
-                    osd_id_full,
-                )));
-            }
-
-            if start.elapsed() > timeout {
-                return Err(InterpretError::new(format!(
-                    "Timed out waiting for OSD {} to be removed from Ceph tree",
-                    osd_id_full
-                )));
-            }
-
-            warn!(
-                "OSD {} still found in Ceph tree, retrying in {:?}...",
-                osd_id_full, interval
-            );
-            sleep(interval).await;
-        }
-    }
-}
-#[derive(Debug, Deserialize, PartialEq)]
-pub struct CephOsdTree {
-    pub nodes: Vec<CephNode>,
-}
-
-#[derive(Debug, Deserialize, PartialEq)]
-pub struct CephNode {
-    pub id: i32,
-    pub name: String,
-    #[serde(rename = "type")]
-    pub node_type: String,
-    pub type_id: Option<i32>,
-    pub children: Option<Vec<i32>>,
-    pub exists: Option<i32>,
-    pub status: Option<String>,
-}
-
-#[cfg(test)]
-mod tests {
-    use serde_json::json;
-
-    use super::*;
-
-    #[test]
-    fn test_get_osd_tree() {
-        let json_data = json!({
-            "nodes": [
-                {"id": 1, "name": "osd.1", "type": "osd", "primary_affinity":"1"},
-                {"id": 2, "name": "osd.2", "type": "osd", "crush_weight": 1.22344}
-            ]
-        });
-        let interpret = CephRemoveOsdInterpret {
-            score: CephRemoveOsd {
-                osd_deployment_name: "osd-1".to_string(),
-                rook_ceph_namespace: "dummy_ns".to_string(),
-            },
-        };
-        let json = interpret.get_osd_tree(json_data).unwrap();
-
-        let expected = CephOsdTree {
-            nodes: vec![
-                CephNode {
-                    id: 1,
-                    name: "osd.1".to_string(),
-                    node_type: "osd".to_string(),
-                    type_id: None,
-                    children: None,
-                    exists: None,
-                    status: None,
-                },
-                CephNode {
-                    id: 2,
-                    name: "osd.2".to_string(),
-                    node_type: "osd".to_string(),
-                    type_id: None,
-                    children: None,
-                    exists: None,
-                    status: None,
-                },
-            ],
-        };
-
-        assert_eq!(json, expected);
-    }
-}

harmony/src/modules/storage/ceph/mod.rs

@@ -1 +0,0 @@
-pub mod ceph_remove_osd_score;

harmony/src/modules/storage/mod.rs

@@ -1 +0,0 @@
-pub mod ceph;

harmony_cli/Cargo.toml

@@ -5,10 +5,6 @@ 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"] }
@@ -23,5 +19,7 @@ lazy_static = "1.5.0"
 log.workspace = true
 indicatif-log-bridge = "0.2.3"
 
-[dev-dependencies]
+
-harmony = { path = "../harmony", features = ["testing"] }
+[features]
+default = ["tui"]
+tui = ["dep:harmony_tui"]

harmony_cli/src/cli_logger.rs

@@ -1,16 +1,10 @@
 use harmony::{
     instrumentation::{self, HarmonyEvent},
-    modules::application::ApplicationFeatureStatus,
     topology::TopologyStatus,
 };
 use indicatif::MultiProgress;
 use indicatif_log_bridge::LogWrapper;
-use log::error;
+use std::sync::{Arc, Mutex};
-use std::{
-    sync::{Arc, Mutex},
-    thread,
-    time::Duration,
-};
 
 use crate::progress::{IndicatifProgressTracker, ProgressTracker};
 
@@ -64,7 +58,6 @@ async fn handle_events(base_progress: MultiProgress) {
                             &format!("\n{} Harmony completed\n\n", crate::theme::EMOJI_HARMONY),
                         );
                         progress_tracker.add_section("harmony-finished", "\n\n");
-                        thread::sleep(Duration::from_millis(200));
                         return false;
                     }
                     HarmonyEvent::TopologyStateChanged {
@@ -163,40 +156,10 @@ async fn handle_events(base_progress: MultiProgress) {
                                 _ => progress_tracker.fail_task(&task_key, &outcome.message),
                             },
                             Err(err) => {
-                                error!("Interpret error: {err}");
                                 progress_tracker.fail_task(&task_key, &err.to_string());
                             }
                         }
                     }
-                    HarmonyEvent::ApplicationFeatureStateChanged {
-                        topology: _,
-                        application,
-                        feature,
-                        status,
-                    } => {
-                        if let Some(score) = &(*current_score) {
-                            let section_key = score_key(score);
-                            let task_key = app_feature_key(&application, &feature);
-
-                            match status {
-                                ApplicationFeatureStatus::Installing => {
-                                    let message = format!("Feature '{}' installing...", feature);
-                                    progress_tracker.add_task(&section_key, &task_key, &message);
-                                }
-                                ApplicationFeatureStatus::Installed => {
-                                    let message = format!("Feature '{}' installed", feature);
-                                    progress_tracker.finish_task(&task_key, &message);
-                                }
-                                ApplicationFeatureStatus::Failed { details } => {
-                                    let message = format!(
-                                        "Feature '{}' installation failed: {}",
-                                        feature, details
-                                    );
-                                    progress_tracker.fail_task(&task_key, &message);
-                                }
-                            }
-                        }
-                    }
                 }
                 true
             }
@@ -212,7 +175,3 @@ fn topology_key(topology: &str) -> String {
 fn score_key(score: &str) -> String {
     format!("score-{score}")
 }
-
-fn app_feature_key(application: &str, feature: &str) -> String {
-    format!("app-{application}-{feature}")
-}

harmony_cli/src/lib.rs

@@ -132,9 +132,8 @@ async fn init<T: Topology + Send + Sync + 'static>(
 
     // if list option is specified, print filtered list and exit
     if args.list {
-        let num_scores = scores_vec.len();
+        println!("Available scores:");
-        println!("Available scores {num_scores}:");
+        println!("{}", list_scores_with_index(&scores_vec));
-        println!("{}\n\n", list_scores_with_index(&scores_vec));
         return Ok(());
     }
 
@@ -166,7 +165,7 @@ async fn init<T: Topology + Send + Sync + 'static>(
 }
 
 #[cfg(test)]
-mod tests {
+mod test {
     use harmony::{
         inventory::Inventory,
         maestro::Maestro,

harmony_cli/src/progress.rs

@@ -33,13 +33,29 @@ pub struct IndicatifProgressTracker {
 
 impl IndicatifProgressTracker {
     pub fn new(base: MultiProgress) -> Self {
-        let sections = HashMap::new();
+        // The indicatif log bridge will insert a progress bar at the top.
-        let tasks = HashMap::new();
+        // To prevent our first section from being erased, we need to create
+        // 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: 0,
+            pb_count: 1,
         }));
 
         Self { mp: base, state }

harmony_cli/src/theme.rs

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

harmony_composer/src/harmony_composer_logger.rs

@@ -1,5 +1,6 @@
 use harmony_cli::progress::{IndicatifProgressTracker, ProgressTracker};
 use indicatif::MultiProgress;
+use log::error;
 use std::sync::Arc;
 
 use crate::instrumentation::{self, HarmonyComposerEvent};
@@ -52,13 +53,15 @@ pub async fn handle_events() {
                         progress_tracker.finish_task(COMPILTATION_TASK, "project compiled");
                     }
                     HarmonyComposerEvent::ProjectCompilationFailed { details } => {
-                        progress_tracker.fail_task(COMPILTATION_TASK, &format!("failed to compile project:\n{details}"));
+                        progress_tracker.fail_task(COMPILTATION_TASK, "failed to compile project");
+
+                        error!("{details}");
                     }
-                    HarmonyComposerEvent::DeploymentStarted { target, profile } => {
+                    HarmonyComposerEvent::DeploymentStarted { target } => {
                         progress_tracker.add_section(
                             PROGRESS_DEPLOYMENT,
                             &format!(
-                                "\n{} Deploying project on target '{target}' with profile '{profile}'...\n",
+                                "\n{} Deploying project to {target}...\n",
                                 harmony_cli::theme::EMOJI_DEPLOY,
                             ),
                         );
@@ -66,10 +69,6 @@ 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,28 +2,16 @@ 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 {
+    ProjectCompilationStarted { details: String },
-        details: String,
-    },
     ProjectCompiled,
-    ProjectCompilationFailed {
+    ProjectCompilationFailed { details: String },
-        details: String,
+    DeploymentStarted { target: String },
-    },
-    DeploymentStarted {
-        target: HarmonyTarget,
-        profile: HarmonyProfile,
-    },
     DeploymentCompleted,
-    DeploymentFailed {
-        details: String,
-    },
     Shutdown,
 }
 
@@ -35,18 +23,9 @@ static HARMONY_COMPOSER_EVENT_BUS: Lazy<broadcast::Sender<HarmonyComposerEvent>>
     });
 
 pub fn instrument(event: HarmonyComposerEvent) -> Result<(), &'static str> {
-    #[cfg(not(test))]
+    match HARMONY_COMPOSER_EVENT_BUS.send(event) {
-    {
+        Ok(_) => Ok(()),
-        match HARMONY_COMPOSER_EVENT_BUS.send(event) {
+        Err(_) => Err("send error: no subscribers"),
-            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,11 +49,14 @@ struct CheckArgs {
 
 #[derive(Args, Clone, Debug)]
 struct DeployArgs {
-    #[arg(long = "target", short = 't', default_value = "local")]
+    #[arg(long, default_value_t = false)]
-    harmony_target: HarmonyTarget,
+    staging: bool,
 
-    #[arg(long = "profile", short = 'p', default_value = "dev")]
+    #[arg(long, default_value_t = false)]
-    harmony_profile: HarmonyProfile,
+    prod: bool,
+
+    #[arg(long, default_value_t = false)]
+    smoke_test: bool,
 }
 
 #[derive(Args, Clone, Debug)]
@@ -65,38 +68,6 @@ 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();
@@ -151,39 +122,26 @@ async fn main() {
                 );
             }
             Commands::Deploy(args) => {
-                instrumentation::instrument(HarmonyComposerEvent::DeploymentStarted {
+                let deploy = if args.staging {
-                    target: args.harmony_target.clone(),
+                    instrumentation::instrument(HarmonyComposerEvent::DeploymentStarted {
-                    profile: args.harmony_profile.clone(),
+                        target: "staging".to_string(),
-                })
+                    })
-                .unwrap();
+                    .unwrap();
-
+                    todo!("implement staging deployment")
-                if matches!(args.harmony_profile, HarmonyProfile::Dev)
+                } else if args.prod {
-                    && !matches!(args.harmony_target, HarmonyTarget::Local)
+                    instrumentation::instrument(HarmonyComposerEvent::DeploymentStarted {
-                {
+                        target: "prod".to_string(),
-                    instrumentation::instrument(HarmonyComposerEvent::DeploymentFailed {
+                    })
-                        details: format!(
+                    .unwrap();
-                            "Cannot run profile '{}' on target '{}'. Profile '{}' can run locally only.",
+                    todo!("implement prod deployment")
-                            args.harmony_profile, args.harmony_target, args.harmony_profile
+                } else {
-                        ),
+                    instrumentation::instrument(HarmonyComposerEvent::DeploymentStarted {
-                    }).unwrap();
+                        target: "dev".to_string(),
-                    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());