Merge branch 'master' into better-cli

Reviewed-on: NationTech/harmony#90
Reviewed-by: wjro <wrolleman@nationtech.io>

.gitignore

@@ -1,5 +1,25 @@
-target
+### General ###
-private_repos
+private_repos/
-log/
+
-*.tgz
+### Harmony ###
-.gitignore
+harmony.log
+
+### Helm ###
+# Chart dependencies
+**/charts/*.tgz
+
+### Rust ###
+# Generated by Cargo
+# will have compiled files and executables
+debug/
+target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
+Cargo.lock
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb

Cargo.lock

@@ -219,15 +219,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "atomic"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a89cbf775b137e9b968e67227ef7f775587cde3fd31b0d8599dbd0f598a48340"
-dependencies = [
- "bytemuck",
-]
-
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -418,12 +409,6 @@ version = "3.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
 
-[[package]]
-name = "bytemuck"
-version = "1.23.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c76a5792e44e4abe34d3abf15636779261d45a7450612059293d1d2cfc63422"
-
 [[package]]
 name = "byteorder"
 version = "1.5.0"
@@ -665,6 +650,19 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "console"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e09ced7ebbccb63b4c65413d821f2e00ce54c5ca4514ddc6b3c892fdbcbc69d"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "once_cell",
+ "unicode-width 0.2.0",
+ "windows-sys 0.60.2",
+]
+
 [[package]]
 name = "const-oid"
 version = "0.9.6"
@@ -1152,6 +1150,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "encode_unicode"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
+
 [[package]]
 name = "encoding_rs"
 version = "0.8.35"
@@ -1358,7 +1362,6 @@ dependencies = [
  "cidr",
  "env_logger",
  "harmony",
- "harmony_cli",
  "harmony_macros",
  "harmony_tui",
  "harmony_types",
@@ -1444,19 +1447,6 @@ version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d"
 
-[[package]]
-name = "figment"
-version = "0.10.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cb01cd46b0cf372153850f4c6c272d9cbea2da513e07538405148f95bd789f3"
-dependencies = [
- "atomic",
- "pear",
- "serde",
- "uncased",
- "version_check",
-]
-
 [[package]]
 name = "filetime"
 version = "0.2.25"
@@ -1779,7 +1769,6 @@ dependencies = [
  "dyn-clone",
  "email_address",
  "env_logger",
- "figment",
  "fqdn",
  "futures-util",
  "harmony_macros",
@@ -1787,7 +1776,6 @@ dependencies = [
  "helm-wrapper-rs",
  "hex",
  "http 1.3.1",
- "inquire",
  "k3d-rs",
  "k8s-openapi",
  "kube",
@@ -1795,6 +1783,7 @@ dependencies = [
  "libredfish",
  "log",
  "non-blank-string-rs",
+ "once_cell",
  "opnsense-config",
  "opnsense-config-xml",
  "pretty_assertions",
@@ -1826,10 +1815,15 @@ version = "0.1.0"
 dependencies = [
  "assert_cmd",
  "clap",
+ "console",
  "env_logger",
  "harmony",
  "harmony_tui",
+ "indicatif",
+ "indicatif-log-bridge",
  "inquire",
+ "lazy_static",
+ "log",
  "tokio",
 ]
 
@@ -1840,10 +1834,16 @@ dependencies = [
  "bollard",
  "cargo_metadata",
  "clap",
+ "console",
  "current_platform",
  "env_logger",
  "futures-util",
+ "harmony_cli",
+ "indicatif",
+ "indicatif-log-bridge",
+ "lazy_static",
  "log",
+ "once_cell",
  "serde_json",
  "tokio",
 ]
@@ -2439,18 +2439,35 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "indicatif"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70a646d946d06bedbbc4cac4c218acf4bbf2d87757a784857025f4d447e4e1cd"
+dependencies = [
+ "console",
+ "portable-atomic",
+ "unicode-width 0.2.0",
+ "unit-prefix",
+ "web-time",
+]
+
+[[package]]
+name = "indicatif-log-bridge"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63703cf9069b85dbe6fe26e1c5230d013dee99d3559cd3d02ba39e099ef7ab02"
+dependencies = [
+ "indicatif",
+ "log",
+]
+
 [[package]]
 name = "indoc"
 version = "2.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
-[[package]]
-name = "inlinable_string"
-version = "0.1.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8fae54786f62fb2918dcfae3d568594e50eb9b5c25bf04371af6fe7516452fb"
-
 [[package]]
 name = "inout"
 version = "0.1.4"
@@ -3272,29 +3289,6 @@ dependencies = [
  "hmac",
 ]
 
-[[package]]
-name = "pear"
-version = "0.2.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdeeaa00ce488657faba8ebf44ab9361f9365a97bd39ffb8a60663f57ff4b467"
-dependencies = [
- "inlinable_string",
- "pear_codegen",
- "yansi",
-]
-
-[[package]]
-name = "pear_codegen"
-version = "0.2.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bab5b985dc082b345f812b7df84e1bef27e7207b39e448439ba8bd69c93f147"
-dependencies = [
- "proc-macro2",
- "proc-macro2-diagnostics",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "pem"
 version = "3.0.5"
@@ -3557,19 +3551,6 @@ dependencies = [
  "unicode-ident",
 ]
 
-[[package]]
-name = "proc-macro2-diagnostics"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "version_check",
- "yansi",
-]
-
 [[package]]
 name = "punycode"
 version = "0.4.1"
@@ -5212,15 +5193,6 @@ version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
 
-[[package]]
-name = "uncased"
-version = "0.9.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1b88fcfe09e89d3866a5c11019378088af2d24c3fbd4f0543f96b479ec90697"
-dependencies = [
- "version_check",
-]
-
 [[package]]
 name = "unicode-ident"
 version = "1.0.18"
@@ -5262,6 +5234,12 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
+[[package]]
+name = "unit-prefix"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "323402cff2dd658f39ca17c789b502021b3f18707c91cdf22e3838e1b4023817"
+
 [[package]]
 name = "universal-hash"
 version = "0.5.1"

Cargo.toml

@@ -56,4 +56,3 @@ pretty_assertions = "1.4.1"
 bollard = "0.19.1"
 base64 = "0.22.1"
 tar = "0.4.44"
-figment = { version = "0.10.19", features = ["env"] }

examples/opnsense/Cargo.toml

@@ -16,4 +16,3 @@ harmony_macros = { path = "../../harmony_macros" }
 log = { workspace = true }
 env_logger = { workspace = true }
 url = { workspace = true }
-harmony_cli = { version = "0.1.0", path = "../../harmony_cli" }

examples/opnsense/src/main.rs

@@ -13,7 +13,7 @@ use harmony::{
         dummy::{ErrorScore, PanicScore, SuccessScore},
         http::StaticFilesHttpScore,
         okd::{dhcp::OKDDhcpScore, dns::OKDDnsScore, load_balancer::OKDLoadBalancerScore},
-        opnsense::{OPNSenseLaunchUpgrade, OPNsenseShellCommandScore},
+        opnsense::OPNsenseShellCommandScore,
         tftp::TftpScore,
     },
     topology::{LogicalHost, UnmanagedRouter, Url},
@@ -22,10 +22,8 @@ use harmony_macros::{ip, mac_address};
 
 #[tokio::main]
 async fn main() {
-    env_logger::init();
-
     let firewall = harmony::topology::LogicalHost {
-        ip: ip!("192.168.122.106"),
+        ip: ip!("192.168.5.229"),
         name: String::from("opnsense-1"),
     };
 
@@ -97,12 +95,9 @@ async fn main() {
             opnsense: opnsense.get_opnsense_config(),
             command: "touch /tmp/helloharmonytouching".to_string(),
         }),
-        // Box::new(OPNSenseLaunchUpgrade {
-        //     opnsense: opnsense.get_opnsense_config(),
-        // }),
         Box::new(SuccessScore {}),
         Box::new(ErrorScore {}),
         Box::new(PanicScore {}),
     ]);
-    harmony_cli::init(maestro, None).await.unwrap();
+    harmony_tui::init(maestro).await.unwrap();
 }

examples/rust/.gitignore

@@ -0,0 +1,3 @@
+Dockerfile.harmony
+.harmony_generated
+harmony

examples/rust/src/main.rs

@@ -9,10 +9,11 @@ use harmony::{
     },
     topology::{K8sAnywhereTopology, Url},
 };
+use harmony_cli::cli_logger;
 
 #[tokio::main]
 async fn main() {
-    env_logger::init();
+    let cli_logger_handle = cli_logger::init();
 
     let topology = K8sAnywhereTopology::from_env();
     let mut maestro = Maestro::initialize(Inventory::autoload(), topology)
@@ -22,7 +23,7 @@ async fn main() {
     let application = Arc::new(RustWebapp {
         name: "harmony-example-rust-webapp".to_string(),
         domain: Url::Url(url::Url::parse("https://rustapp.harmony.example.com").unwrap()),
-        project_root: PathBuf::from("./examples/rust/webapp"),
+        project_root: PathBuf::from("./webapp"), // Relative from 'harmony-path' param
         framework: Some(RustWebFramework::Leptos),
     });
 
@@ -30,14 +31,16 @@ async fn main() {
         features: vec![
             Box::new(ContinuousDelivery {
                 application: application.clone(),
-            }), // TODO add monitoring, backups, multisite ha, etc
+            }),
             Box::new(Monitoring {
                 application: application.clone(),
-            }),
+            }), // TODO: add backups, multisite ha, etc.
         ],
         application,
     };
 
     maestro.register_all(vec![Box::new(app)]);
     harmony_cli::init(maestro, None).await.unwrap();
+
+    let _ = tokio::try_join!(cli_logger_handle);
 }

examples/rust/webapp/Dockerfile.harmony

@@ -1,16 +0,0 @@
-FROM rust:bookworm as builder
-RUN apt-get update && apt-get install -y --no-install-recommends clang wget && wget https://github.com/cargo-bins/cargo-binstall/releases/latest/download/cargo-binstall-x86_64-unknown-linux-musl.tgz && tar -xvf cargo-binstall-x86_64-unknown-linux-musl.tgz && cp cargo-binstall /usr/local/cargo/bin && rm cargo-binstall-x86_64-unknown-linux-musl.tgz cargo-binstall && apt-get clean && rm -rf /var/lib/apt/lists/*
-RUN cargo binstall cargo-leptos -y
-RUN rustup target add wasm32-unknown-unknown
-WORKDIR /app
-COPY . .
-RUN cargo leptos build --release -vv
-FROM debian:bookworm-slim
-RUN groupadd -r appgroup && useradd -r -s /bin/false -g appgroup appuser
-ENV LEPTOS_SITE_ADDR=0.0.0.0:3000
-EXPOSE 3000/tcp
-WORKDIR /home/appuser
-COPY --from=builder /app/target/site/pkg /home/appuser/pkg
-COPY --from=builder /app/target/release/harmony-example-rust-webapp /home/appuser/harmony-example-rust-webapp
-USER appuser
-CMD /home/appuser/harmony-example-rust-webapp

harmony/Cargo.toml

@@ -32,7 +32,6 @@ k8s-openapi.workspace = true
 serde_yaml.workspace = true
 http.workspace = true
 serde-value.workspace = true
-inquire.workspace = true
 helm-wrapper-rs = "0.4.0"
 non-blank-string-rs = "1.0.4"
 k3d-rs = { path = "../k3d" }
@@ -44,12 +43,12 @@ convert_case.workspace = true
 email_address = "0.2.9"
 chrono.workspace = true
 fqdn = { version = "0.4.6", features = [
-    "domain-label-cannot-start-or-end-with-hyphen",
+  "domain-label-cannot-start-or-end-with-hyphen",
-    "domain-label-length-limited-to-63",
+  "domain-label-length-limited-to-63",
-    "domain-name-without-special-chars",
+  "domain-name-without-special-chars",
-    "domain-name-length-limited-to-255",
+  "domain-name-length-limited-to-255",
-    "punycode",
+  "punycode",
-    "serde",
+  "serde",
 ] }
 temp-dir = "0.1.14"
 dyn-clone = "1.0.19"
@@ -62,7 +61,7 @@ serde_with = "3.14.0"
 bollard.workspace = true
 tar.workspace = true
 base64.workspace = true
-figment.workspace = true
+once_cell = "1.21.3"
 
 [dev-dependencies]
 pretty_assertions.workspace = true

harmony/src/domain/config.rs

@@ -1,66 +1,15 @@
-use figment::{
-    Error, Figment, Metadata, Profile, Provider,
-    providers::{Env, Format},
-    value::{Dict, Map},
-};
 use lazy_static::lazy_static;
-use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
-#[derive(Debug, Deserialize, Serialize)]
+lazy_static! {
-pub struct Config {
+    pub static ref HARMONY_DATA_DIR: PathBuf = directories::BaseDirs::new()
-    pub data_dir: PathBuf,
+        .unwrap()
-    pub registry_url: String,
+        .data_dir()
-    pub registry_project: String,
+        .join("harmony");
-    pub dry_run: bool,
+    pub static ref REGISTRY_URL: String =
-    pub run_upgrades: bool,
+        std::env::var("HARMONY_REGISTRY_URL").unwrap_or_else(|_| "hub.nationtech.io".to_string());
-}
+    pub static ref REGISTRY_PROJECT: String =
-
+        std::env::var("HARMONY_REGISTRY_PROJECT").unwrap_or_else(|_| "harmony".to_string());
-impl Default for Config {
+    pub static ref DRY_RUN: bool =
-    fn default() -> Self {
+        std::env::var("HARMONY_DRY_RUN").map_or(true, |value| value.parse().unwrap_or(true));
-        Config {
-            data_dir: directories::BaseDirs::new()
-                .unwrap()
-                .data_dir()
-                .join("harmony"),
-            registry_url: "hub.nationtech.io".to_string(),
-            registry_project: "harmony".to_string(),
-            dry_run: true,
-            run_upgrades: false,
-        }
-    }
-}
-
-impl Config {
-    pub fn load() -> Result<Self, figment::Error> {
-        Figment::from(Config::default())
-            .merge(Env::prefixed("HARMONY_"))
-            .extract()
-    }
-
-    fn from<T: Provider>(provider: T) -> Result<Config, Error> {
-        Figment::from(provider).extract()
-    }
-
-    fn figment() -> Figment {
-        use figment::providers::Env;
-
-        // In reality, whatever the library desires.
-        Figment::from(Config::default()).merge(Env::prefixed("HARMONY_"))
-    }
-}
-
-impl Provider for Config {
-    fn metadata(&self) -> Metadata {
-        Metadata::named("Harmony Config")
-    }
-
-    fn data(&self) -> Result<Map<Profile, Dict>, Error> {
-        figment::providers::Serialized::defaults(Config::default()).data()
-    }
-
-    fn profile(&self) -> Option<Profile> {
-        // Optionally, a profile that's selected by default.
-        Some(Profile::Default)
-    }
 }

harmony/src/domain/instrumentation.rs

@@ -0,0 +1,63 @@
+use log::debug;
+use once_cell::sync::Lazy;
+use tokio::sync::broadcast;
+
+use super::interpret::{InterpretError, Outcome};
+
+#[derive(Debug, Clone)]
+pub enum HarmonyEvent {
+    HarmonyStarted,
+    PrepareTopologyStarted {
+        topology: String,
+    },
+    TopologyPrepared {
+        topology: String,
+        outcome: Outcome,
+    },
+    InterpretExecutionStarted {
+        topology: String,
+        interpret: String,
+        message: String,
+    },
+    InterpretExecutionFinished {
+        topology: String,
+        interpret: String,
+        outcome: Result<Outcome, InterpretError>,
+    },
+}
+
+static HARMONY_EVENT_BUS: Lazy<broadcast::Sender<HarmonyEvent>> = Lazy::new(|| {
+    // TODO: Adjust channel capacity
+    let (tx, _rx) = broadcast::channel(100);
+    tx
+});
+
+pub fn instrument(event: HarmonyEvent) -> Result<(), &'static str> {
+    match HARMONY_EVENT_BUS.send(event) {
+        Ok(_) => Ok(()),
+        Err(_) => Err("send error: no subscribers"),
+    }
+}
+
+pub async fn subscribe<F, Fut>(name: &str, mut handler: F)
+where
+    F: FnMut(HarmonyEvent) -> Fut + Send + 'static,
+    Fut: Future<Output = bool> + Send,
+{
+    let mut rx = HARMONY_EVENT_BUS.subscribe();
+    debug!("[{name}] Service started. Listening for events...");
+    loop {
+        match rx.recv().await {
+            Ok(event) => {
+                if !handler(event).await {
+                    debug!("[{name}] Handler requested exit.");
+                    break;
+                }
+            }
+            Err(broadcast::error::RecvError::Lagged(n)) => {
+                debug!("[{name}] Lagged behind by {n} messages.");
+            }
+            Err(_) => break,
+        }
+    }
+}

harmony/src/domain/maestro/mod.rs

@@ -1,6 +1,8 @@
 use std::sync::{Arc, Mutex, RwLock};
 
-use log::{info, warn};
+use log::{debug, info, warn};
+
+use crate::instrumentation::{self, HarmonyEvent};
 
 use super::{
     interpret::{InterpretError, InterpretStatus, Outcome},
@@ -40,13 +42,18 @@ impl<T: Topology> Maestro<T> {
     /// Ensures the associated Topology is ready for operations.
     /// Delegates the readiness check and potential setup actions to the Topology.
     pub async fn prepare_topology(&self) -> Result<Outcome, InterpretError> {
-        info!("Ensuring topology '{}' is ready...", self.topology.name());
+        instrumentation::instrument(HarmonyEvent::PrepareTopologyStarted {
+            topology: self.topology.name().to_string(),
+        })
+        .unwrap();
+
         let outcome = self.topology.ensure_ready().await?;
-        info!(
+
-            "Topology '{}' readiness check complete: {}",
+        instrumentation::instrument(HarmonyEvent::TopologyPrepared {
-            self.topology.name(),
+            topology: self.topology.name().to_string(),
-            outcome.status
+            outcome: outcome.clone(),
-        );
+        })
+        .unwrap();
 
         self.topology_preparation_result
             .lock()
@@ -80,11 +87,11 @@ impl<T: Topology> Maestro<T> {
                 self.topology.name(),
             );
         }
-        info!("Running score {score:?}");
+        debug!("Running score {score:?}");
         let interpret = score.create_interpret();
-        info!("Launching interpret {interpret:?}");
+        debug!("Launching interpret {interpret:?}");
         let result = interpret.execute(&self.inventory, &self.topology).await;
-        info!("Got result {result:?}");
+        debug!("Got result {result:?}");
         result
     }
 

harmony/src/domain/mod.rs

@@ -3,6 +3,7 @@ pub mod data;
 pub mod executors;
 pub mod filter;
 pub mod hardware;
+pub mod instrumentation;
 pub mod interpret;
 pub mod inventory;
 pub mod maestro;

harmony/src/domain/topology/ha_cluster.rs

@@ -1,15 +1,11 @@
 use async_trait::async_trait;
 use harmony_macros::ip;
 use harmony_types::net::MacAddress;
-use log::error;
 use log::info;
 
-use crate::config::Config;
 use crate::executors::ExecutorError;
 use crate::interpret::InterpretError;
 use crate::interpret::Outcome;
-use crate::inventory::Inventory;
-use crate::topology::upgradeable::Upgradeable;
 
 use super::DHCPStaticEntry;
 use super::DhcpServer;
@@ -29,12 +25,9 @@ use super::TftpServer;
 use super::Topology;
 use super::Url;
 use super::k8s::K8sClient;
-use std::fmt::Debug;
-use std::net::IpAddr;
-use std::str::FromStr;
 use std::sync::Arc;
 
-#[derive(Clone, Debug)]
+#[derive(Debug, Clone)]
 pub struct HAClusterTopology {
     pub domain_name: String,
     pub router: Arc<dyn Router>,
@@ -56,15 +49,9 @@ impl Topology for HAClusterTopology {
         "HAClusterTopology"
     }
     async fn ensure_ready(&self) -> Result<Outcome, InterpretError> {
-        error!(
+        todo!(
             "ensure_ready, not entirely sure what it should do here, probably something like verify that the hosts are reachable and all services are up and ready."
-        );
+        )
-        let config = Config::load().expect("couldn't load config");
-
-        if config.run_upgrades {
-            self.upgrade(&Inventory::empty(), self).await?;
-        }
-        Ok(Outcome::success("for now do nothing".to_string()))
     }
 }
 
@@ -264,13 +251,6 @@ impl Topology for DummyInfra {
     }
 }
 
-#[async_trait]
-impl<T: Topology> Upgradeable<T> for DummyInfra {
-    async fn upgrade(&self, _inventory: &Inventory, _topology: &T) -> Result<(), InterpretError> {
-        unimplemented!("{}", UNIMPLEMENTED_DUMMY_INFRA)
-    }
-}
-
 const UNIMPLEMENTED_DUMMY_INFRA: &str = "This is a dummy infrastructure, no operation is supported";
 
 impl Router for DummyInfra {
@@ -437,12 +417,3 @@ impl DnsServer for DummyInfra {
         unimplemented!("{}", UNIMPLEMENTED_DUMMY_INFRA)
     }
 }
-
-#[async_trait]
-impl<T: Topology> Upgradeable<T> for HAClusterTopology {
-    async fn upgrade(&self, inventory: &Inventory, topology: &T) -> Result<(), InterpretError> {
-        error!("TODO implement upgrades for all parts of the cluster");
-        self.firewall.upgrade(inventory, topology).await?;
-        Ok(())
-    }
-}

harmony/src/domain/topology/k8s.rs

@@ -20,8 +20,6 @@ use log::{debug, error, trace};
 use serde::de::DeserializeOwned;
 use similar::{DiffableStr, TextDiff};
 
-use crate::config::Config as HarmonyConfig;
-
 #[derive(new, Clone)]
 pub struct K8sClient {
     client: Client,
@@ -156,9 +154,7 @@ impl K8sClient {
             .as_ref()
             .expect("K8s Resource should have a name");
 
-        let config = HarmonyConfig::load().expect("couldn't load config");
+        if *crate::config::DRY_RUN {
-
-        if config.dry_run {
             match api.get(name).await {
                 Ok(current) => {
                     trace!("Received current value {current:#?}");

harmony/src/domain/topology/k8s_anywhere.rs

@@ -1,19 +1,16 @@
 use std::{process::Command, sync::Arc};
 
 use async_trait::async_trait;
-use figment::{Figment, providers::Env};
-use inquire::Confirm;
 use log::{debug, info, warn};
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 use tokio::sync::OnceCell;
 
 use crate::{
     executors::ExecutorError,
     interpret::{InterpretError, Outcome},
     inventory::Inventory,
-    maestro::Maestro,
     modules::k3d::K3DInstallationScore,
-    topology::LocalhostTopology,
+    score::Score,
 };
 
 use super::{
@@ -95,9 +92,8 @@ impl K8sAnywhereTopology {
             return Err("Failed to run 'helm -version'".to_string());
         }
 
-        // Print the version output
         let version_output = String::from_utf8_lossy(&version_result.stdout);
-        println!("Helm version: {}", version_output.trim());
+        debug!("Helm version: {}", version_output.trim());
 
         Ok(())
     }
@@ -115,9 +111,10 @@ impl K8sAnywhereTopology {
     }
 
     async fn try_install_k3d(&self) -> Result<(), InterpretError> {
-        let maestro = Maestro::initialize(Inventory::autoload(), LocalhostTopology::new()).await?;
+        self.get_k3d_installation_score()
-        let k3d_score = self.get_k3d_installation_score();
+            .create_interpret()
-        maestro.interpret(Box::new(k3d_score)).await?;
+            .execute(&Inventory::empty(), self)
+            .await?;
         Ok(())
     }
 
@@ -127,7 +124,7 @@ impl K8sAnywhereTopology {
         // TODO this deserves some refactoring, it is becoming a bit hard to figure out
         // be careful when making modifications here
         if k8s_anywhere_config.use_local_k3d {
-            info!("Using local k3d cluster because of use_local_k3d set to true");
+            debug!("Using local k3d cluster because of use_local_k3d set to true");
         } else {
             if let Some(kubeconfig) = &k8s_anywhere_config.kubeconfig {
                 debug!("Loading kubeconfig {kubeconfig}");
@@ -159,22 +156,13 @@ impl K8sAnywhereTopology {
         }
 
         if !k8s_anywhere_config.autoinstall {
-            debug!("Autoinstall confirmation prompt");
+            warn!(
-            let confirmation = Confirm::new( "Harmony autoinstallation is not activated, do you wish to launch autoinstallation? : ")
+                "Installation cancelled, K8sAnywhere could not initialize a valid Kubernetes client"
-                .with_default(false)
+            );
-                .prompt()
+            return Ok(None);
-                .expect("Unexpected prompt error");
-            debug!("Autoinstall confirmation {confirmation}");
-
-            if !confirmation {
-                warn!(
-                    "Installation cancelled, K8sAnywhere could not initialize a valid Kubernetes client"
-                );
-                return Ok(None);
-            }
         }
 
-        info!("Starting K8sAnywhere installation");
+        debug!("Starting K8sAnywhere installation");
         self.try_install_k3d().await?;
         let k3d_score = self.get_k3d_installation_score();
         // I feel like having to rely on the k3d_rs crate here is a smell
@@ -187,7 +175,7 @@ impl K8sAnywhereTopology {
             Ok(client) => K8sState {
                 client: Arc::new(K8sClient::new(client)),
                 _source: K8sSource::LocalK3d,
-                message: "Successfully installed K3D cluster and acquired client".to_string(),
+                message: "K8s client ready".to_string(),
             },
             Err(_) => todo!(),
         };
@@ -220,7 +208,7 @@ impl K8sAnywhereTopology {
     }
 }
 
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug)]
 pub struct K8sAnywhereConfig {
     /// The path of the KUBECONFIG file that Harmony should use to interact with the Kubernetes
     /// cluster
@@ -238,7 +226,7 @@ pub struct K8sAnywhereConfig {
     ///
     /// When enabled, autoinstall will setup a K3D cluster on the localhost. https://k3d.io/stable/
     ///
-    /// Default: false
+    /// Default: true
     pub autoinstall: bool,
 
     /// Whether to use local k3d cluster.
@@ -247,29 +235,25 @@ pub struct K8sAnywhereConfig {
     ///
     /// default: true
     pub use_local_k3d: bool,
-    pub profile: String,
+    pub harmony_profile: String,
-}
-
-impl Default for K8sAnywhereConfig {
-    fn default() -> Self {
-        Self {
-            kubeconfig: None,
-            use_system_kubeconfig: false,
-            autoinstall: false,
-            // TODO harmony_profile should be managed at a more core level than this
-            profile: "dev".to_string(),
-            use_local_k3d: true,
-        }
-    }
 }
 
 impl K8sAnywhereConfig {
     fn from_env() -> Self {
-        Figment::new()
+        Self {
-            .merge(Env::prefixed("HARMONY_"))
+            kubeconfig: std::env::var("KUBECONFIG").ok().map(|v| v.to_string()),
-            .merge(Env::raw().only(&["KUBECONFIG"]))
+            use_system_kubeconfig: std::env::var("HARMONY_USE_SYSTEM_KUBECONFIG")
-            .extract()
+                .map_or_else(|_| false, |v| v.parse().ok().unwrap_or(false)),
-            .expect("couldn't load config from env")
+            autoinstall: std::env::var("HARMONY_AUTOINSTALL")
+                .map_or_else(|_| true, |v| v.parse().ok().unwrap_or(false)),
+            // TODO harmony_profile should be managed at a more core level than this
+            harmony_profile: std::env::var("HARMONY_PROFILE").map_or_else(
+                |_| "dev".to_string(),
+                |v| v.parse().ok().unwrap_or("dev".to_string()),
+            ),
+            use_local_k3d: std::env::var("HARMONY_USE_LOCAL_K3D")
+                .map_or_else(|_| true, |v| v.parse().ok().unwrap_or(true)),
+        }
     }
 }
 
@@ -309,7 +293,7 @@ impl MultiTargetTopology for K8sAnywhereTopology {
             return DeploymentTarget::LocalDev;
         }
 
-        match self.config.profile.to_lowercase().as_str() {
+        match self.config.harmony_profile.to_lowercase().as_str() {
             "staging" => DeploymentTarget::Staging,
             "production" => DeploymentTarget::Production,
             _ => todo!("HARMONY_PROFILE must be set when use_local_k3d is not set"),

harmony/src/domain/topology/mod.rs

@@ -6,7 +6,6 @@ mod k8s_anywhere;
 mod localhost;
 pub mod oberservability;
 pub mod tenant;
-pub mod upgradeable;
 pub use k8s_anywhere::*;
 pub use localhost::*;
 pub mod k8s;

harmony/src/domain/topology/network.rs

@@ -2,15 +2,9 @@ use std::{net::Ipv4Addr, str::FromStr, sync::Arc};
 
 use async_trait::async_trait;
 use harmony_types::net::MacAddress;
-use log::debug;
 use serde::Serialize;
 
-use crate::{
+use crate::executors::ExecutorError;
-    executors::ExecutorError,
-    interpret::InterpretError,
-    inventory::Inventory,
-    topology::{Topology, upgradeable::Upgradeable},
-};
 
 use super::{IpAddress, LogicalHost, k8s::K8sClient};
 
@@ -44,15 +38,6 @@ impl std::fmt::Debug for dyn Firewall {
     }
 }
 
-// #[async_trait]
-// impl<T: Topology> Upgradeable<T> for dyn Firewall {
-//     async fn upgrade(&self, inventory: &Inventory, topology: &T) -> Result<(), InterpretError> {
-//         debug!("upgrading");
-//         self.upgrade(inventory, topology).await?;
-//         Ok(())
-//     }
-// }
-
 pub struct NetworkDomain {
     pub name: String,
 }

harmony/src/domain/topology/upgradeable.rs

@@ -1,8 +0,0 @@
-use async_trait::async_trait;
-
-use crate::{interpret::InterpretError, inventory::Inventory};
-
-#[async_trait]
-pub trait Upgradeable<T>: Send + Sync {
-    async fn upgrade(&self, inventory: &Inventory, topology: &T) -> Result<(), InterpretError>;
-}

harmony/src/infra/opnsense/mod.rs

@@ -7,18 +7,13 @@ mod management;
 mod tftp;
 use std::sync::Arc;
 
-use async_trait::async_trait;
 pub use management::*;
 use opnsense_config_xml::Host;
 use tokio::sync::RwLock;
 
 use crate::{
     executors::ExecutorError,
-    interpret::InterpretError,
+    topology::{IpAddress, LogicalHost},
-    inventory::Inventory,
-    modules::opnsense::OPNSenseLaunchUpgrade,
-    score::Score,
-    topology::{IpAddress, LogicalHost, Topology, upgradeable::Upgradeable},
 };
 
 #[derive(Debug, Clone)]
@@ -54,17 +49,3 @@ impl OPNSenseFirewall {
             .map_err(|e| ExecutorError::UnexpectedError(e.to_string()))
     }
 }
-
-#[async_trait]
-impl<T: Topology> Upgradeable<T> for OPNSenseFirewall {
-    async fn upgrade(&self, inventory: &Inventory, topology: &T) -> Result<(), InterpretError> {
-        OPNSenseLaunchUpgrade {
-            opnsense: self.get_opnsense_config(),
-        }
-        .create_interpret()
-        .execute(inventory, topology)
-        .await?;
-
-        Ok(())
-    }
-}

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

@@ -1,12 +1,12 @@
 use std::{io::Write, process::Command, sync::Arc};
 
 use async_trait::async_trait;
-use log::{error, info};
+use log::{debug, error};
 use serde_yaml::Value;
 use tempfile::NamedTempFile;
 
 use crate::{
-    config::Config,
+    config::HARMONY_DATA_DIR,
     data::Version,
     inventory::Inventory,
     modules::application::{
@@ -56,16 +56,14 @@ impl<A: OCICompliant + HelmPackage> ContinuousDelivery<A> {
         chart_url: String,
         image_name: String,
     ) -> Result<(), String> {
-        let config = Config::load().expect("couldn't load config");
-
         error!(
             "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 = config.data_dir.join("k3d").join("k3d");
+        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
         );
@@ -82,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()
@@ -103,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
         );
@@ -133,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(())
     }
 }
@@ -147,24 +145,19 @@ impl<
     async fn ensure_installed(&self, topology: &T) -> Result<(), String> {
         let image = self.application.image_name();
 
-        // TODO
-        error!(
-            "TODO reverse helm chart packaging and docker image build. I put helm package first for faster iterations"
-        );
-
         // TODO Write CI/CD workflow files
         // we can autotedect the CI type using the remote url (default to github action for github
         // url, etc..)
         // Or ask for it when unknown
 
         let helm_chart = self.application.build_push_helm_package(&image).await?;
-        info!("Pushed new helm chart {helm_chart}");
+        debug!("Pushed new helm chart {helm_chart}");
 
-        error!("TODO Make building image configurable/skippable");
+        error!("TODO Make building image configurable/skippable if image already exists (prompt)");
         let image = self.application.build_push_oci_image().await?;
-        info!("Pushed new docker image {image}");
+        debug!("Pushed new docker image {image}");
 
-        info!("Installing ContinuousDelivery feature");
+        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.
@@ -184,7 +177,7 @@ impl<
                     .await?;
             }
             target => {
-                info!("Deploying to target {target:?}");
+                debug!("Deploying to target {target:?}");
                 let score = ArgoHelmScore {
                     namespace: "harmonydemo-staging".to_string(),
                     openshift: false,

harmony/src/modules/application/mod.rs

@@ -5,7 +5,7 @@ mod rust;
 use std::sync::Arc;
 
 pub use feature::*;
-use log::info;
+use log::debug;
 pub use oci::*;
 pub use rust::*;
 
@@ -36,7 +36,7 @@ impl<A: Application, T: Topology + std::fmt::Debug> Interpret<T> for Application
         topology: &T,
     ) -> Result<Outcome, InterpretError> {
         let app_name = self.application.name();
-        info!(
+        debug!(
             "Preparing {} features [{}] for application {app_name}",
             self.features.len(),
             self.features
@@ -46,7 +46,7 @@ impl<A: Application, T: Topology + std::fmt::Debug> Interpret<T> for Application
                 .join(", ")
         );
         for feature in self.features.iter() {
-            info!(
+            debug!(
                 "Installing feature {} for application {app_name}",
                 feature.name()
             );

harmony/src/modules/application/rust.rs

@@ -10,11 +10,11 @@ use dockerfile_builder::Dockerfile;
 use dockerfile_builder::instruction::{CMD, COPY, ENV, EXPOSE, FROM, RUN, USER, WORKDIR};
 use dockerfile_builder::instruction_builder::CopyBuilder;
 use futures_util::StreamExt;
-use log::{debug, error, info};
+use log::{debug, error, log_enabled};
 use serde::Serialize;
 use tar::Archive;
 
-use crate::config::Config;
+use crate::config::{REGISTRY_PROJECT, REGISTRY_URL};
 use crate::{
     score::Score,
     topology::{Topology, Url},
@@ -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,26 +107,22 @@ 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 local image by calling the synchronous helper function.
+        // 1. Build the image by calling the synchronous helper function.
-        let local_image_name = self.local_image_name();
+        let image_tag = self.image_name();
-        self.build_docker_image(&local_image_name)
+        self.build_docker_image(&image_tag)
             .await
             .map_err(|e| format!("Failed to build Docker image: {}", e))?;
-        info!(
+        debug!("Successfully built Docker image: {}", image_tag);
-            "Successfully built local Docker image: {}",
-            local_image_name
-        );
 
-        let remote_image_name = self.image_name();
         // 2. Push the image to the registry.
-        self.push_docker_image(&local_image_name, &remote_image_name)
+        self.push_docker_image(&image_tag)
             .await
             .map_err(|e| format!("Failed to push Docker image: {}", e))?;
-        info!("Successfully pushed Docker image to: {}", remote_image_name);
+        debug!("Successfully pushed Docker image to: {}", image_tag);
 
-        Ok(remote_image_name)
+        Ok(image_tag)
     }
 
     fn local_image_name(&self) -> String {
@@ -134,12 +130,10 @@ impl OCICompliant for RustWebapp {
     }
 
     fn image_name(&self) -> String {
-        let config = Config::load().expect("couldn't load config");
-
         format!(
             "{}/{}/{}",
-            config.registry_url,
+            *REGISTRY_URL,
-            config.registry_project,
+            *REGISTRY_PROJECT,
             &self.local_image_name()
         )
     }
@@ -165,15 +159,17 @@ impl RustWebapp {
         &self,
         image_name: &str,
     ) -> Result<String, Box<dyn std::error::Error>> {
-        info!("Generating Dockerfile for '{}'", self.name);
+        debug!("Generating Dockerfile for '{}'", self.name);
         let _dockerfile_path = self.build_dockerfile()?;
 
         let docker = Docker::connect_with_socket_defaults().unwrap();
 
+        let quiet = !log_enabled!(log::Level::Debug);
+
         let build_image_options = bollard::query_parameters::BuildImageOptionsBuilder::default()
             .dockerfile("Dockerfile.harmony")
             .t(image_name)
-            .q(false)
+            .q(quiet)
             .version(bollard::query_parameters::BuilderVersion::BuilderV1)
             .platform("linux/x86_64");
 
@@ -208,23 +204,25 @@ impl RustWebapp {
     /// Tags and pushes a Docker image to the configured remote registry.
     async fn push_docker_image(
         &self,
-        image_name: &str,
+        image_tag: &str,
-        full_tag: &str,
     ) -> Result<String, Box<dyn std::error::Error>> {
-        info!("Pushing docker image {full_tag}");
+        debug!("Pushing docker image {image_tag}");
 
         let docker = Docker::connect_with_socket_defaults().unwrap();
 
         // let push_options = PushImageOptionsBuilder::new().tag(tag);
 
-        let mut push_image_stream =
+        let mut push_image_stream = docker.push_image(
-            docker.push_image(full_tag, Some(PushImageOptionsBuilder::new().build()), None);
+            image_tag,
+            Some(PushImageOptionsBuilder::new().build()),
+            None,
+        );
 
         while let Some(msg) = push_image_stream.next().await {
             println!("Message: {msg:?}");
         }
 
-        Ok(full_tag.to_string())
+        Ok(image_tag.to_string())
     }
 
     /// Checks the output of a process command for success.
@@ -537,7 +535,7 @@ spec:
         chart_dir: &PathBuf,
     ) -> Result<PathBuf, Box<dyn std::error::Error>> {
         let chart_dirname = chart_dir.file_name().expect("Should find a chart dirname");
-        info!(
+        debug!(
             "Launching `helm package {}` cli with CWD {}",
             chart_dirname.to_string_lossy(),
             &self
@@ -577,14 +575,12 @@ spec:
         &self,
         packaged_chart_path: &PathBuf,
     ) -> Result<String, Box<dyn std::error::Error>> {
-        let config = Config::load().expect("couldn't load config");
-
         // The chart name is the file stem of the .tgz file
         let chart_file_name = packaged_chart_path.file_stem().unwrap().to_str().unwrap();
-        let oci_push_url = format!("oci://{}/{}", config.registry_url, config.registry_project);
+        let oci_push_url = format!("oci://{}/{}", *REGISTRY_URL, *REGISTRY_PROJECT);
         let oci_pull_url = format!("{oci_push_url}/{}-chart", self.name);
 
-        info!(
+        debug!(
             "Pushing Helm chart {} to {}",
             packaged_chart_path.to_string_lossy(),
             oci_push_url

harmony/src/modules/k3d/install.rs

@@ -1,12 +1,13 @@
 use std::path::PathBuf;
 
 use async_trait::async_trait;
-use log::info;
+use log::{debug, info};
 use serde::Serialize;
 
 use crate::{
-    config::Config,
+    config::HARMONY_DATA_DIR,
     data::{Id, Version},
+    instrumentation::{self, HarmonyEvent},
     interpret::{Interpret, InterpretError, InterpretName, InterpretStatus, Outcome},
     inventory::Inventory,
     score::Score,
@@ -21,10 +22,8 @@ pub struct K3DInstallationScore {
 
 impl Default for K3DInstallationScore {
     fn default() -> Self {
-        let config = Config::load().expect("couldn't load config");
-
         Self {
-            installation_path: config.data_dir.join("k3d"),
+            installation_path: HARMONY_DATA_DIR.join("k3d"),
             cluster_name: "harmony".to_string(),
         }
     }
@@ -52,22 +51,38 @@ impl<T: Topology> Interpret<T> for K3dInstallationInterpret {
     async fn execute(
         &self,
         _inventory: &Inventory,
-        _topology: &T,
+        topology: &T,
     ) -> Result<Outcome, InterpretError> {
+        instrumentation::instrument(HarmonyEvent::InterpretExecutionStarted {
+            topology: topology.name().into(),
+            interpret: "k3d-installation".into(),
+            message: "installing k3d...".into(),
+        })
+        .unwrap();
+
         let k3d = k3d_rs::K3d::new(
             self.score.installation_path.clone(),
             Some(self.score.cluster_name.clone()),
         );
-        match k3d.ensure_installed().await {
+        let outcome = match k3d.ensure_installed().await {
             Ok(_client) => {
-                let msg = format!("k3d cluster {} is installed ", self.score.cluster_name);
+                let msg = format!("k3d cluster '{}' installed ", self.score.cluster_name);
-                info!("{msg}");
+                debug!("{msg}");
                 Ok(Outcome::success(msg))
             }
             Err(msg) => Err(InterpretError::new(format!(
-                "K3dInstallationInterpret failed to ensure k3d is installed : {msg}"
+                "failed to ensure k3d is installed : {msg}"
             ))),
-        }
+        };
+
+        instrumentation::instrument(HarmonyEvent::InterpretExecutionFinished {
+            topology: topology.name().into(),
+            interpret: "k3d-installation".into(),
+            outcome: outcome.clone(),
+        })
+        .unwrap();
+
+        outcome
     }
     fn get_name(&self) -> InterpretName {
         InterpretName::K3dInstallation

harmony/src/modules/lamp.rs

@@ -14,7 +14,7 @@ use async_trait::async_trait;
 use log::{debug, info};
 use serde::Serialize;
 
-use crate::config::Config as HarmonyConfig;
+use crate::config::{REGISTRY_PROJECT, REGISTRY_URL};
 use crate::modules::k8s::ingress::K8sIngressScore;
 use crate::topology::HelmCommand;
 use crate::{
@@ -355,12 +355,7 @@ opcache.fast_shutdown=1
     }
 
     fn push_docker_image(&self, image_name: &str) -> Result<String, Box<dyn std::error::Error>> {
-        let config = HarmonyConfig::load().expect("couldn't load config");
+        let full_tag = format!("{}/{}/{}", *REGISTRY_URL, *REGISTRY_PROJECT, &image_name);
-
-        let full_tag = format!(
-            "{}/{}/{}",
-            config.registry_url, config.registry_project, &image_name
-        );
         let output = std::process::Command::new("docker")
             .args(["tag", image_name, &full_tag])
             .output()?;

harmony_cli/Cargo.toml

@@ -13,6 +13,11 @@ harmony_tui = { path = "../harmony_tui", optional = true }
 inquire.workspace = true
 tokio.workspace = true
 env_logger.workspace = true
+console = "0.16.0"
+indicatif = "0.18.0"
+lazy_static = "1.5.0"
+log.workspace = true
+indicatif-log-bridge = "0.2.3"
 
 
 [features]

harmony_cli/src/cli_logger.rs

@@ -0,0 +1,116 @@
+use harmony::instrumentation::{self, HarmonyEvent};
+use indicatif::{MultiProgress, ProgressBar};
+use indicatif_log_bridge::LogWrapper;
+use std::{
+    collections::{HashMap, hash_map},
+    sync::{Arc, Mutex},
+};
+
+use crate::progress;
+
+pub fn init() -> tokio::task::JoinHandle<()> {
+    configure_logger();
+    let handle = tokio::spawn(handle_events());
+
+    loop {
+        if instrumentation::instrument(HarmonyEvent::HarmonyStarted).is_ok() {
+            break;
+        }
+    }
+
+    handle
+}
+
+fn configure_logger() {
+    let logger =
+        env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).build();
+    let level = logger.filter();
+    let multi = MultiProgress::new();
+    LogWrapper::new(multi.clone(), logger).try_init().unwrap();
+    log::set_max_level(level);
+}
+
+async fn handle_events() {
+    instrumentation::subscribe("Harmony CLI Logger", {
+        let sections: Arc<Mutex<HashMap<String, MultiProgress>>> =
+            Arc::new(Mutex::new(HashMap::new()));
+        let progress_bars: Arc<Mutex<HashMap<String, ProgressBar>>> =
+            Arc::new(Mutex::new(HashMap::new()));
+
+        move |event| {
+            let sections_clone = Arc::clone(&sections);
+            let progress_bars_clone = Arc::clone(&progress_bars);
+
+            async move {
+                let mut sections = sections_clone.lock().unwrap();
+                let mut progress_bars = progress_bars_clone.lock().unwrap();
+
+                match event {
+                    HarmonyEvent::HarmonyStarted => {}
+                    HarmonyEvent::PrepareTopologyStarted { topology: name } => {
+                        let section = progress::new_section(format!(
+                            "{} Preparing environment: {name}...",
+                            crate::theme::EMOJI_TOPOLOGY,
+                        ));
+                        (*sections).insert(name, section);
+                    }
+                    HarmonyEvent::TopologyPrepared {
+                        topology: name,
+                        outcome,
+                    } => {
+                        let section = (*sections).get(&name).unwrap();
+                        let progress = progress::add_spinner(section, "".into());
+
+                        match outcome.status {
+                            harmony::interpret::InterpretStatus::SUCCESS => {
+                                progress::success(section, Some(progress), outcome.message);
+                            }
+                            harmony::interpret::InterpretStatus::FAILURE => {
+                                progress::error(section, Some(progress), outcome.message);
+                            }
+                            harmony::interpret::InterpretStatus::RUNNING => todo!(),
+                            harmony::interpret::InterpretStatus::QUEUED => todo!(),
+                            harmony::interpret::InterpretStatus::BLOCKED => todo!(),
+                            harmony::interpret::InterpretStatus::NOOP => {
+                                progress::skip(section, Some(progress), outcome.message);
+                            }
+                        }
+                    }
+                    HarmonyEvent::InterpretExecutionStarted {
+                        interpret: name,
+                        topology,
+                        message,
+                    } => {
+                        let section = (*sections).get(&topology).unwrap();
+                        let progress_bar = progress::add_spinner(section, message);
+
+                        (*progress_bars).insert(name, progress_bar);
+                    }
+                    HarmonyEvent::InterpretExecutionFinished {
+                        topology,
+                        interpret: name,
+                        outcome,
+                    } => {
+                        let section = (*sections).get(&topology).unwrap();
+                        let progress_bar = (*progress_bars).get(&name).cloned();
+
+                        let _ = section.clear();
+
+                        match outcome {
+                            Ok(outcome) => {
+                                progress::success(section, progress_bar, outcome.message);
+                            }
+                            Err(err) => {
+                                progress::error(section, progress_bar, err.to_string());
+                            }
+                        }
+
+                        (*progress_bars).remove(&name);
+                    }
+                }
+                true
+            }
+        }
+    })
+    .await;
+}

harmony_cli/src/lib.rs

@@ -4,8 +4,13 @@ use harmony;
 use harmony::{score::Score, topology::Topology};
 use inquire::Confirm;
 
+pub mod cli_logger; // FIXME: Don't make me pub
+pub mod progress;
+pub mod theme;
+
 #[cfg(feature = "tui")]
 use harmony_tui;
+use log::debug;
 
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
@@ -134,7 +139,7 @@ pub async fn init<T: Topology + Send + Sync + 'static>(
 
     // Run filtered scores
     for s in scores_vec {
-        println!("Running: {}", s.name());
+        debug!("Running: {}", s.name());
         maestro.interpret(s).await?;
     }
 

harmony_cli/src/progress.rs

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

harmony_cli/src/theme.rs

@@ -0,0 +1,26 @@
+use console::Emoji;
+use indicatif::ProgressStyle;
+use lazy_static::lazy_static;
+
+pub static EMOJI_HARMONY: Emoji<'_, '_> = Emoji("🎼", "");
+pub static EMOJI_SUCCESS: Emoji<'_, '_> = Emoji("✅", "");
+pub static EMOJI_SKIP: Emoji<'_, '_> = Emoji("⏭️", "");
+pub static EMOJI_ERROR: Emoji<'_, '_> = Emoji("⚠️", "");
+pub static EMOJI_DEPLOY: Emoji<'_, '_> = Emoji("🚀", "");
+pub static EMOJI_TOPOLOGY: Emoji<'_, '_> = Emoji("📦", "");
+
+lazy_static! {
+    pub static ref SPINNER_STYLE: ProgressStyle = ProgressStyle::default_spinner()
+        .template("    {spinner:.green} {msg}")
+        .unwrap()
+        .tick_strings(&["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]);
+    pub static ref SUCCESS_SPINNER_STYLE: ProgressStyle = SPINNER_STYLE
+        .clone()
+        .tick_strings(&[format!("{}", EMOJI_SUCCESS).as_str()]);
+    pub static ref SKIP_SPINNER_STYLE: ProgressStyle = SPINNER_STYLE
+        .clone()
+        .tick_strings(&[format!("{}", EMOJI_SKIP).as_str()]);
+    pub static ref ERROR_SPINNER_STYLE: ProgressStyle = SPINNER_STYLE
+        .clone()
+        .tick_strings(&[format!("{}", EMOJI_ERROR).as_str()]);
+}

harmony_composer/Cargo.toml

@@ -15,3 +15,9 @@ current_platform = "0.2.0"
 futures-util = "0.3.31"
 serde_json = "1.0.140"
 cargo_metadata = "0.20.0"
+indicatif = "0.18.0"
+console = "0.16.0"
+lazy_static = "1.5.0"
+once_cell = "1.21.3"
+harmony_cli = { path = "../harmony_cli" }
+indicatif-log-bridge = "0.2.3"

harmony_composer/src/harmony_composer_logger.rs

@@ -0,0 +1,112 @@
+use indicatif::{MultiProgress, ProgressBar};
+use indicatif_log_bridge::LogWrapper;
+use log::error;
+use std::{
+    collections::HashMap,
+    sync::{Arc, Mutex},
+};
+
+use crate::instrumentation::{self, HarmonyComposerEvent};
+
+pub fn init() -> tokio::task::JoinHandle<()> {
+    configure_logger();
+    let handle = tokio::spawn(handle_events());
+
+    loop {
+        if instrumentation::instrument(HarmonyComposerEvent::HarmonyComposerStarted).is_ok() {
+            break;
+        }
+    }
+
+    handle
+}
+
+fn configure_logger() {
+    let logger =
+        env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).build();
+    let level = logger.filter();
+    let multi = MultiProgress::new();
+    LogWrapper::new(multi.clone(), logger).try_init().unwrap();
+    log::set_max_level(level);
+}
+
+pub async fn handle_events() {
+    const PROGRESS_SETUP: &str = "project-initialization";
+    const PROGRESS_DEPLOYMENT: &str = "deployment";
+
+    instrumentation::subscribe("Harmony Composer Logger", {
+        let progresses: Arc<Mutex<HashMap<String, MultiProgress>>> =
+            Arc::new(Mutex::new(HashMap::new()));
+        let compilation_progress = Arc::new(Mutex::new(None::<ProgressBar>));
+
+        move |event| {
+            let progresses_clone = Arc::clone(&progresses);
+            let compilation_progress_clone = Arc::clone(&compilation_progress);
+
+            async move {
+                let mut progresses_guard = progresses_clone.lock().unwrap();
+                let mut compilation_progress_guard = compilation_progress_clone.lock().unwrap();
+
+                match event {
+                    HarmonyComposerEvent::HarmonyComposerStarted => {}
+                    HarmonyComposerEvent::ProjectInitializationStarted => {
+                        let multi_progress = harmony_cli::progress::new_section(format!(
+                            "{} Initializing Harmony project...",
+                            harmony_cli::theme::EMOJI_HARMONY,
+                        ));
+                        (*progresses_guard).insert(PROGRESS_SETUP.to_string(), multi_progress);
+                    }
+                    HarmonyComposerEvent::ProjectInitialized => println!("\n"),
+                    HarmonyComposerEvent::ProjectCompilationStarted { details } => {
+                        let initialization_progress =
+                            (*progresses_guard).get(PROGRESS_SETUP).unwrap();
+                        let _ = initialization_progress.clear();
+
+                        let progress =
+                            harmony_cli::progress::add_spinner(initialization_progress, details);
+                        *compilation_progress_guard = Some(progress);
+                    }
+                    HarmonyComposerEvent::ProjectCompiled => {
+                        let initialization_progress =
+                            (*progresses_guard).get(PROGRESS_SETUP).unwrap();
+
+                        harmony_cli::progress::success(
+                            initialization_progress,
+                            (*compilation_progress_guard).take(),
+                            "project compiled".to_string(),
+                        );
+                    }
+                    HarmonyComposerEvent::ProjectCompilationFailed { details } => {
+                        let initialization_progress =
+                            (*progresses_guard).get(PROGRESS_SETUP).unwrap();
+
+                        harmony_cli::progress::error(
+                            initialization_progress,
+                            (*compilation_progress_guard).take(),
+                            "failed to compile project".to_string(),
+                        );
+
+                        error!("{details}");
+                    }
+                    HarmonyComposerEvent::DeploymentStarted { target } => {
+                        let multi_progress = harmony_cli::progress::new_section(format!(
+                            "{} Starting deployment to {target}...\n\n",
+                            harmony_cli::theme::EMOJI_DEPLOY
+                        ));
+                        (*progresses_guard).insert(PROGRESS_DEPLOYMENT.to_string(), multi_progress);
+                    }
+                    HarmonyComposerEvent::DeploymentCompleted { details } => println!("\n"),
+                    HarmonyComposerEvent::Shutdown => {
+                        for (_, progresses) in (*progresses_guard).iter() {
+                            progresses.clear().unwrap();
+                        }
+
+                        return false;
+                    }
+                }
+                true
+            }
+        }
+    })
+    .await
+}

harmony_composer/src/instrumentation.rs

@@ -0,0 +1,53 @@
+use log::debug;
+use once_cell::sync::Lazy;
+use tokio::sync::broadcast;
+
+#[derive(Debug, Clone)]
+pub enum HarmonyComposerEvent {
+    HarmonyComposerStarted,
+    ProjectInitializationStarted,
+    ProjectInitialized,
+    ProjectCompilationStarted { details: String },
+    ProjectCompiled,
+    ProjectCompilationFailed { details: String },
+    DeploymentStarted { target: String },
+    DeploymentCompleted { details: String },
+    Shutdown,
+}
+
+static HARMONY_COMPOSER_EVENT_BUS: Lazy<broadcast::Sender<HarmonyComposerEvent>> =
+    Lazy::new(|| {
+        // TODO: Adjust channel capacity
+        let (tx, _rx) = broadcast::channel(16);
+        tx
+    });
+
+pub fn instrument(event: HarmonyComposerEvent) -> Result<(), &'static str> {
+    match HARMONY_COMPOSER_EVENT_BUS.send(event) {
+        Ok(_) => Ok(()),
+        Err(_) => Err("send error: no subscribers"),
+    }
+}
+
+pub async fn subscribe<F, Fut>(name: &str, mut handler: F)
+where
+    F: FnMut(HarmonyComposerEvent) -> Fut + Send + 'static,
+    Fut: Future<Output = bool> + Send,
+{
+    let mut rx = HARMONY_COMPOSER_EVENT_BUS.subscribe();
+    debug!("[{name}] Service started. Listening for events...");
+    loop {
+        match rx.recv().await {
+            Ok(event) => {
+                if !handler(event).await {
+                    debug!("[{name}] Handler requested exit.");
+                    break;
+                }
+            }
+            Err(broadcast::error::RecvError::Lagged(n)) => {
+                debug!("[{name}] Lagged behind by {n} messages.");
+            }
+            Err(_) => break,
+        }
+    }
+}

harmony_composer/src/main.rs

@@ -7,12 +7,16 @@ use bollard::secret::HostConfig;
 use cargo_metadata::{Artifact, Message, MetadataCommand};
 use clap::{Args, Parser, Subcommand};
 use futures_util::StreamExt;
-use log::info;
+use instrumentation::HarmonyComposerEvent;
+use log::{debug, info, log_enabled};
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 use tokio::fs;
 
+mod harmony_composer_logger;
+mod instrumentation;
+
 #[derive(Parser)]
 #[command(version, about, long_about = None, flatten_help = true, propagate_version = true)]
 struct GlobalArgs {
@@ -66,13 +70,15 @@ struct AllArgs {
 
 #[tokio::main]
 async fn main() {
-    env_logger::init();
+    let hc_logger_handle = harmony_composer_logger::init();
     let cli_args = GlobalArgs::parse();
 
     let harmony_path = Path::new(&cli_args.harmony_path)
         .try_exists()
         .expect("couldn't check if path exists");
 
+    instrumentation::instrument(HarmonyComposerEvent::ProjectInitializationStarted).unwrap();
+
     let harmony_bin_path: PathBuf = match harmony_path {
         true => {
             compile_harmony(
@@ -85,6 +91,8 @@ async fn main() {
         false => todo!("implement autodetect code"),
     };
 
+    instrumentation::instrument(HarmonyComposerEvent::ProjectInitialized).unwrap();
+
     match cli_args.command {
         Some(command) => match command {
             Commands::Check(args) => {
@@ -98,7 +106,9 @@ async fn main() {
                     .expect("couldn't check if path exists")
                 {
                     true => (),
-                    false => todo!("implement couldn't find path logic"),
+                    false => todo!(
+                        "path {check_script_str} not found. Other paths currently unsupported."
+                    ),
                 };
 
                 let check_output = Command::new(check_script)
@@ -114,19 +124,31 @@ async fn main() {
             }
             Commands::Deploy(args) => {
                 let deploy = if args.staging {
+                    instrumentation::instrument(HarmonyComposerEvent::DeploymentStarted {
+                        target: "staging".to_string(),
+                    })
+                    .unwrap();
                     todo!("implement staging deployment")
                 } else if args.prod {
+                    instrumentation::instrument(HarmonyComposerEvent::DeploymentStarted {
+                        target: "prod".to_string(),
+                    })
+                    .unwrap();
                     todo!("implement prod deployment")
                 } else {
+                    instrumentation::instrument(HarmonyComposerEvent::DeploymentStarted {
+                        target: "dev".to_string(),
+                    })
+                    .unwrap();
                     Command::new(harmony_bin_path).arg("-y").arg("-a").spawn()
                 }
                 .expect("failed to run harmony deploy");
 
                 let deploy_output = deploy.wait_with_output().unwrap();
-                println!(
+                instrumentation::instrument(HarmonyComposerEvent::DeploymentCompleted {
-                    "deploy output: {}",
+                    details: String::from_utf8(deploy_output.stdout).unwrap(),
-                    String::from_utf8(deploy_output.stdout).expect("couldn't parse from utf8")
+                })
-                );
+                .unwrap();
             }
             Commands::All(_args) => todo!(
                 "take all previous match arms and turn them into separate functions, and call them all one after the other"
@@ -135,6 +157,10 @@ async fn main() {
         },
         None => todo!("run interactively, ask for info on CLI"),
     }
+
+    instrumentation::instrument(HarmonyComposerEvent::Shutdown).unwrap();
+
+    let _ = tokio::try_join!(hc_logger_handle);
 }
 
 #[derive(Clone, Debug, clap::ValueEnum)]
@@ -155,6 +181,7 @@ async fn compile_harmony(
 
     let cargo_exists = Command::new("which")
         .arg("cargo")
+        .stdout(Stdio::null())
         .status()
         .expect("couldn't get `which cargo` status")
         .success();
@@ -163,17 +190,32 @@ async fn compile_harmony(
         Some(m) => m,
         None => {
             if cargo_exists {
-                return compile_cargo(platform, harmony_location).await;
+                CompileMethod::LocalCargo
             } else {
-                return compile_docker(platform, harmony_location).await;
+                CompileMethod::Docker
             }
         }
     };
 
-    match method {
+    let path = match method {
-        CompileMethod::LocalCargo => return compile_cargo(platform, harmony_location).await,
+        CompileMethod::LocalCargo => {
-        CompileMethod::Docker => return compile_docker(platform, harmony_location).await,
+            instrumentation::instrument(HarmonyComposerEvent::ProjectCompilationStarted {
+                details: "compiling project with cargo".to_string(),
+            })
+            .unwrap();
+            compile_cargo(platform, harmony_location).await
+        }
+        CompileMethod::Docker => {
+            instrumentation::instrument(HarmonyComposerEvent::ProjectCompilationStarted {
+                details: "compiling project with docker".to_string(),
+            })
+            .unwrap();
+            compile_docker(platform, harmony_location).await
+        }
     };
+
+    instrumentation::instrument(HarmonyComposerEvent::ProjectCompiled).unwrap();
+    path
 }
 
 // TODO: make sure this works with cargo workspaces
@@ -183,6 +225,12 @@ async fn compile_cargo(platform: String, harmony_location: String) -> PathBuf {
         .exec()
         .unwrap();
 
+    let stderr = if log_enabled!(log::Level::Debug) {
+        Stdio::inherit()
+    } else {
+        Stdio::piped()
+    };
+
     let mut cargo_build = Command::new("cargo")
         .current_dir(&harmony_location)
         .args(vec![
@@ -192,6 +240,7 @@ async fn compile_cargo(platform: String, harmony_location: String) -> PathBuf {
             "--message-format=json-render-diagnostics",
         ])
         .stdout(Stdio::piped())
+        .stderr(stderr)
         .spawn()
         .expect("run cargo command failed");
 
@@ -207,18 +256,20 @@ async fn compile_cargo(platform: String, harmony_location: String) -> PathBuf {
                         .expect("failed to get root package")
                         .manifest_path
                 {
-                    println!("{:?}", artifact);
+                    debug!("{:?}", artifact);
                     artifacts.push(artifact);
                 }
             }
             Message::BuildScriptExecuted(_script) => (),
             Message::BuildFinished(finished) => {
-                println!("{:?}", finished);
+                debug!("{:?}", finished);
             }
             _ => (), // Unknown message
         }
     }
 
+    cargo_build.wait().expect("run cargo command failed");
+
     let bin = artifacts
         .last()
         .expect("no binaries built")
@@ -234,7 +285,8 @@ async fn compile_cargo(platform: String, harmony_location: String) -> PathBuf {
         bin_out = PathBuf::from(format!("{}/harmony", harmony_location));
         let _copy_res = fs::copy(&bin, &bin_out).await;
     }
-    return bin_out;
+
+    bin_out
 }
 
 async fn compile_docker(platform: String, harmony_location: String) -> PathBuf {

k3d/src/lib.rs

@@ -2,7 +2,7 @@ mod downloadable_asset;
 use downloadable_asset::*;
 
 use kube::Client;
-use log::{debug, info, warn};
+use log::{debug, warn};
 use std::path::PathBuf;
 
 const K3D_BIN_FILE_NAME: &str = "k3d";
@@ -90,7 +90,7 @@ impl K3d {
         let latest_release = self.get_latest_release_tag().await.unwrap();
 
         let release_binary = self.get_binary_for_current_platform(latest_release).await;
-        info!("Foudn K3d binary to install : {release_binary:#?}");
+        debug!("Foudn K3d binary to install : {release_binary:#?}");
         release_binary.download_to_path(self.base_dir.clone()).await
     }
 
@@ -175,7 +175,7 @@ impl K3d {
             Err(_) => return Err("Could not get cluster_name, cannot initialize".to_string()),
         };
 
-        info!("Initializing k3d cluster '{}'", cluster_name);
+        debug!("Initializing k3d cluster '{}'", cluster_name);
 
         self.create_cluster(cluster_name)?;
         self.create_kubernetes_client().await
@@ -205,7 +205,7 @@ impl K3d {
     /// - `Err(String)` - Error message if any step failed
     pub async fn ensure_installed(&self) -> Result<Client, String> {
         if !self.is_installed() {
-            info!("K3d is not installed, downloading latest release");
+            debug!("K3d is not installed, downloading latest release");
             self.download_latest_release()
                 .await
                 .map_err(|e| format!("Failed to download k3d: {}", e))?;
@@ -216,13 +216,13 @@ impl K3d {
         }
 
         if !self.is_cluster_initialized() {
-            info!("Cluster is not initialized, initializing now");
+            debug!("Cluster is not initialized, initializing now");
             return self.initialize_cluster().await;
         }
 
         self.start_cluster().await?;
 
-        info!("K3d and cluster are already properly set up");
+        debug!("K3d and cluster are already properly set up");
         self.create_kubernetes_client().await
     }
 
@@ -325,12 +325,12 @@ impl K3d {
             return Err(format!("Failed to create cluster: {}", stderr));
         }
 
-        info!("Successfully created k3d cluster '{}'", cluster_name);
+        debug!("Successfully created k3d cluster '{}'", cluster_name);
         Ok(())
     }
 
     async fn create_kubernetes_client(&self) -> Result<Client, String> {
-        warn!("TODO this method is way too dumb, it should make sure that the client is connected to the k3d cluster actually represented by this instance, not just any default  client");
+        // TODO: Connect the client to the right k3d cluster (see https://git.nationtech.io/NationTech/harmony/issues/92)
         Client::try_default()
             .await
             .map_err(|e| format!("Failed to create Kubernetes client: {}", e))
@@ -352,7 +352,7 @@ impl K3d {
             return Err(format!("Failed to start cluster: {}", stderr));
         }
 
-        info!("Successfully started k3d cluster '{}'", cluster_name);
+        debug!("Successfully started k3d cluster '{}'", cluster_name);
         Ok(())
     }
 }

opnsense-config-xml/src/data/interfaces.rs

@@ -83,7 +83,6 @@ pub struct Interface {
     pub adv_dhcp_config_advanced: Option<MaybeString>,
     pub adv_dhcp_config_file_override: Option<MaybeString>,
     pub adv_dhcp_config_file_override_path: Option<MaybeString>,
-    pub mtu: Option<u32>,
 }
 
 #[cfg(test)]

opnsense-config-xml/src/data/opnsense.rs

@@ -1,6 +1,6 @@
 use crate::HAProxy;
 use crate::{data::dhcpd::DhcpInterface, xml_utils::to_xml_str};
-use log::{debug, error};
+use log::error;
 use uuid::Uuid;
 use yaserde::{MaybeString, NamedList, RawXml};
 use yaserde_derive::{YaDeserialize, YaSerialize};
@@ -17,12 +17,12 @@ pub struct OPNsense {
     pub dhcpd: NamedList<DhcpInterface>,
     pub snmpd: Snmpd,
     pub syslog: Syslog,
-    pub nat: Option<Nat>,
+    pub nat: Nat,
     pub filter: Filters,
     pub load_balancer: Option<LoadBalancer>,
     pub rrd: Option<RawXml>,
     pub ntpd: Ntpd,
-    pub widgets: Option<Widgets>,
+    pub widgets: Widgets,
     pub revision: Revision,
     #[yaserde(rename = "OPNsense")]
     pub opnsense: OPNsenseXmlSection,
@@ -46,12 +46,10 @@ pub struct OPNsense {
     pub pischem: Option<Pischem>,
     pub ifgroups: Ifgroups,
     pub dnsmasq: Option<RawXml>,
-    pub wizardtemp: Option<RawXml>,
 }
 
 impl From<String> for OPNsense {
     fn from(content: String) -> Self {
-        debug!("XML content: {content}");
         yaserde::de::from_str(&content)
             .map_err(|e| println!("{}", e.to_string()))
             .expect("OPNSense received invalid string, should be full XML")
@@ -244,7 +242,6 @@ pub struct Ssh {
     pub passwordauth: u8,
     pub keysig: MaybeString,
     pub permitrootlogin: u8,
-    pub rekeylimit: MaybeString,
 }
 
 #[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
@@ -274,7 +271,6 @@ pub struct Group {
     pub member: Vec<u32>,
     #[yaserde(rename = "priv")]
     pub priv_field: String,
-    pub source_networks: Vec<MaybeString>,
 }
 
 #[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
@@ -1510,7 +1506,7 @@ pub struct Vlans {
 
 #[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
 pub struct Bridges {
-    pub bridged: Option<MaybeString>,
+    pub bridged: MaybeString,
 }
 
 #[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]