Merge pull request 'feat: Add openbao example, open-source fork of vault' (#162) from feat/openbao into master

Reviewed-on: #162

Cargo.lock

@@ -1795,6 +1795,18 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "example-openbao"
+version = "0.1.0"
+dependencies = [
+ "harmony",
+ "harmony_cli",
+ "harmony_macros",
+ "harmony_types",
+ "tokio",
+ "url",
+]
+
 [[package]]
 name = "example-opnsense"
 version = "0.1.0"
@@ -1810,6 +1822,18 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "example-penpot"
+version = "0.1.0"
+dependencies = [
+ "harmony",
+ "harmony_cli",
+ "harmony_macros",
+ "harmony_types",
+ "tokio",
+ "url",
+]
+
 [[package]]
 name = "example-pxe"
 version = "0.1.0"

examples/openbao/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "example-openbao"
+edition = "2024"
+version.workspace = true
+readme.workspace = true
+license.workspace = true
+
+[dependencies]
+harmony = { path = "../../harmony" }
+harmony_cli = { path = "../../harmony_cli" }
+harmony_macros = { path = "../../harmony_macros" }
+harmony_types = { path = "../../harmony_types" }
+tokio.workspace = true
+url.workspace = true

examples/openbao/README.md

@@ -0,0 +1,7 @@
+To install an openbao instance with harmony simply `cargo run -p example-openbao` .
+
+Depending on your environement configuration, it will either install a k3d cluster locally and deploy on it, or install to a remote cluster.
+
+Then follow the openbao documentation to initialize and unseal, this will make openbao usable.
+
+https://openbao.org/docs/platform/k8s/helm/run/

examples/openbao/src/main.rs

@@ -0,0 +1,67 @@
+use std::{collections::HashMap, str::FromStr};
+
+use harmony::{
+    inventory::Inventory,
+    modules::helm::chart::{HelmChartScore, HelmRepository, NonBlankString},
+    topology::K8sAnywhereTopology,
+};
+use harmony_macros::hurl;
+
+#[tokio::main]
+async fn main() {
+    let values_yaml = Some(
+        r#"server:
+  standalone:
+    enabled: true
+    config: |
+      listener "tcp" {
+        tls_disable = true
+        address = "[::]:8200"
+        cluster_address = "[::]:8201"
+      }
+
+      storage "file" {
+        path = "/openbao/data"
+      }
+
+  service:
+    enabled: true
+
+  dataStorage:
+    enabled: true
+    size: 10Gi
+    storageClass: null
+    accessMode: ReadWriteOnce
+
+  auditStorage:
+    enabled: true
+    size: 10Gi
+    storageClass: null
+    accessMode: ReadWriteOnce"#
+            .to_string(),
+    );
+    let openbao = HelmChartScore {
+        namespace: Some(NonBlankString::from_str("openbao").unwrap()),
+        release_name: NonBlankString::from_str("openbao").unwrap(),
+        chart_name: NonBlankString::from_str("openbao/openbao").unwrap(),
+        chart_version: None,
+        values_overrides: None,
+        values_yaml,
+        create_namespace: true,
+        install_only: true,
+        repository: Some(HelmRepository::new(
+            "openbao".to_string(),
+            hurl!("https://openbao.github.io/openbao-helm"),
+            true,
+        )),
+    };
+
+    harmony_cli::run(
+        Inventory::autoload(),
+        K8sAnywhereTopology::from_env(),
+        vec![Box::new(openbao)],
+        None,
+    )
+    .await
+    .unwrap();
+}

harmony/src/domain/topology/k8s.rs

@@ -3,7 +3,10 @@ use std::time::Duration;
 use derive_new::new;
 use k8s_openapi::{
     ClusterResourceScope, NamespaceResourceScope,
-    api::{apps::v1::Deployment, core::v1::Pod},
+    api::{
+        apps::v1::Deployment,
+        core::v1::{Pod, PodStatus},
+    },
 };
 use kube::{
     Client, Config, Error, Resource,
@@ -20,7 +23,7 @@ use kube::{
 };
 use log::{debug, error, trace};
 use serde::{Serialize, de::DeserializeOwned};
-use serde_json::json;
+use serde_json::{Value, json};
 use similar::TextDiff;
 use tokio::{io::AsyncReadExt, time::sleep};
 
@@ -68,7 +71,7 @@ impl K8sClient {
         } else {
             Api::default_namespaced_with(self.client.clone(), &gvk)
         };
-        resource.get(name).await
+        Ok(resource.get(name).await?)
     }
 
     pub async fn get_deployment(
@@ -81,7 +84,7 @@ impl K8sClient {
         } else {
             Api::default_namespaced(self.client.clone())
         };
-        deps.get_opt(name).await
+        Ok(deps.get_opt(name).await?)
     }
 
     pub async fn get_pod(&self, name: &str, namespace: Option<&str>) -> Result<Option<Pod>, Error> {
@@ -90,7 +93,7 @@ impl K8sClient {
         } else {
             Api::default_namespaced(self.client.clone())
         };
-        pods.get_opt(name).await
+        Ok(pods.get_opt(name).await?)
     }
 
     pub async fn scale_deployment(
@@ -167,12 +170,14 @@ impl K8sClient {
         loop {
             let pod = self.get_pod(pod_name, namespace).await?;
 
-            if let Some(p) = pod
-                && let Some(status) = p.status
-                && let Some(phase) = status.phase
-                && phase.to_lowercase() == "running"
-            {
-                return Ok(());
+            if let Some(p) = pod {
+                if let Some(status) = p.status {
+                    if let Some(phase) = status.phase {
+                        if phase.to_lowercase() == "running" {
+                            return Ok(());
+                        }
+                    }
+                }
             }
 
             if elapsed >= timeout_secs {
@@ -235,7 +240,7 @@ impl K8sClient {
 
                 if let Some(s) = status.status {
                     let mut stdout_buf = String::new();
-                    if let Some(mut stdout) = process.stdout() {
+                    if let Some(mut stdout) = process.stdout().take() {
                         stdout
                             .read_to_string(&mut stdout_buf)
                             .await

harmony/src/domain/topology/k8s_anywhere.rs

@@ -212,11 +212,11 @@ impl K8sAnywhereTopology {
             .await?;
         let ready_replicas = ic.data["status"]["availableReplicas"].as_i64().unwrap_or(0);
         if ready_replicas >= 1 {
-            Ok(())
+            return Ok(());
         } else {
-            Err(PreparationError::new(
+            return Err(PreparationError::new(
                 "openshift-ingress-operator not available".to_string(),
-            ))
+            ));
         }
     }
 

harmony/src/infra/inventory/mod.rs

@@ -11,7 +11,7 @@ pub struct InventoryRepositoryFactory;
 impl InventoryRepositoryFactory {
     pub async fn build() -> Result<Box<dyn InventoryRepository>, RepoError> {
         Ok(Box::new(
-            SqliteInventoryRepository::new(&DATABASE_URL).await?,
+            SqliteInventoryRepository::new(&(*DATABASE_URL)).await?,
         ))
     }
 }

harmony/src/infra/opnsense/http.rs

@@ -36,7 +36,7 @@ impl HttpServer for OPNSenseFirewall {
     async fn serve_file_content(&self, file: &FileContent) -> Result<(), ExecutorError> {
         let path = match &file.path {
             crate::data::FilePath::Relative(path) => {
-                format!("{OPNSENSE_HTTP_ROOT_PATH}/{}", path)
+                format!("{OPNSENSE_HTTP_ROOT_PATH}/{}", path.to_string())
             }
             crate::data::FilePath::Absolute(path) => {
                 return Err(ExecutorError::ConfigurationError(format!(

harmony/src/infra/opnsense/load_balancer.rs

@@ -182,12 +182,16 @@ pub(crate) fn get_health_check_for_backend(
     let uppercase = binding.as_str();
     match uppercase {
         "TCP" => {
-            if let Some(checkport) = haproxy_health_check.checkport.content.as_ref()
-                && !checkport.is_empty()
-            {
-                return Some(HealthCheck::TCP(Some(checkport.parse().unwrap_or_else(
-                    |_| panic!("HAProxy check port should be a valid port number, got {checkport}"),
-                ))));
+            if let Some(checkport) = haproxy_health_check.checkport.content.as_ref() {
+                if !checkport.is_empty() {
+                    return Some(HealthCheck::TCP(Some(checkport.parse().unwrap_or_else(
+                        |_| {
+                            panic!(
+                                "HAProxy check port should be a valid port number, got {checkport}"
+                            )
+                        },
+                    ))));
+                }
             }
             Some(HealthCheck::TCP(None))
         }

harmony/src/infra/opnsense/mod.rs

@@ -8,6 +8,7 @@ mod tftp;
 use std::sync::Arc;
 
 pub use management::*;
+use opnsense_config_xml::Host;
 use tokio::sync::RwLock;
 
 use crate::{executors::ExecutorError, topology::LogicalHost};

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

@@ -1,8 +1,11 @@
 use async_trait::async_trait;
-use kube::api::GroupVersionKind;
+use harmony_macros::hurl;
+use kube::{Api, api::GroupVersionKind};
+use log::{debug, warn};
 use non_blank_string_rs::NonBlankString;
 use serde::Serialize;
-use std::{str::FromStr, sync::Arc};
+use serde::de::DeserializeOwned;
+use std::{process::Command, str::FromStr, sync::Arc};
 
 use crate::{
     data::Version,
@@ -10,7 +13,10 @@ use crate::{
     inventory::Inventory,
     modules::helm::chart::{HelmChartScore, HelmRepository},
     score::Score,
-    topology::{HelmCommand, K8sclient, Topology, ingress::Ingress, k8s::K8sClient},
+    topology::{
+        HelmCommand, K8sclient, PreparationError, PreparationOutcome, Topology, ingress::Ingress,
+        k8s::K8sClient,
+    },
 };
 use harmony_types::id::Id;
 
@@ -114,13 +120,13 @@ impl ArgoInterpret {
 
                 match ic.data["status"]["domain"].as_str() {
                     Some(domain) => return Ok(domain.to_string()),
-                    None => Err(InterpretError::new("Could not find domain".to_string())),
+                    None => return Err(InterpretError::new("Could not find domain".to_string())),
                 }
             }
             false => {
                 todo!()
             }
-        }
+        };
     }
 }
 
@@ -1046,7 +1052,7 @@ commitServer:
         install_only: false,
         repository: Some(HelmRepository::new(
             "argo".to_string(),
-            url::Url::parse("https://argoproj.github.io/argo-helm").unwrap(),
+            hurl!("https://argoproj.github.io/argo-helm"),
             true,
         )),
     }

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

@@ -190,7 +190,7 @@ impl<
                 info!("Deploying {} to target {target:?}", self.application.name());
 
                 let score = ArgoHelmScore {
-                    namespace: self.application.name().to_string(),
+                    namespace: format!("{}", self.application.name()),
                     openshift: true,
                     argo_apps: vec![ArgoApplication::from(CDApplicationConfig {
                         // helm pull oci://hub.nationtech.io/harmony/harmony-example-rust-webapp-chart --version 0.1.0
@@ -198,8 +198,8 @@ impl<
                         helm_chart_repo_url: "hub.nationtech.io/harmony".to_string(),
                         helm_chart_name: format!("{}-chart", self.application.name()),
                         values_overrides: None,
-                        name: self.application.name().to_string(),
-                        namespace: self.application.name().to_string(),
+                        name: format!("{}", self.application.name()),
+                        namespace: format!("{}", self.application.name()),
                     })],
                 };
                 score

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

@@ -3,6 +3,7 @@ use std::sync::Arc;
 use crate::modules::application::{
     Application, ApplicationFeature, InstallationError, InstallationOutcome,
 };
+use crate::modules::monitoring::application_monitoring::application_monitoring_score::ApplicationMonitoringScore;
 use crate::modules::monitoring::application_monitoring::rhobs_application_monitoring_score::ApplicationRHOBMonitoringScore;
 
 use crate::modules::monitoring::kube_prometheus::crd::rhob_alertmanager_config::RHOBObservability;

harmony/src/modules/application/rust.rs

@@ -194,10 +194,10 @@ impl RustWebapp {
                     Some(body_full(tar_data.into())),
                 );
 
-                while let Some(msg) = image_build_stream.next().await {
+                while let Some(mut msg) = image_build_stream.next().await {
                     trace!("Got bollard msg {msg:?}");
                     match msg {
-                        Ok(msg) => {
+                        Ok(mut msg) => {
                             if let Some(progress) = msg.progress_detail {
                                 info!(
                                     "Build progress {}/{}",
@@ -511,23 +511,25 @@ ingress:
         fs::write(chart_dir.join("values.yaml"), values_yaml)?;
 
         // Create templates/_helpers.tpl
-        let helpers_tpl = r#"
-{{/*
+        let helpers_tpl = format!(
+            r#"
+{{{{/*
 Expand the name of the chart.
-*/}}
-{{- define "chart.name" -}}
-{{- default .Chart.Name $.Values.nameOverride | trunc 63 | trimSuffix "-" }}
-{{- end }}
+*/}}}}
+{{{{- define "chart.name" -}}}}
+{{{{- default .Chart.Name $.Values.nameOverride | trunc 63 | trimSuffix "-" }}}}
+{{{{- end }}}}
 
-{{/*
+{{{{/*
 Create a default fully qualified app name.
 We truncate at 63 chars because some Kubernetes name fields are limited to this (by the DNS naming spec).
-*/}}
-{{- define "chart.fullname" -}}
-{{- $name := default .Chart.Name $.Values.nameOverride }}
-{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" }}
-{{- end }}
-"#.to_string();
+*/}}}}
+{{{{- define "chart.fullname" -}}}}
+{{{{- $name := default .Chart.Name $.Values.nameOverride }}}}
+{{{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" }}}}
+{{{{- end }}}}
+"#
+        );
         fs::write(templates_dir.join("_helpers.tpl"), helpers_tpl)?;
 
         // Create templates/service.yaml

harmony/src/modules/cert_manager/helm.rs

@@ -1,5 +1,6 @@
 use std::{collections::HashMap, str::FromStr};
 
+use harmony_macros::hurl;
 use non_blank_string_rs::NonBlankString;
 use serde::Serialize;
 use url::Url;
@@ -33,7 +34,7 @@ impl<T: Topology + HelmCommand> Score<T> for CertManagerHelmScore {
             install_only: true,
             repository: Some(HelmRepository::new(
                 "jetstack".to_string(),
-                Url::parse("https://charts.jetstack.io").unwrap(),
+                hurl!("https://charts.jetstack.io"),
                 true,
             )),
         }

harmony/src/modules/helm/chart.rs

@@ -5,6 +5,7 @@ use crate::score::Score;
 use crate::topology::{HelmCommand, Topology};
 use async_trait::async_trait;
 use harmony_types::id::Id;
+use harmony_types::net::Url;
 use helm_wrapper_rs;
 use helm_wrapper_rs::blocking::{DefaultHelmExecutor, HelmExecutor};
 use log::{debug, info, warn};
@@ -15,7 +16,6 @@ use std::path::Path;
 use std::process::{Command, Output, Stdio};
 use std::str::FromStr;
 use temp_file::TempFile;
-use url::Url;
 
 #[derive(Debug, Clone, Serialize)]
 pub struct HelmRepository {
@@ -78,7 +78,8 @@ impl HelmChartInterpret {
             repo.name, repo.url, repo.force_update
         );
 
-        let mut add_args = vec!["repo", "add", &repo.name, repo.url.as_str()];
+        let repo_url = repo.url.to_string();
+        let mut add_args = vec!["repo", "add", &repo.name, &repo_url];
         if repo.force_update {
             add_args.push("--force-update");
         }

harmony/src/modules/helm/command.rs

@@ -1,363 +0,0 @@
-use async_trait::async_trait;
-use log::debug;
-use serde::Serialize;
-use std::collections::HashMap;
-use std::io::ErrorKind;
-use std::path::PathBuf;
-use std::process::{Command, Output};
-use temp_dir::{self, TempDir};
-use temp_file::TempFile;
-
-use crate::data::Version;
-use crate::interpret::{Interpret, InterpretError, InterpretName, InterpretStatus, Outcome};
-use crate::inventory::Inventory;
-use crate::score::Score;
-use crate::topology::{HelmCommand, K8sclient, Topology};
-use harmony_types::id::Id;
-
-#[derive(Clone)]
-pub struct HelmCommandExecutor {
-    pub env: HashMap<String, String>,
-    pub path: Option<PathBuf>,
-    pub args: Vec<String>,
-    pub api_versions: Option<Vec<String>>,
-    pub kube_version: String,
-    pub debug: Option<bool>,
-    pub globals: HelmGlobals,
-    pub chart: HelmChart,
-}
-
-#[derive(Clone)]
-pub struct HelmGlobals {
-    pub chart_home: Option<PathBuf>,
-    pub config_home: Option<PathBuf>,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct HelmChart {
-    pub name: String,
-    pub version: Option<String>,
-    pub repo: Option<String>,
-    pub release_name: Option<String>,
-    pub namespace: Option<String>,
-    pub additional_values_files: Vec<PathBuf>,
-    pub values_file: Option<PathBuf>,
-    pub values_inline: Option<String>,
-    pub include_crds: Option<bool>,
-    pub skip_hooks: Option<bool>,
-    pub api_versions: Option<Vec<String>>,
-    pub kube_version: Option<String>,
-    pub name_template: String,
-    pub skip_tests: Option<bool>,
-    pub debug: Option<bool>,
-}
-
-impl HelmCommandExecutor {
-    pub fn generate(mut self) -> Result<String, std::io::Error> {
-        if self.globals.chart_home.is_none() {
-            self.globals.chart_home = Some(PathBuf::from("charts"));
-        }
-
-        if self
-            .clone()
-            .chart
-            .clone()
-            .chart_exists_locally(self.clone().globals.chart_home.unwrap())
-            .is_none()
-        {
-            if self.chart.repo.is_none() {
-                return Err(std::io::Error::other(
-                    "Chart doesn't exist locally and no repo specified",
-                ));
-            }
-            self.clone().run_command(
-                self.chart
-                    .clone()
-                    .pull_command(self.globals.chart_home.clone().unwrap()),
-            )?;
-        }
-
-        let out = self.clone().run_command(
-            self.chart
-                .clone()
-                .helm_args(self.globals.chart_home.clone().unwrap()),
-        )?;
-
-        // TODO: don't use unwrap here
-        let s = String::from_utf8(out.stdout).unwrap();
-        debug!("helm stderr: {}", String::from_utf8(out.stderr).unwrap());
-        debug!("helm status: {}", out.status);
-        debug!("helm output: {s}");
-
-        let clean = s.split_once("---").unwrap().1;
-
-        Ok(clean.to_string())
-    }
-
-    pub fn version(self) -> Result<String, std::io::Error> {
-        let out = self.run_command(vec![
-            "version".to_string(),
-            "-c".to_string(),
-            "--short".to_string(),
-        ])?;
-
-        // TODO: don't use unwrap
-        Ok(String::from_utf8(out.stdout).unwrap())
-    }
-
-    pub fn run_command(mut self, mut args: Vec<String>) -> Result<Output, std::io::Error> {
-        if let Some(d) = self.debug
-            && d
-        {
-            args.push("--debug".to_string());
-        }
-
-        let path = if let Some(p) = self.path {
-            p
-        } else {
-            PathBuf::from("helm")
-        };
-
-        let config_home = match self.globals.config_home {
-            Some(p) => p,
-            None => PathBuf::from(TempDir::new()?.path()),
-        };
-
-        if let Some(yaml_str) = self.chart.values_inline {
-            let tf: TempFile = temp_file::with_contents(yaml_str.as_bytes());
-            self.chart
-                .additional_values_files
-                .push(PathBuf::from(tf.path()));
-        };
-
-        self.env.insert(
-            "HELM_CONFIG_HOME".to_string(),
-            config_home.to_str().unwrap().to_string(),
-        );
-        self.env.insert(
-            "HELM_CACHE_HOME".to_string(),
-            config_home.to_str().unwrap().to_string(),
-        );
-        self.env.insert(
-            "HELM_DATA_HOME".to_string(),
-            config_home.to_str().unwrap().to_string(),
-        );
-
-        Command::new(path).envs(self.env).args(args).output()
-    }
-}
-
-impl HelmChart {
-    pub fn chart_exists_locally(self, chart_home: PathBuf) -> Option<PathBuf> {
-        let chart_path =
-            PathBuf::from(chart_home.to_str().unwrap().to_string() + "/" + &self.name.to_string());
-
-        if chart_path.exists() {
-            Some(chart_path)
-        } else {
-            None
-        }
-    }
-
-    pub fn pull_command(self, chart_home: PathBuf) -> Vec<String> {
-        let mut args = vec![
-            "pull".to_string(),
-            "--untar".to_string(),
-            "--untardir".to_string(),
-            chart_home.to_str().unwrap().to_string(),
-        ];
-
-        match self.repo {
-            Some(r) => {
-                if r.starts_with("oci://") {
-                    args.push(
-                        r.trim_end_matches("/").to_string() + "/" + self.name.clone().as_str(),
-                    );
-                } else {
-                    args.push("--repo".to_string());
-                    args.push(r.to_string());
-
-                    args.push(self.name);
-                }
-            }
-            None => args.push(self.name),
-        };
-
-        if let Some(v) = self.version {
-            args.push("--version".to_string());
-            args.push(v.to_string());
-        }
-
-        args
-    }
-
-    pub fn helm_args(self, chart_home: PathBuf) -> Vec<String> {
-        let mut args: Vec<String> = vec!["template".to_string()];
-
-        match self.release_name {
-            Some(rn) => args.push(rn.to_string()),
-            None => args.push("--generate-name".to_string()),
-        }
-
-        args.push(
-            PathBuf::from(chart_home.to_str().unwrap().to_string() + "/" + self.name.as_str())
-                .to_str()
-                .unwrap()
-                .to_string(),
-        );
-
-        if let Some(n) = self.namespace {
-            args.push("--namespace".to_string());
-            args.push(n.to_string());
-        }
-
-        if let Some(f) = self.values_file {
-            args.push("-f".to_string());
-            args.push(f.to_str().unwrap().to_string());
-        }
-
-        for f in self.additional_values_files {
-            args.push("-f".to_string());
-            args.push(f.to_str().unwrap().to_string());
-        }
-
-        if let Some(vv) = self.api_versions {
-            for v in vv {
-                args.push("--api-versions".to_string());
-                args.push(v);
-            }
-        }
-
-        if let Some(kv) = self.kube_version {
-            args.push("--kube-version".to_string());
-            args.push(kv);
-        }
-
-        if let Some(crd) = self.include_crds
-            && crd
-        {
-            args.push("--include-crds".to_string());
-        }
-
-        if let Some(st) = self.skip_tests
-            && st
-        {
-            args.push("--skip-tests".to_string());
-        }
-
-        if let Some(sh) = self.skip_hooks
-            && sh
-        {
-            args.push("--no-hooks".to_string());
-        }
-
-        if let Some(d) = self.debug
-            && d
-        {
-            args.push("--debug".to_string());
-        }
-
-        args
-    }
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct HelmChartScoreV2 {
-    pub chart: HelmChart,
-}
-
-impl<T: Topology + K8sclient + HelmCommand> Score<T> for HelmChartScoreV2 {
-    fn create_interpret(&self) -> Box<dyn Interpret<T>> {
-        Box::new(HelmChartInterpretV2 {
-            score: self.clone(),
-        })
-    }
-
-    fn name(&self) -> String {
-        format!(
-            "{} {} HelmChartScoreV2",
-            self.chart
-                .release_name
-                .clone()
-                .unwrap_or("Unknown".to_string()),
-            self.chart.name
-        )
-    }
-}
-
-#[derive(Debug, Serialize)]
-pub struct HelmChartInterpretV2 {
-    pub score: HelmChartScoreV2,
-}
-impl HelmChartInterpretV2 {}
-
-#[async_trait]
-impl<T: Topology + K8sclient + HelmCommand> Interpret<T> for HelmChartInterpretV2 {
-    async fn execute(
-        &self,
-        _inventory: &Inventory,
-        _topology: &T,
-    ) -> Result<Outcome, InterpretError> {
-        let _ns = self
-            .score
-            .chart
-            .namespace
-            .as_ref()
-            .unwrap_or_else(|| todo!("Get namespace from active kubernetes cluster"));
-
-        let helm_executor = HelmCommandExecutor {
-            env: HashMap::new(),
-            path: None,
-            args: vec![],
-            api_versions: None,
-            kube_version: "v1.33.0".to_string(),
-            debug: Some(false),
-            globals: HelmGlobals {
-                chart_home: None,
-                config_home: None,
-            },
-            chart: self.score.chart.clone(),
-        };
-
-        // let mut helm_options = Vec::new();
-        // if self.score.create_namespace {
-        //     helm_options.push(NonBlankString::from_str("--create-namespace").unwrap());
-        // }
-
-        let res = helm_executor.generate();
-
-        let _output = match res {
-            Ok(output) => output,
-            Err(err) => return Err(InterpretError::new(err.to_string())),
-        };
-
-        // TODO: implement actually applying the YAML from the templating in the generate function to a k8s cluster, having trouble passing in straight YAML into the k8s client
-
-        // let k8s_resource = k8s_openapi::serde_json::from_str(output.as_str()).unwrap();
-
-        // let client = topology
-        //     .k8s_client()
-        //     .await
-        //     .expect("Environment should provide enough information to instanciate a client")
-        //     .apply_namespaced(&vec![output], Some(ns.to_string().as_str()));
-        // match client.apply_yaml(output) {
-        //     Ok(_) => return Ok(Outcome::success("Helm chart deployed".to_string())),
-        //     Err(e) => return Err(InterpretError::new(e)),
-        // }
-
-        Ok(Outcome::success("Helm chart deployed".to_string()))
-    }
-
-    fn get_name(&self) -> InterpretName {
-        InterpretName::HelmCommand
-    }
-    fn get_version(&self) -> Version {
-        todo!()
-    }
-    fn get_status(&self) -> InterpretStatus {
-        todo!()
-    }
-    fn get_children(&self) -> Vec<Id> {
-        todo!()
-    }
-}

harmony/src/modules/helm/mod.rs

@@ -1,2 +1 @@
 pub mod chart;
-pub mod command;

harmony/src/modules/http.rs

@@ -63,7 +63,7 @@ impl<T: Topology + HttpServer> Interpret<T> for StaticFilesHttpInterpret {
         }
 
         for f in self.score.files.iter() {
-            http_server.serve_file_content(f).await?
+            http_server.serve_file_content(&f).await?
         }
 
         http_server.commit_config().await?;

harmony/src/modules/inventory/discovery.rs

@@ -92,7 +92,7 @@ impl<T: Topology> Interpret<T> for DiscoverHostForRoleInterpret {
                     );
                     return Err(InterpretError::new(format!(
                         "Could not select host : {}",
-                        e
+                        e.to_string()
                     )));
                 }
             }

harmony/src/modules/monitoring/application_monitoring/rhobs_application_monitoring_score.rs

@@ -9,7 +9,9 @@ use crate::{
     inventory::Inventory,
     modules::{
         application::Application,
-        monitoring::kube_prometheus::crd::rhob_alertmanager_config::RHOBObservability,
+        monitoring::kube_prometheus::crd::{
+            crd_alertmanager_config::CRDPrometheus, rhob_alertmanager_config::RHOBObservability,
+        },
         prometheus::prometheus::PrometheusApplicationMonitoring,
     },
     score::Score,

harmony/src/modules/monitoring/kube_prometheus/crd/rhob_monitoring_stack.rs

@@ -1,8 +1,12 @@
+use std::collections::BTreeMap;
+
 use kube::CustomResource;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use crate::modules::monitoring::kube_prometheus::crd::rhob_prometheuses::LabelSelector;
+use crate::modules::monitoring::kube_prometheus::crd::rhob_prometheuses::{
+    LabelSelector, PrometheusSpec,
+};
 
 /// MonitoringStack CRD for monitoring.rhobs/v1alpha1
 #[derive(CustomResource, Serialize, Deserialize, Debug, Clone, JsonSchema)]

harmony/src/modules/okd/bootstrap_02_bootstrap.rs

@@ -52,12 +52,6 @@ pub struct OKDSetup02BootstrapInterpret {
     status: InterpretStatus,
 }
 
-impl Default for OKDSetup02BootstrapInterpret {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl OKDSetup02BootstrapInterpret {
     pub fn new() -> Self {
         let version = Version::from("1.0.0").unwrap();
@@ -104,9 +98,9 @@ impl OKDSetup02BootstrapInterpret {
                 InterpretError::new(format!("Failed to create okd installation directory : {e}"))
             })?;
         if !exit_status.success() {
-            return Err(InterpretError::new(
-                "Failed to create okd installation directory".to_string(),
-            ));
+            return Err(InterpretError::new(format!(
+                "Failed to create okd installation directory"
+            )));
         } else {
             info!(
                 "Created OKD installation directory {}",

harmony/src/modules/prometheus/rhob_alerting_score.rs

@@ -254,7 +254,7 @@ impl RHOBAlertingInterpret {
 
         let stack = MonitoringStack {
             metadata: ObjectMeta {
-                name: Some(format!("{}-monitoring", self.sender.namespace.clone())),
+                name: Some(format!("{}-monitoring", self.sender.namespace.clone()).into()),
                 namespace: Some(self.sender.namespace.clone()),
                 labels: Some([("monitoring-stack".into(), "true".into())].into()),
                 ..Default::default()
@@ -278,7 +278,7 @@ impl RHOBAlertingInterpret {
             .get_domain(&format!("alert-manager-{}", self.sender.namespace.clone()))
             .await?;
         let name = format!("{}-alert-manager", self.sender.namespace.clone());
-        let backend_service = "alertmanager-operated".to_string();
+        let backend_service = format!("alertmanager-operated");
         let namespace = self.sender.namespace.clone();
         let alert_manager_ingress = K8sIngressScore {
             name: fqdn!(&name),
@@ -295,7 +295,7 @@ impl RHOBAlertingInterpret {
             .get_domain(&format!("prometheus-{}", self.sender.namespace.clone()))
             .await?;
         let name = format!("{}-prometheus", self.sender.namespace.clone());
-        let backend_service = "prometheus-operated".to_string();
+        let backend_service = format!("prometheus-operated");
         let prometheus_ingress = K8sIngressScore {
             name: fqdn!(&name),
             host: fqdn!(&prometheus_domain),

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

@@ -25,7 +25,7 @@ pub struct CephRemoveOsd {
 
 impl<T: Topology + K8sclient> Score<T> for CephRemoveOsd {
     fn name(&self) -> String {
-        "CephRemoveOsdScore".to_string()
+        format!("CephRemoveOsdScore")
     }
 
     #[doc(hidden)]
@@ -118,14 +118,14 @@ impl CephRemoveOsdInterpret {
                 if let Some(status) = deployment.status {
                     let ready_count = status.ready_replicas.unwrap_or(0);
                     if ready_count >= 1 {
-                        Ok(Outcome::success(format!(
+                        return Ok(Outcome::success(format!(
                             "'{}' is ready with {} replica(s).",
                             &toolbox_dep, ready_count
-                        )))
+                        )));
                     } else {
-                        Err(InterpretError::new(
+                        return Err(InterpretError::new(
                             "ceph-tool-box not ready in cluster".to_string(),
-                        ))
+                        ));
                     }
                 } else {
                     Err(InterpretError::new(format!(
@@ -181,14 +181,15 @@ impl CephRemoveOsdInterpret {
                 )
                 .await?;
 
-            if let Some(deployment) = dep
-                && let Some(status) = deployment.status
-                && status.replicas.unwrap_or(1) == 0
-                && status.ready_replicas.unwrap_or(1) == 0
-            {
-                return Ok(Outcome::success(
-                    "Deployment successfully scaled down.".to_string(),
-                ));
+            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 {

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

@@ -20,7 +20,7 @@ pub struct CephVerifyClusterHealth {
 
 impl<T: Topology + K8sclient> Score<T> for CephVerifyClusterHealth {
     fn name(&self) -> String {
-        "CephValidateClusterHealth".to_string()
+        format!("CephValidateClusterHealth")
     }
 
     fn create_interpret(&self) -> Box<dyn Interpret<T>> {
@@ -80,14 +80,14 @@ impl CephVerifyClusterHealthInterpret {
                 if let Some(status) = deployment.status {
                     let ready_count = status.ready_replicas.unwrap_or(0);
                     if ready_count >= 1 {
-                        Ok(Outcome::success(format!(
+                        return Ok(Outcome::success(format!(
                             "'{}' is ready with {} replica(s).",
                             &toolbox_dep, ready_count
-                        )))
+                        )));
                     } else {
-                        Err(InterpretError::new(
+                        return Err(InterpretError::new(
                             "ceph-tool-box not ready in cluster".to_string(),
-                        ))
+                        ));
                     }
                 } else {
                     Err(InterpretError::new(format!(
@@ -123,9 +123,9 @@ impl CephVerifyClusterHealthInterpret {
             .await?;
 
         if health.contains("HEALTH_OK") {
-            Ok(Outcome::success(
+            return Ok(Outcome::success(
                 "Ceph Cluster in healthy state".to_string(),
-            ))
+            ));
         } else {
             Err(InterpretError::new(format!(
                 "Ceph cluster unhealthy {}",