commit

2025-10-02 17:11:02 -04:00 · 2025-10-02 16:59:08 -04:00 · 2025-10-02 16:56:17 -04:00 · 2025-10-02 16:53:25 -04:00 · 2025-10-02 16:46:43 -04:00 · 2025-10-02 16:25:07 -04:00
47 changed files with 329 additions and 2327 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -429,15 +429,6 @@ dependencies = [
 "wait-timeout",
 ]
 [[package]]
 name = "assertor"
 version = "0.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ff24d87260733dc86d38a11c60d9400ce4a74a05d0dafa2a6f5ab249cd857cb"
 dependencies = [
 "num-traits",
 ]
 [[package]]
 name = "async-broadcast"
 version = "0.7.2"
@@ -674,20 +665,6 @@ dependencies = [
 "serde_with",
 ]
 [[package]]
 name = "brocade"
 version = "0.1.0"
 dependencies = [
 "async-trait",
 "env_logger",
 "harmony_types",
 "log",
 "regex",
 "russh",
 "russh-keys",
 "tokio",
 ]
 [[package]]
 name = "brotli"
 version = "8.0.2"
@@ -2328,11 +2305,9 @@ name = "harmony"
 version = "0.1.0"
 dependencies = [
 "askama",
 "assertor",
 "async-trait",
 "base64 0.22.1",
 "bollard",
 "brocade",
 "chrono",
 "cidr",
 "convert_case",
@@ -2429,17 +2404,6 @@ dependencies = [
 "tokio",
 ]
 [[package]]
 name = "harmony_derive"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2d138bbb32bb346299c5f95fbb53532313f39927cb47c411c99c634ef8665ef7"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn 1.0.109",
 ]
 [[package]]
 name = "harmony_inventory_agent"
 version = "0.1.0"
@@ -3886,19 +3850,6 @@ dependencies = [
 "web-time",
 ]
 [[package]]
 name = "okd_host_network"
 version = "0.1.0"
 dependencies = [
 "harmony",
 "harmony_cli",
 "harmony_derive",
 "harmony_inventory_agent",
 "harmony_macros",
 "harmony_types",
 "tokio",
 ]
 [[package]]
 name = "once_cell"
 version = "1.21.3"
@@ -4586,9 +4537,9 @@ dependencies = [
 [[package]]
 name = "regex"
-version = "1.11.3"
+version = "1.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b5288124840bee7b386bc413c487869b360b2b4ec421ea56425128692f2a82c"
+checksum = "23d7fd106d8c02486a8d64e778353d1cffe08ce79ac2e82f540c86d0facf6912"
 dependencies = [
 "aho-corasick 1.1.3",
 "memchr",
@@ -4598,9 +4549,9 @@ dependencies = [
 [[package]]
 name = "regex-automata"
-version = "0.4.11"
+version = "0.4.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "833eb9ce86d40ef33cb1306d8accf7bc8ec2bfea4355cbdebb3df68b40925cad"
+checksum = "6b9458fa0bfeeac22b5ca447c63aaf45f28439a709ccd244698632f9aa6394d6"
 dependencies = [
 "aho-corasick 1.1.3",
 "memchr",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,8 +14,7 @@ members = [
  "harmony_composer",
  "harmony_inventory_agent",
  "harmony_secret_derive",
-  "harmony_secret",
+  "harmony_secret", "adr/agent_discovery/mdns",
  "adr/agent_discovery/mdns", "brocade",
 ]
 [workspace.package]
@@ -67,12 +66,5 @@ thiserror = "2.0.14"
 serde = { version = "1.0.209", features = ["derive", "rc"] }
 serde_json = "1.0.127"
 askama = "0.14"
-sqlx = { version = "0.8", features = ["runtime-tokio", "sqlite"] }
+sqlx = { version = "0.8", features = ["runtime-tokio", "sqlite" ] }
-reqwest = { version = "0.12", features = [
+reqwest = { version = "0.12", features = ["blocking", "stream", "rustls-tls", "http2", "json"], default-features = false }
  "blocking",
  "stream",
  "rustls-tls",
  "http2",
  "json",
 ], default-features = false }
 assertor = "0.0.4"
--- a/brocade/Cargo.toml
+++ b/brocade/Cargo.toml
@@ -1,16 +0,0 @@
 [package]
 name = "brocade"
 edition = "2024"
 version.workspace = true
 readme.workspace = true
 license.workspace = true
 [dependencies]
 async-trait.workspace = true
 harmony_types = { path = "../harmony_types" }
 russh.workspace = true
 russh-keys.workspace = true
 tokio.workspace = true
 log.workspace = true
 env_logger.workspace = true
 regex = "1.11.3"
--- a/brocade/examples/main.rs
+++ b/brocade/examples/main.rs
@@ -1,54 +0,0 @@
 use std::net::{IpAddr, Ipv4Addr};
 use harmony_types::switch::PortLocation;
 #[tokio::main]
 async fn main() {
    env_logger::init();
    let ip = IpAddr::V4(Ipv4Addr::new(10, 0, 0, 250)); // old brocade @ ianlet
    // let ip = IpAddr::V4(Ipv4Addr::new(192, 168, 55, 101)); // brocade @ sto1
    let switch_addresses = vec![ip];
    let brocade = brocade::init(&switch_addresses, 22, "admin", "password", None)
        .await
        .expect("Brocade client failed to connect");
    let version = brocade.version().await.unwrap();
    println!("Version: {version:?}");
    println!("--------------");
    println!("Showing MAC Address table...");
    let mac_adddresses = brocade.show_mac_address_table().await.unwrap();
    println!("VLAN\tMAC\t\t\tPORT");
    for mac in mac_adddresses {
        println!("{}\t{}\t{}", mac.vlan, mac.mac_address, mac.port);
    }
    println!("--------------");
    let channel_name = "HARMONY_LAG";
    println!("Clearing port channel '{channel_name}'...");
    brocade.clear_port_channel(channel_name).await.unwrap();
    println!("Cleared");
    println!("--------------");
    println!("Finding next available channel...");
    let channel_id = brocade.find_available_channel_id().await.unwrap();
    println!("Channel id: {channel_id}");
    println!("--------------");
    let channel_name = "HARMONY_LAG";
    let ports = [PortLocation(1, 1, 3), PortLocation(1, 1, 4)];
    println!("Creating port channel '{channel_name}' with ports {ports:?}'...");
    brocade
        .create_port_channel(channel_id, channel_name, &ports)
        .await
        .unwrap();
    println!("Created");
 }
--- a/brocade/src/fast_iron.rs
+++ b/brocade/src/fast_iron.rs
@@ -1,161 +0,0 @@
 use super::BrocadeClient;
 use crate::{
    BrocadeInfo, Error, ExecutionMode, MacAddressEntry, PortChannelId, parse_brocade_mac_address,
    shell::BrocadeShell,
 };
 use async_trait::async_trait;
 use harmony_types::switch::{PortDeclaration, PortLocation};
 use log::{debug, info};
 use regex::Regex;
 use std::{collections::HashSet, str::FromStr};
 pub struct FastIronClient {
    pub shell: BrocadeShell,
    pub version: BrocadeInfo,
 }
 impl FastIronClient {
    pub fn parse_mac_entry(&self, line: &str) -> Option<Result<MacAddressEntry, Error>> {
        debug!("[Brocade] Parsing mac address entry: {line}");
        let parts: Vec<&str> = line.split_whitespace().collect();
        if parts.len() < 3 {
            return None;
        }
        let (vlan, mac_address, port) = match parts.len() {
            3 => (
                u16::from_str(parts[0]).ok()?,
                parse_brocade_mac_address(parts[1]).ok()?,
                parts[2].to_string(),
            ),
            _ => (
                1,
                parse_brocade_mac_address(parts[0]).ok()?,
                parts[1].to_string(),
            ),
        };
        let port =
            PortDeclaration::parse(&port).map_err(|e| Error::UnexpectedError(format!("{e}")));
        match port {
            Ok(p) => Some(Ok(MacAddressEntry {
                vlan,
                mac_address,
                port: p,
            })),
            Err(e) => Some(Err(e)),
        }
    }
    pub fn build_port_channel_commands(
        &self,
        channel_name: &str,
        channel_id: u8,
        ports: &[PortLocation],
    ) -> Vec<String> {
        let mut commands = vec![
            "configure terminal".to_string(),
            format!("lag {channel_name} static id {channel_id}"),
        ];
        for port in ports {
            commands.push(format!("ports ethernet {port}"));
        }
        commands.push(format!("primary-port {}", ports[0]));
        commands.push("deploy".into());
        commands.push("exit".into());
        commands.push("write memory".into());
        commands.push("exit".into());
        commands
    }
 }
 #[async_trait]
 impl BrocadeClient for FastIronClient {
    async fn version(&self) -> Result<BrocadeInfo, Error> {
        Ok(self.version.clone())
    }
    async fn show_mac_address_table(&self) -> Result<Vec<MacAddressEntry>, Error> {
        info!("[Brocade] Showing MAC address table...");
        let output = self
            .shell
            .run_command("show mac-address", ExecutionMode::Regular)
            .await?;
        output
            .lines()
            .skip(2)
            .filter_map(|line| self.parse_mac_entry(line))
            .collect()
    }
    async fn find_available_channel_id(&self) -> Result<PortChannelId, Error> {
        info!("[Brocade] Finding next available channel id...");
        let output = self
            .shell
            .run_command("show lag", ExecutionMode::Regular)
            .await?;
        let re = Regex::new(r"=== LAG .* ID\s+(\d+)").expect("Invalid regex");
        let used_ids: HashSet<u8> = output
            .lines()
            .filter_map(|line| {
                re.captures(line)
                    .and_then(|c| c.get(1))
                    .and_then(|id_match| id_match.as_str().parse().ok())
            })
            .collect();
        let mut next_id: u8 = 1;
        loop {
            if !used_ids.contains(&next_id) {
                break;
            }
            next_id += 1;
        }
        info!("[Brocade] Found channel id: {next_id}");
        Ok(next_id)
    }
    async fn create_port_channel(
        &self,
        channel_id: PortChannelId,
        channel_name: &str,
        ports: &[PortLocation],
    ) -> Result<(), Error> {
        info!(
            "[Brocade] Configuring port-channel '{channel_name} {channel_id}' with ports: {ports:?}"
        );
        let commands = self.build_port_channel_commands(channel_name, channel_id, ports);
        self.shell
            .run_commands(commands, ExecutionMode::Privileged)
            .await?;
        info!("[Brocade] Port-channel '{channel_name}' configured.");
        Ok(())
    }
    async fn clear_port_channel(&self, channel_name: &str) -> Result<(), Error> {
        debug!("[Brocade] Clearing port-channel: {channel_name}");
        let commands = vec![
            "configure terminal".to_string(),
            format!("no lag {channel_name}"),
            "write memory".to_string(),
        ];
        self.shell
            .run_commands(commands, ExecutionMode::Privileged)
            .await?;
        Ok(())
    }
 }
--- a/brocade/src/lib.rs
+++ b/brocade/src/lib.rs
@@ -1,203 +0,0 @@
 use std::net::IpAddr;
 use std::{
    fmt::{self, Display},
    time::Duration,
 };
 use crate::{
    fast_iron::FastIronClient,
    shell::{BrocadeSession, BrocadeShell},
 };
 use async_trait::async_trait;
 use harmony_types::net::MacAddress;
 use harmony_types::switch::{PortDeclaration, PortLocation};
 use regex::Regex;
 mod fast_iron;
 mod shell;
 mod ssh;
 #[derive(Default, Clone, Debug)]
 pub struct BrocadeOptions {
    pub dry_run: bool,
    pub ssh: ssh::SshOptions,
    pub timeouts: TimeoutConfig,
 }
 #[derive(Clone, Debug)]
 pub struct TimeoutConfig {
    pub shell_ready: Duration,
    pub command_execution: Duration,
    pub cleanup: Duration,
    pub message_wait: Duration,
 }
 impl Default for TimeoutConfig {
    fn default() -> Self {
        Self {
            shell_ready: Duration::from_secs(3),
            command_execution: Duration::from_secs(60), // Commands like `deploy` (for a LAG) can take a while
            cleanup: Duration::from_secs(10),
            message_wait: Duration::from_millis(500),
        }
    }
 }
 enum ExecutionMode {
    Regular,
    Privileged,
 }
 #[derive(Clone, Debug)]
 pub struct BrocadeInfo {
    os: BrocadeOs,
    version: String,
 }
 #[derive(Clone, Debug)]
 pub enum BrocadeOs {
    NetworkOperatingSystem,
    FastIron,
    Unknown,
 }
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
 pub struct MacAddressEntry {
    pub vlan: u16,
    pub mac_address: MacAddress,
    pub port: PortDeclaration,
 }
 pub type PortChannelId = u8;
 pub async fn init(
    ip_addresses: &[IpAddr],
    port: u16,
    username: &str,
    password: &str,
    options: Option<BrocadeOptions>,
 ) -> Result<Box<dyn BrocadeClient + Send + Sync>, Error> {
    let shell = BrocadeShell::init(ip_addresses, port, username, password, options).await?;
    let version_info = shell
        .with_session(ExecutionMode::Regular, |session| {
            Box::pin(get_brocade_info(session))
        })
        .await?;
    Ok(match version_info.os {
        BrocadeOs::FastIron => Box::new(FastIronClient {
            shell,
            version: version_info,
        }),
        BrocadeOs::NetworkOperatingSystem => todo!(),
        BrocadeOs::Unknown => todo!(),
    })
 }
 #[async_trait]
 pub trait BrocadeClient {
    async fn version(&self) -> Result<BrocadeInfo, Error>;
    async fn show_mac_address_table(&self) -> Result<Vec<MacAddressEntry>, Error>;
    async fn find_available_channel_id(&self) -> Result<PortChannelId, Error>;
    async fn create_port_channel(
        &self,
        channel_id: PortChannelId,
        channel_name: &str,
        ports: &[PortLocation],
    ) -> Result<(), Error>;
    async fn clear_port_channel(&self, channel_name: &str) -> Result<(), Error>;
 }
 async fn get_brocade_info(session: &mut BrocadeSession) -> Result<BrocadeInfo, Error> {
    let output = session.run_command("show version").await?;
    if output.contains("Network Operating System") {
        let re = Regex::new(r"Network Operating System Version:\s*(?P<version>[a-zA-Z0-9.\-]+)")
            .expect("Invalid regex");
        let version = re
            .captures(&output)
            .and_then(|cap| cap.name("version"))
            .map(|m| m.as_str().to_string())
            .unwrap_or_default();
        return Ok(BrocadeInfo {
            os: BrocadeOs::NetworkOperatingSystem,
            version,
        });
    } else if output.contains("ICX") {
        let re = Regex::new(r"(?m)^\s*SW: Version\s*(?P<version>[a-zA-Z0-9.\-]+)")
            .expect("Invalid regex");
        let version = re
            .captures(&output)
            .and_then(|cap| cap.name("version"))
            .map(|m| m.as_str().to_string())
            .unwrap_or_default();
        return Ok(BrocadeInfo {
            os: BrocadeOs::FastIron,
            version,
        });
    }
    Err(Error::UnexpectedError("Unknown Brocade OS version".into()))
 }
 fn parse_brocade_mac_address(value: &str) -> Result<MacAddress, String> {
    let cleaned_mac = value.replace('.', "");
    if cleaned_mac.len() != 12 {
        return Err(format!("Invalid MAC address: {value}"));
    }
    let mut bytes = [0u8; 6];
    for (i, pair) in cleaned_mac.as_bytes().chunks(2).enumerate() {
        let byte_str = std::str::from_utf8(pair).map_err(|_| "Invalid UTF-8")?;
        bytes[i] =
            u8::from_str_radix(byte_str, 16).map_err(|_| format!("Invalid hex in MAC: {value}"))?;
    }
    Ok(MacAddress(bytes))
 }
 #[derive(Debug)]
 pub enum Error {
    NetworkError(String),
    AuthenticationError(String),
    ConfigurationError(String),
    TimeoutError(String),
    UnexpectedError(String),
    CommandError(String),
 }
 impl Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Error::NetworkError(msg) => write!(f, "Network error: {msg}"),
            Error::AuthenticationError(msg) => write!(f, "Authentication error: {msg}"),
            Error::ConfigurationError(msg) => write!(f, "Configuration error: {msg}"),
            Error::TimeoutError(msg) => write!(f, "Timeout error: {msg}"),
            Error::UnexpectedError(msg) => write!(f, "Unexpected error: {msg}"),
            Error::CommandError(msg) => write!(f, "{msg}"),
        }
    }
 }
 impl From<Error> for String {
    fn from(val: Error) -> Self {
        format!("{val}")
    }
 }
 impl std::error::Error for Error {}
 impl From<russh::Error> for Error {
    fn from(value: russh::Error) -> Self {
        Error::NetworkError(format!("Russh client error: {value}"))
    }
 }
--- a/brocade/src/shell.rs
+++ b/brocade/src/shell.rs
@@ -1,330 +0,0 @@
 use std::net::IpAddr;
 use std::time::Duration;
 use std::time::Instant;
 use crate::BrocadeOptions;
 use crate::Error;
 use crate::ExecutionMode;
 use crate::TimeoutConfig;
 use crate::ssh;
 use log::debug;
 use log::info;
 use russh::ChannelMsg;
 use tokio::time::timeout;
 pub struct BrocadeShell {
    pub ip: IpAddr,
    pub port: u16,
    pub username: String,
    pub password: String,
    pub options: BrocadeOptions,
 }
 impl BrocadeShell {
    pub async fn init(
        ip_addresses: &[IpAddr],
        port: u16,
        username: &str,
        password: &str,
        options: Option<BrocadeOptions>,
    ) -> Result<Self, Error> {
        let ip = ip_addresses
            .first()
            .ok_or_else(|| Error::ConfigurationError("No IP addresses provided".to_string()))?;
        let base_options = options.unwrap_or_default();
        let options = ssh::try_init_client(username, password, ip, base_options).await?;
        Ok(Self {
            ip: *ip,
            port,
            username: username.to_string(),
            password: password.to_string(),
            options,
        })
    }
    pub async fn open_session(&self, mode: ExecutionMode) -> Result<BrocadeSession, Error> {
        BrocadeSession::open(
            self.ip,
            self.port,
            &self.username,
            &self.password,
            self.options.clone(),
            mode,
        )
        .await
    }
    pub async fn with_session<F, R>(&self, mode: ExecutionMode, callback: F) -> Result<R, Error>
    where
        F: FnOnce(
            &mut BrocadeSession,
        ) -> std::pin::Pin<
            Box<dyn std::future::Future<Output = Result<R, Error>> + Send + '_>,
        >,
    {
        let mut session = self.open_session(mode).await?;
        let result = callback(&mut session).await;
        session.close().await?;
        result
    }
    pub async fn run_command(&self, command: &str, mode: ExecutionMode) -> Result<String, Error> {
        let mut session = self.open_session(mode).await?;
        let result = session.run_command(command).await;
        session.close().await?;
        result
    }
    pub async fn run_commands(
        &self,
        commands: Vec<String>,
        mode: ExecutionMode,
    ) -> Result<(), Error> {
        let mut session = self.open_session(mode).await?;
        let result = session.run_commands(commands).await;
        session.close().await?;
        result
    }
 }
 pub struct BrocadeSession {
    pub channel: russh::Channel<russh::client::Msg>,
    pub mode: ExecutionMode,
    pub options: BrocadeOptions,
 }
 impl BrocadeSession {
    pub async fn open(
        ip: IpAddr,
        port: u16,
        username: &str,
        password: &str,
        options: BrocadeOptions,
        mode: ExecutionMode,
    ) -> Result<Self, Error> {
        let client = ssh::create_client(ip, port, username, password, &options).await?;
        let mut channel = client.channel_open_session().await?;
        channel
            .request_pty(false, "vt100", 80, 24, 0, 0, &[])
            .await?;
        channel.request_shell(false).await?;
        wait_for_shell_ready(&mut channel, &options.timeouts).await?;
        if let ExecutionMode::Privileged = mode {
            try_elevate_session(&mut channel, username, password, &options.timeouts).await?;
        }
        Ok(Self {
            channel,
            mode,
            options,
        })
    }
    pub async fn close(&mut self) -> Result<(), Error> {
        debug!("[Brocade] Closing session...");
        self.channel.data(&b"exit\n"[..]).await?;
        if let ExecutionMode::Privileged = self.mode {
            self.channel.data(&b"exit\n"[..]).await?;
        }
        let start = Instant::now();
        while start.elapsed() < self.options.timeouts.cleanup {
            match timeout(self.options.timeouts.message_wait, self.channel.wait()).await {
                Ok(Some(ChannelMsg::Close)) => break,
                Ok(Some(_)) => continue,
                Ok(None) | Err(_) => break,
            }
        }
        debug!("[Brocade] Session closed.");
        Ok(())
    }
    pub async fn run_command(&mut self, command: &str) -> Result<String, Error> {
        debug!("[Brocade] Running command: '{command}'...");
        self.channel
            .data(format!("{}\n", command).as_bytes())
            .await?;
        tokio::time::sleep(Duration::from_millis(100)).await;
        let output = self.collect_command_output().await?;
        let output = String::from_utf8(output)
            .map_err(|_| Error::UnexpectedError("Invalid UTF-8 in command output".to_string()))?;
        self.check_for_command_errors(&output, command)?;
        Ok(output)
    }
    pub async fn run_commands(&mut self, commands: Vec<String>) -> Result<(), Error> {
        for command in commands {
            self.run_command(&command).await?;
        }
        Ok(())
    }
    pub async fn collect_command_output(&mut self) -> Result<Vec<u8>, Error> {
        let mut output = Vec::new();
        let start = Instant::now();
        let read_timeout = Duration::from_millis(500);
        let log_interval = Duration::from_secs(3);
        let mut last_log = Instant::now();
        loop {
            if start.elapsed() > self.options.timeouts.command_execution {
                return Err(Error::TimeoutError(
                    "Timeout waiting for command completion.".into(),
                ));
            }
            if start.elapsed() > Duration::from_secs(5) && last_log.elapsed() > log_interval {
                info!("[Brocade] Waiting for command output...");
                last_log = Instant::now();
            }
            match timeout(read_timeout, self.channel.wait()).await {
                Ok(Some(ChannelMsg::Data { data } | ChannelMsg::ExtendedData { data, .. })) => {
                    output.extend_from_slice(&data);
                    let current_output = String::from_utf8_lossy(&output);
                    if current_output.contains('>') || current_output.contains('#') {
                        return Ok(output);
                    }
                }
                Ok(Some(ChannelMsg::Eof | ChannelMsg::Close)) => return Ok(output),
                Ok(Some(ChannelMsg::ExitStatus { exit_status })) => {
                    debug!("[Brocade] Command exit status: {exit_status}");
                }
                Ok(Some(_)) => continue,
                Ok(None) | Err(_) => {
                    if output.is_empty() {
                        if let Ok(None) = timeout(read_timeout, self.channel.wait()).await {
                            break;
                        }
                        continue;
                    }
                    tokio::time::sleep(Duration::from_millis(100)).await;
                    let current_output = String::from_utf8_lossy(&output);
                    if current_output.contains('>') || current_output.contains('#') {
                        return Ok(output);
                    }
                }
            }
        }
        Ok(output)
    }
    pub fn check_for_command_errors(&self, output: &str, command: &str) -> Result<(), Error> {
        const ERROR_PATTERNS: &[&str] = &[
            "invalid input",
            "syntax error",
            "command not found",
            "unknown command",
            "permission denied",
            "access denied",
            "authentication failed",
            "configuration error",
            "failed to",
            "error:",
        ];
        let output_lower = output.to_lowercase();
        if ERROR_PATTERNS.iter().any(|&p| output_lower.contains(p)) {
            return Err(Error::CommandError(format!(
                "Command '{command}' failed: {}",
                output.trim()
            )));
        }
        if !command.starts_with("show") && output.trim().is_empty() {
            return Err(Error::CommandError(format!(
                "Command '{command}' produced no output"
            )));
        }
        Ok(())
    }
 }
 pub async fn wait_for_shell_ready(
    channel: &mut russh::Channel<russh::client::Msg>,
    timeouts: &TimeoutConfig,
 ) -> Result<(), Error> {
    let mut buffer = Vec::new();
    let start = Instant::now();
    while start.elapsed() < timeouts.shell_ready {
        match timeout(timeouts.message_wait, channel.wait()).await {
            Ok(Some(ChannelMsg::Data { data })) => {
                buffer.extend_from_slice(&data);
                let output = String::from_utf8_lossy(&buffer);
                if output.ends_with('>') || output.ends_with('#') {
                    debug!("[Brocade] Shell ready");
                    return Ok(());
                }
            }
            Ok(Some(_)) => continue,
            Ok(None) => break,
            Err(_) => continue,
        }
    }
    Ok(())
 }
 pub async fn try_elevate_session(
    channel: &mut russh::Channel<russh::client::Msg>,
    username: &str,
    password: &str,
    timeouts: &TimeoutConfig,
 ) -> Result<(), Error> {
    channel.data(&b"enable\n"[..]).await?;
    let start = Instant::now();
    let mut buffer = Vec::new();
    while start.elapsed() < timeouts.shell_ready {
        match timeout(timeouts.message_wait, channel.wait()).await {
            Ok(Some(ChannelMsg::Data { data })) => {
                buffer.extend_from_slice(&data);
                let output = String::from_utf8_lossy(&buffer);
                if output.ends_with('#') {
                    debug!("[Brocade] Privileged mode established");
                    return Ok(());
                }
                if output.contains("User Name:") {
                    channel.data(format!("{}\n", username).as_bytes()).await?;
                    buffer.clear();
                } else if output.contains("Password:") {
                    channel.data(format!("{}\n", password).as_bytes()).await?;
                    buffer.clear();
                } else if output.contains('>') {
                    return Err(Error::AuthenticationError(
                        "Enable authentication failed".into(),
                    ));
                }
            }
            Ok(Some(_)) => continue,
            Ok(None) => break,
            Err(_) => continue,
        }
    }
    let output = String::from_utf8_lossy(&buffer);
    if output.ends_with('#') {
        debug!("[Brocade] Privileged mode established");
        Ok(())
    } else {
        Err(Error::AuthenticationError(format!(
            "Enable failed. Output:\n{output}"
        )))
    }
 }
--- a/brocade/src/ssh.rs
+++ b/brocade/src/ssh.rs
@@ -1,113 +0,0 @@
 use std::borrow::Cow;
 use std::sync::Arc;
 use async_trait::async_trait;
 use russh::client::Handler;
 use russh::kex::DH_G1_SHA1;
 use russh::kex::ECDH_SHA2_NISTP256;
 use russh_keys::key::SSH_RSA;
 use super::BrocadeOptions;
 use super::Error;
 #[derive(Default, Clone, Debug)]
 pub struct SshOptions {
    pub preferred_algorithms: russh::Preferred,
 }
 impl SshOptions {
    fn ecdhsa_sha2_nistp256() -> Self {
        Self {
            preferred_algorithms: russh::Preferred {
                kex: Cow::Borrowed(&[ECDH_SHA2_NISTP256]),
                key: Cow::Borrowed(&[SSH_RSA]),
                ..Default::default()
            },
        }
    }
    fn legacy() -> Self {
        Self {
            preferred_algorithms: russh::Preferred {
                kex: Cow::Borrowed(&[DH_G1_SHA1]),
                key: Cow::Borrowed(&[SSH_RSA]),
                ..Default::default()
            },
        }
    }
 }
 pub struct Client;
 #[async_trait]
 impl Handler for Client {
    type Error = Error;
    async fn check_server_key(
        &mut self,
        _server_public_key: &russh_keys::key::PublicKey,
    ) -> Result<bool, Self::Error> {
        Ok(true)
    }
 }
 pub async fn try_init_client(
    username: &str,
    password: &str,
    ip: &std::net::IpAddr,
    base_options: BrocadeOptions,
 ) -> Result<BrocadeOptions, Error> {
    let ssh_options = vec![
        SshOptions::default(),
        SshOptions::ecdhsa_sha2_nistp256(),
        SshOptions::legacy(),
    ];
    for ssh in ssh_options {
        let opts = BrocadeOptions {
            ssh,
            ..base_options.clone()
        };
        let client = create_client(*ip, 22, username, password, &opts).await;
        match client {
            Ok(_) => {
                return Ok(opts);
            }
            Err(e) => match e {
                Error::NetworkError(e) => {
                    if e.contains("No common key exchange algorithm") {
                        continue;
                    } else {
                        return Err(Error::NetworkError(e));
                    }
                }
                _ => return Err(e),
            },
        }
    }
    Err(Error::NetworkError(
        "Could not establish ssh connection: wrong key exchange algorithm)".to_string(),
    ))
 }
 pub async fn create_client(
    ip: std::net::IpAddr,
    port: u16,
    username: &str,
    password: &str,
    options: &BrocadeOptions,
 ) -> Result<russh::client::Handle<Client>, Error> {
    let config = russh::client::Config {
        preferred: options.ssh.preferred_algorithms.clone(),
        ..Default::default()
    };
    let mut client = russh::client::connect(Arc::new(config), (ip, port), Client {}).await?;
    if !client.authenticate_password(username, password).await? {
        return Err(Error::AuthenticationError(
            "ssh authentication failed".to_string(),
        ));
    }
    Ok(client)
 }
--- a/examples/okd_installation/src/topology.rs
+++ b/examples/okd_installation/src/topology.rs
@@ -1,6 +1,6 @@
 use cidr::Ipv4Cidr;
 use harmony::{
-    hardware::{Location, SwitchGroup},
+    hardware::{FirewallGroup, HostCategory, Location, PhysicalHost, SwitchGroup},
    infra::opnsense::OPNSenseManagementInterface,
    inventory::Inventory,
    topology::{HAClusterTopology, LogicalHost, UnmanagedRouter},
--- a/harmony/Cargo.toml
+++ b/harmony/Cargo.toml
@@ -77,8 +77,6 @@ harmony_secret = { path = "../harmony_secret" }
 askama.workspace = true
 sqlx.workspace = true
 inquire.workspace = true
 brocade = { path = "../brocade" }
 [dev-dependencies]
 pretty_assertions.workspace = true
 assertor.workspace = true
--- a/harmony/src/domain/hardware/mod.rs
+++ b/harmony/src/domain/hardware/mod.rs
@@ -12,11 +12,11 @@ pub type FirewallGroup = Vec<PhysicalHost>;
 pub struct PhysicalHost {
    pub id: Id,
    pub category: HostCategory,
-    pub network: Vec<NetworkInterface>, // FIXME: Don't use harmony_inventory_agent::NetworkInterface
+    pub network: Vec<NetworkInterface>,
-    pub storage: Vec<StorageDrive>,     // FIXME: Don't use harmony_inventory_agent::StorageDrive
+    pub storage: Vec<StorageDrive>,
    pub labels: Vec<Label>,
-    pub memory_modules: Vec<MemoryModule>, // FIXME: Don't use harmony_inventory_agent::MemoryModule
+    pub memory_modules: Vec<MemoryModule>,
-    pub cpus: Vec<CPU>,                    // FIXME: Don't use harmony_inventory_agent::CPU
+    pub cpus: Vec<CPU>,
 }
 impl PhysicalHost {
--- a/harmony/src/domain/topology/ha_cluster.rs
+++ b/harmony/src/domain/topology/ha_cluster.rs
@@ -1,29 +1,12 @@
 use async_trait::async_trait;
 use brocade::BrocadeOptions;
 use harmony_macros::ip;
 use harmony_secret::SecretManager;
 use harmony_types::net::MacAddress;
 use harmony_types::net::Url;
 use harmony_types::switch::PortLocation;
 use k8s_openapi::api::core::v1::Namespace;
 use kube::api::ObjectMeta;
 use log::debug;
 use log::info;
 use crate::data::FileContent;
 use crate::executors::ExecutorError;
 use crate::hardware::PhysicalHost;
 use crate::infra::brocade::BrocadeSwitchAuth;
 use crate::infra::brocade::BrocadeSwitchClient;
 use crate::modules::okd::crd::InstallPlanApproval;
 use crate::modules::okd::crd::OperatorGroup;
 use crate::modules::okd::crd::OperatorGroupSpec;
 use crate::modules::okd::crd::Subscription;
 use crate::modules::okd::crd::SubscriptionSpec;
 use crate::modules::okd::crd::nmstate;
 use crate::modules::okd::crd::nmstate::NMState;
 use crate::modules::okd::crd::nmstate::NodeNetworkConfigurationPolicy;
 use crate::modules::okd::crd::nmstate::NodeNetworkConfigurationPolicySpec;
 use crate::topology::PxeOptions;
 use super::DHCPStaticEntry;
@@ -32,7 +15,6 @@ use super::DnsRecord;
 use super::DnsRecordType;
 use super::DnsServer;
 use super::Firewall;
 use super::HostNetworkConfig;
 use super::HttpServer;
 use super::IpAddress;
 use super::K8sclient;
@@ -42,15 +24,10 @@ use super::LogicalHost;
 use super::PreparationError;
 use super::PreparationOutcome;
 use super::Router;
 use super::Switch;
 use super::SwitchClient;
 use super::SwitchError;
 use super::TftpServer;
 use super::Topology;
 use super::k8s::K8sClient;
 use std::collections::BTreeMap;
 use std::net::IpAddr;
 use std::sync::Arc;
 #[derive(Debug, Clone)]
@@ -112,231 +89,6 @@ impl HAClusterTopology {
            .to_string()
    }
    async fn ensure_nmstate_operator_installed(&self) -> Result<(), String> {
        // FIXME: Find a way to check nmstate is already available (get pod -n openshift-nmstate)
        debug!("Installing NMState operator...");
        let k8s_client = self.k8s_client().await?;
        let nmstate_namespace = Namespace {
            metadata: ObjectMeta {
                name: Some("openshift-nmstate".to_string()),
                finalizers: Some(vec!["kubernetes".to_string()]),
                ..Default::default()
            },
            ..Default::default()
        };
        debug!("Creating NMState namespace: {nmstate_namespace:#?}");
        k8s_client
            .apply(&nmstate_namespace, None)
            .await
            .map_err(|e| e.to_string())?;
        let nmstate_operator_group = OperatorGroup {
            metadata: ObjectMeta {
                name: Some("openshift-nmstate".to_string()),
                namespace: Some("openshift-nmstate".to_string()),
                ..Default::default()
            },
            spec: OperatorGroupSpec {
                target_namespaces: vec!["openshift-nmstate".to_string()],
            },
        };
        debug!("Creating NMState operator group: {nmstate_operator_group:#?}");
        k8s_client
            .apply(&nmstate_operator_group, None)
            .await
            .map_err(|e| e.to_string())?;
        let nmstate_subscription = Subscription {
            metadata: ObjectMeta {
                name: Some("kubernetes-nmstate-operator".to_string()),
                namespace: Some("openshift-nmstate".to_string()),
                ..Default::default()
            },
            spec: SubscriptionSpec {
                channel: Some("stable".to_string()),
                install_plan_approval: Some(InstallPlanApproval::Automatic),
                name: "kubernetes-nmstate-operator".to_string(),
                source: "redhat-operators".to_string(),
                source_namespace: "openshift-marketplace".to_string(),
            },
        };
        debug!("Subscribing to NMState Operator: {nmstate_subscription:#?}");
        k8s_client
            .apply(&nmstate_subscription, None)
            .await
            .map_err(|e| e.to_string())?;
        let nmstate = NMState {
            metadata: ObjectMeta {
                name: Some("nmstate".to_string()),
                ..Default::default()
            },
            ..Default::default()
        };
        debug!("Creating NMState: {nmstate:#?}");
        k8s_client
            .apply(&nmstate, None)
            .await
            .map_err(|e| e.to_string())?;
        Ok(())
    }
    fn get_next_bond_id(&self) -> u8 {
        42 // FIXME: Find a better way to declare the bond id
    }
    async fn configure_bond(
        &self,
        host: &PhysicalHost,
        config: &HostNetworkConfig,
    ) -> Result<(), SwitchError> {
        self.ensure_nmstate_operator_installed()
            .await
            .map_err(|e| {
                SwitchError::new(format!(
                    "Can't configure bond, NMState operator not available: {e}"
                ))
            })?;
        let bond_config = self.create_bond_configuration(host, config);
        debug!("Configuring bond for host {host:?}: {bond_config:#?}");
        self.k8s_client()
            .await
            .unwrap()
            .apply(&bond_config, None)
            .await
            .unwrap();
        todo!()
    }
    fn create_bond_configuration(
        &self,
        host: &PhysicalHost,
        config: &HostNetworkConfig,
    ) -> NodeNetworkConfigurationPolicy {
        let host_name = host.id.clone();
        let bond_id = self.get_next_bond_id();
        let bond_name = format!("bond{bond_id}");
        let mut bond_mtu: Option<u32> = None;
        let mut bond_mac_address: Option<String> = None;
        let mut bond_ports = Vec::new();
        let mut interfaces: Vec<nmstate::InterfaceSpec> = Vec::new();
        for switch_port in &config.switch_ports {
            let interface_name = switch_port.interface.name.clone();
            interfaces.push(nmstate::InterfaceSpec {
                name: interface_name.clone(),
                description: Some(format!("Member of bond {bond_name}")),
                r#type: "ethernet".to_string(),
                state: "up".to_string(),
                mtu: Some(switch_port.interface.mtu),
                mac_address: Some(switch_port.interface.mac_address.to_string()),
                ipv4: Some(nmstate::IpStackSpec {
                    enabled: Some(false),
                    ..Default::default()
                }),
                ipv6: Some(nmstate::IpStackSpec {
                    enabled: Some(false),
                    ..Default::default()
                }),
                link_aggregation: None,
                ..Default::default()
            });
            bond_ports.push(interface_name);
            // Use the first port's details for the bond mtu and mac address
            if bond_mtu.is_none() {
                bond_mtu = Some(switch_port.interface.mtu);
            }
            if bond_mac_address.is_none() {
                bond_mac_address = Some(switch_port.interface.mac_address.to_string());
            }
        }
        interfaces.push(nmstate::InterfaceSpec {
            name: bond_name.clone(),
            description: Some(format!("Network bond for host {host_name}")),
            r#type: "bond".to_string(),
            state: "up".to_string(),
            mtu: bond_mtu,
            mac_address: bond_mac_address,
            ipv4: Some(nmstate::IpStackSpec {
                dhcp: Some(true),
                enabled: Some(true),
                ..Default::default()
            }),
            ipv6: Some(nmstate::IpStackSpec {
                dhcp: Some(true),
                autoconf: Some(true),
                enabled: Some(true),
                ..Default::default()
            }),
            link_aggregation: Some(nmstate::BondSpec {
                mode: "802.3ad".to_string(),
                ports: bond_ports,
                ..Default::default()
            }),
            ..Default::default()
        });
        NodeNetworkConfigurationPolicy {
            metadata: ObjectMeta {
                name: Some(format!("{host_name}-bond-config")),
                ..Default::default()
            },
            spec: NodeNetworkConfigurationPolicySpec {
                node_selector: Some(BTreeMap::from([(
                    "kubernetes.io/hostname".to_string(),
                    host_name.to_string(),
                )])),
                desired_state: nmstate::DesiredStateSpec { interfaces },
            },
        }
    }
    async fn get_switch_client(&self) -> Result<Box<dyn SwitchClient>, SwitchError> {
        let auth = SecretManager::get_or_prompt::<BrocadeSwitchAuth>()
            .await
            .map_err(|e| SwitchError::new(format!("Failed to get credentials: {e}")))?;
        // FIXME: We assume Brocade switches
        let switches: Vec<IpAddr> = self.switch.iter().map(|s| s.ip).collect();
        let brocade_options = Some(BrocadeOptions {
            dry_run: *crate::config::DRY_RUN,
            ..Default::default()
        });
        let client =
            BrocadeSwitchClient::init(&switches, &auth.username, &auth.password, brocade_options)
                .await
                .map_err(|e| SwitchError::new(format!("Failed to connect to switch: {e}")))?;
        Ok(Box::new(client))
    }
    async fn configure_port_channel(
        &self,
        host: &PhysicalHost,
        config: &HostNetworkConfig,
    ) -> Result<(), SwitchError> {
        debug!("Configuring port channel: {config:#?}");
        let client = self.get_switch_client().await?;
        let switch_ports = config.switch_ports.iter().map(|s| s.port.clone()).collect();
        client
            .configure_port_channel(&format!("Harmony_{}", host.id), switch_ports)
            .await
            .map_err(|e| SwitchError::new(format!("Failed to configure switch: {e}")))?;
        Ok(())
    }
    pub fn autoload() -> Self {
        let dummy_infra = Arc::new(DummyInfra {});
        let dummy_host = LogicalHost {
@@ -511,27 +263,6 @@ impl HttpServer for HAClusterTopology {
    }
 }
 #[async_trait]
 impl Switch for HAClusterTopology {
    async fn get_port_for_mac_address(
        &self,
        mac_address: &MacAddress,
    ) -> Result<Option<PortLocation>, SwitchError> {
        let client = self.get_switch_client().await?;
        let port = client.find_port(mac_address).await?;
        Ok(port)
    }
    async fn configure_host_network(
        &self,
        host: &PhysicalHost,
        config: HostNetworkConfig,
    ) -> Result<(), SwitchError> {
        // self.configure_bond(host, &config).await?;
        self.configure_port_channel(host, &config).await
    }
 }
 #[derive(Debug)]
 pub struct DummyInfra;
@@ -601,8 +332,8 @@ impl DhcpServer for DummyInfra {
    }
    async fn set_dhcp_range(
        &self,
-        _start: &IpAddress,
+        start: &IpAddress,
-        _end: &IpAddress,
+        end: &IpAddress,
    ) -> Result<(), ExecutorError> {
        unimplemented!("{}", UNIMPLEMENTED_DUMMY_INFRA)
    }
--- a/harmony/src/domain/topology/k8s.rs
+++ b/harmony/src/domain/topology/k8s.rs
@@ -1,3 +1,5 @@
 use std::time::Duration;
 use derive_new::new;
 use k8s_openapi::{
    ClusterResourceScope, NamespaceResourceScope,
@@ -8,6 +10,7 @@ use kube::{
    api::{Api, AttachParams, DeleteParams, ListParams, Patch, PatchParams, ResourceExt},
    config::{KubeConfigOptions, Kubeconfig},
    core::ErrorResponse,
    error::DiscoveryError,
    runtime::reflector::Lookup,
 };
 use kube::{api::DynamicObject, runtime::conditions};
@@ -17,9 +20,9 @@ use kube::{
 };
 use log::{debug, error, trace};
 use serde::{Serialize, de::DeserializeOwned};
-use serde_json::{Value, json};
+use serde_json::json;
 use similar::TextDiff;
-use tokio::io::AsyncReadExt;
+use tokio::{io::AsyncReadExt, time::sleep};
 #[derive(new, Clone)]
 pub struct K8sClient {
@@ -65,7 +68,7 @@ impl K8sClient {
        } else {
            Api::default_namespaced_with(self.client.clone(), &gvk)
        };
-        Ok(resource.get(name).await?)
+        resource.get(name).await
    }
    pub async fn get_deployment(
@@ -78,7 +81,7 @@ impl K8sClient {
        } else {
            Api::default_namespaced(self.client.clone())
        };
-        Ok(deps.get_opt(name).await?)
+        deps.get_opt(name).await
    }
    pub async fn get_pod(&self, name: &str, namespace: Option<&str>) -> Result<Option<Pod>, Error> {
@@ -87,7 +90,7 @@ impl K8sClient {
        } else {
            Api::default_namespaced(self.client.clone())
        };
-        Ok(pods.get_opt(name).await?)
+        pods.get_opt(name).await
    }
    pub async fn scale_deployment(
@@ -153,6 +156,39 @@ impl K8sClient {
        }
    }
    pub async fn wait_for_pod_ready(
        &self,
        pod_name: &str,
        namespace: Option<&str>,
    ) -> Result<(), Error> {
        let mut elapsed = 0;
        let interval = 5; // seconds between checks
        let timeout_secs = 120;
        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 elapsed >= timeout_secs {
                return Err(Error::Discovery(DiscoveryError::MissingResource(format!(
                    "'{}' in ns '{}' did not become ready within {}s",
                    pod_name,
                    namespace.unwrap(),
                    timeout_secs
                ))));
            }
            sleep(Duration::from_secs(interval)).await;
            elapsed += interval;
        }
    }
    /// Will execute a commond in the first pod found that matches the specified label
    /// '{label}={name}'
    pub async fn exec_app_capture_output(
@@ -199,7 +235,7 @@ impl K8sClient {
                if let Some(s) = status.status {
                    let mut stdout_buf = String::new();
-                    if let Some(mut stdout) = process.stdout().take() {
+                    if let Some(mut stdout) = process.stdout() {
                        stdout
                            .read_to_string(&mut stdout_buf)
                            .await
@@ -419,9 +455,12 @@ impl K8sClient {
            .as_str()
            .expect("couldn't get kind as str");
-        let split: Vec<&str> = api_version.splitn(2, "/").collect();
+        let mut it = api_version.splitn(2, '/');
-        let g = split[0];
+        let first = it.next().unwrap();
-        let v = split[1];
+        let (g, v) = match it.next() {
            Some(second) => (first, second),
            None => ("", first),
        };
        let gvk = GroupVersionKind::gvk(g, v, kind);
        let api_resource = ApiResource::from_gvk(&gvk);
--- a/harmony/src/domain/topology/k8s_anywhere.rs
+++ b/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 {
-            return Ok(());
+            Ok(())
        } else {
-            return Err(PreparationError::new(
+            Err(PreparationError::new(
                "openshift-ingress-operator not available".to_string(),
-            ));
+            ))
        }
    }
--- a/harmony/src/domain/topology/network.rs
+++ b/harmony/src/domain/topology/network.rs
@@ -1,14 +1,10 @@
-use std::{error::Error, net::Ipv4Addr, str::FromStr, sync::Arc};
+use std::{net::Ipv4Addr, str::FromStr, sync::Arc};
 use async_trait::async_trait;
-use derive_new::new;
+use harmony_types::net::{IpAddress, MacAddress};
 use harmony_types::{
    net::{IpAddress, MacAddress},
    switch::PortLocation,
 };
 use serde::Serialize;
-use crate::{executors::ExecutorError, hardware::PhysicalHost};
+use crate::executors::ExecutorError;
 use super::{LogicalHost, k8s::K8sClient};
@@ -176,66 +172,6 @@ impl FromStr for DnsRecordType {
    }
 }
 #[async_trait]
 pub trait Switch: Send + Sync {
    async fn get_port_for_mac_address(
        &self,
        mac_address: &MacAddress,
    ) -> Result<Option<PortLocation>, SwitchError>;
    async fn configure_host_network(
        &self,
        host: &PhysicalHost,
        config: HostNetworkConfig,
    ) -> Result<(), SwitchError>;
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct HostNetworkConfig {
    pub switch_ports: Vec<SwitchPort>,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct SwitchPort {
    pub interface: NetworkInterface,
    pub port: PortLocation,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct NetworkInterface {
    pub name: String,
    pub mac_address: MacAddress,
    pub speed_mbps: Option<u32>,
    pub mtu: u32,
 }
 #[derive(Debug, Clone, new)]
 pub struct SwitchError {
    msg: String,
 }
 impl std::fmt::Display for SwitchError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&self.msg)
    }
 }
 impl Error for SwitchError {}
 #[async_trait]
 pub trait SwitchClient: Send + Sync {
    async fn find_port(
        &self,
        mac_address: &MacAddress,
    ) -> Result<Option<PortLocation>, SwitchError>;
    async fn configure_port_channel(
        &self,
        channel_name: &str,
        switch_ports: Vec<PortLocation>,
    ) -> Result<u8, SwitchError>;
 }
 #[cfg(test)]
 mod test {
    use std::sync::Arc;
--- a/harmony/src/infra/brocade.rs
+++ b/harmony/src/infra/brocade.rs
@@ -1,81 +0,0 @@
 use async_trait::async_trait;
 use brocade::{BrocadeClient, BrocadeOptions};
 use harmony_secret::Secret;
 use harmony_types::{
    net::{IpAddress, MacAddress},
    switch::{PortDeclaration, PortLocation},
 };
 use serde::{Deserialize, Serialize};
 use crate::topology::{SwitchClient, SwitchError};
 pub struct BrocadeSwitchClient {
    brocade: Box<dyn BrocadeClient + Send + Sync>,
 }
 impl BrocadeSwitchClient {
    pub async fn init(
        ip_addresses: &[IpAddress],
        username: &str,
        password: &str,
        options: Option<BrocadeOptions>,
    ) -> Result<Self, brocade::Error> {
        let brocade = brocade::init(ip_addresses, 22, username, password, options).await?;
        Ok(Self { brocade })
    }
 }
 #[async_trait]
 impl SwitchClient for BrocadeSwitchClient {
    async fn find_port(
        &self,
        mac_address: &MacAddress,
    ) -> Result<Option<PortLocation>, SwitchError> {
        let table = self
            .brocade
            .show_mac_address_table()
            .await
            .map_err(|e| SwitchError::new(format!("{e}")))?;
        let port = table
            .iter()
            .find(|entry| entry.mac_address == *mac_address)
            .map(|entry| match &entry.port {
                PortDeclaration::Single(port_location) => Ok(port_location.clone()),
                _ => Err(SwitchError::new(
                    "Multiple ports found for MAC address".into(),
                )),
            });
        match port {
            Some(Ok(p)) => Ok(Some(p)),
            Some(Err(e)) => Err(e),
            None => Ok(None),
        }
    }
    async fn configure_port_channel(
        &self,
        channel_name: &str,
        switch_ports: Vec<PortLocation>,
    ) -> Result<u8, SwitchError> {
        let channel_id = self
            .brocade
            .find_available_channel_id()
            .await
            .map_err(|e| SwitchError::new(format!("{e}")))?;
        self.brocade
            .create_port_channel(channel_id, channel_name, &switch_ports)
            .await
            .map_err(|e| SwitchError::new(format!("{e}")))?;
        Ok(channel_id)
    }
 }
 #[derive(Secret, Serialize, Deserialize, Debug)]
 pub struct BrocadeSwitchAuth {
    pub username: String,
    pub password: String,
 }
--- a/harmony/src/infra/inventory/mod.rs
+++ b/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?,
        ))
    }
 }
--- a/harmony/src/infra/mod.rs
+++ b/harmony/src/infra/mod.rs
@@ -1,4 +1,3 @@
 pub mod brocade;
 pub mod executors;
 pub mod hp_ilo;
 pub mod intel_amt;
--- a/harmony/src/infra/opnsense/http.rs
+++ b/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.to_string())
+                format!("{OPNSENSE_HTTP_ROOT_PATH}/{}", path)
            }
            crate::data::FilePath::Absolute(path) => {
                return Err(ExecutorError::ConfigurationError(format!(
--- a/harmony/src/infra/opnsense/load_balancer.rs
+++ b/harmony/src/infra/opnsense/load_balancer.rs
@@ -182,16 +182,12 @@ 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() {
+            if let Some(checkport) = haproxy_health_check.checkport.content.as_ref()
-                if !checkport.is_empty() {
+                && !checkport.is_empty()
-                    return Some(HealthCheck::TCP(Some(checkport.parse().unwrap_or_else(
+            {
-                        |_| {
+                return Some(HealthCheck::TCP(Some(checkport.parse().unwrap_or_else(
-                            panic!(
+                    |_| panic!("HAProxy check port should be a valid port number, got {checkport}"),
-                                "HAProxy check port should be a valid port number, got {checkport}"
+                ))));
                            )
                        },
                    ))));
                }
            }
            Some(HealthCheck::TCP(None))
        }
--- a/harmony/src/infra/opnsense/mod.rs
+++ b/harmony/src/infra/opnsense/mod.rs
@@ -8,7 +8,6 @@ mod tftp;
 use std::sync::Arc;
 pub use management::*;
 use opnsense_config_xml::Host;
 use tokio::sync::RwLock;
 use crate::{executors::ExecutorError, topology::LogicalHost};
--- a/harmony/src/modules/application/features/helm_argocd_score.rs
+++ b/harmony/src/modules/application/features/helm_argocd_score.rs
@@ -1,10 +1,8 @@
 use async_trait::async_trait;
-use kube::{Api, api::GroupVersionKind};
+use kube::api::GroupVersionKind;
 use log::{debug, warn};
 use non_blank_string_rs::NonBlankString;
 use serde::Serialize;
-use serde::de::DeserializeOwned;
+use std::{str::FromStr, sync::Arc};
 use std::{process::Command, str::FromStr, sync::Arc};
 use crate::{
    data::Version,
@@ -12,10 +10,7 @@ use crate::{
    inventory::Inventory,
    modules::helm::chart::{HelmChartScore, HelmRepository},
    score::Score,
-    topology::{
+    topology::{HelmCommand, K8sclient, Topology, ingress::Ingress, k8s::K8sClient},
        HelmCommand, K8sclient, PreparationError, PreparationOutcome, Topology, ingress::Ingress,
        k8s::K8sClient,
    },
 };
 use harmony_types::id::Id;
@@ -119,13 +114,13 @@ impl ArgoInterpret {
                match ic.data["status"]["domain"].as_str() {
                    Some(domain) => return Ok(domain.to_string()),
-                    None => return Err(InterpretError::new("Could not find domain".to_string())),
+                    None => Err(InterpretError::new("Could not find domain".to_string())),
                }
            }
            false => {
                todo!()
            }
-        };
+        }
    }
 }
--- a/harmony/src/modules/application/features/packaging_deployment.rs
+++ b/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: format!("{}", self.application.name()),
+                    namespace: self.application.name().to_string(),
                    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: format!("{}", self.application.name()),
+                        name: self.application.name().to_string(),
-                        namespace: format!("{}", self.application.name()),
+                        namespace: self.application.name().to_string(),
                    })],
                };
                score
--- a/harmony/src/modules/application/features/rhob_monitoring.rs
+++ b/harmony/src/modules/application/features/rhob_monitoring.rs
@@ -3,7 +3,6 @@ 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;
--- a/harmony/src/modules/application/rust.rs
+++ b/harmony/src/modules/application/rust.rs
@@ -194,10 +194,10 @@ impl RustWebapp {
                    Some(body_full(tar_data.into())),
                );
-                while let Some(mut msg) = image_build_stream.next().await {
+                while let Some(msg) = image_build_stream.next().await {
                    trace!("Got bollard msg {msg:?}");
                    match msg {
-                        Ok(mut msg) => {
+                        Ok(msg) => {
                            if let Some(progress) = msg.progress_detail {
                                info!(
                                    "Build progress {}/{}",
@@ -511,25 +511,23 @@ ingress:
        fs::write(chart_dir.join("values.yaml"), values_yaml)?;
        // Create templates/_helpers.tpl
-        let helpers_tpl = format!(
+        let helpers_tpl = r#"
-            r#"
+{{/*
 {{{{/*
 Expand the name of the chart.
-*/}}}}
+*/}}
-{{{{- define "chart.name" -}}}}
+{{- define "chart.name" -}}
-{{{{- default .Chart.Name $.Values.nameOverride | trunc 63 | trimSuffix "-" }}}}
+{{- default .Chart.Name $.Values.nameOverride | trunc 63 | trimSuffix "-" }}
-{{{{- end }}}}
+{{- 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" -}}}}
+{{- define "chart.fullname" -}}
-{{{{- $name := default .Chart.Name $.Values.nameOverride }}}}
+{{- $name := default .Chart.Name $.Values.nameOverride }}
-{{{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" }}}}
+{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" }}
-{{{{- end }}}}
+{{- end }}
-"#
+"#.to_string();
        );
        fs::write(templates_dir.join("_helpers.tpl"), helpers_tpl)?;
        // Create templates/service.yaml
--- a/harmony/src/modules/helm/command.rs
+++ b/harmony/src/modules/helm/command.rs
@@ -66,8 +66,7 @@ impl HelmCommandExecutor {
            .is_none()
        {
            if self.chart.repo.is_none() {
-                return Err(std::io::Error::new(
+                return Err(std::io::Error::other(
                    ErrorKind::Other,
                    "Chart doesn't exist locally and no repo specified",
                ));
            }
@@ -107,10 +106,10 @@ impl HelmCommandExecutor {
    }
    pub fn run_command(mut self, mut args: Vec<String>) -> Result<Output, std::io::Error> {
-        if let Some(d) = self.debug {
+        if let Some(d) = self.debug
-            if d {
+            && d
-                args.push("--debug".to_string());
+        {
-            }
+            args.push("--debug".to_string());
        }
        let path = if let Some(p) = self.path {
@@ -234,28 +233,28 @@ impl HelmChart {
            args.push(kv);
        }
-        if let Some(crd) = self.include_crds {
+        if let Some(crd) = self.include_crds
-            if crd {
+            && crd
-                args.push("--include-crds".to_string());
+        {
-            }
+            args.push("--include-crds".to_string());
        }
-        if let Some(st) = self.skip_tests {
+        if let Some(st) = self.skip_tests
-            if st {
+            && st
-                args.push("--skip-tests".to_string());
+        {
-            }
+            args.push("--skip-tests".to_string());
        }
-        if let Some(sh) = self.skip_hooks {
+        if let Some(sh) = self.skip_hooks
-            if sh {
+            && sh
-                args.push("--no-hooks".to_string());
+        {
-            }
+            args.push("--no-hooks".to_string());
        }
-        if let Some(d) = self.debug {
+        if let Some(d) = self.debug
-            if d {
+            && d
-                args.push("--debug".to_string());
+        {
-            }
+            args.push("--debug".to_string());
        }
        args
--- a/harmony/src/modules/http.rs
+++ b/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?;
--- a/harmony/src/modules/inventory/discovery.rs
+++ b/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.to_string()
+                        e
                    )));
                }
            }
--- a/harmony/src/modules/monitoring/application_monitoring/rhobs_application_monitoring_score.rs
+++ b/harmony/src/modules/monitoring/application_monitoring/rhobs_application_monitoring_score.rs
@@ -9,9 +9,7 @@ use crate::{
    inventory::Inventory,
    modules::{
        application::Application,
-        monitoring::kube_prometheus::crd::{
+        monitoring::kube_prometheus::crd::rhob_alertmanager_config::RHOBObservability,
            crd_alertmanager_config::CRDPrometheus, rhob_alertmanager_config::RHOBObservability,
        },
        prometheus::prometheus::PrometheusApplicationMonitoring,
    },
    score::Score,
--- a/harmony/src/modules/monitoring/kube_prometheus/crd/rhob_monitoring_stack.rs
+++ b/harmony/src/modules/monitoring/kube_prometheus/crd/rhob_monitoring_stack.rs
@@ -1,12 +1,8 @@
 use std::collections::BTreeMap;
 use kube::CustomResource;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use crate::modules::monitoring::kube_prometheus::crd::rhob_prometheuses::{
+use crate::modules::monitoring::kube_prometheus::crd::rhob_prometheuses::LabelSelector;
    LabelSelector, PrometheusSpec,
 };
 /// MonitoringStack CRD for monitoring.rhobs/v1alpha1
 #[derive(CustomResource, Serialize, Deserialize, Debug, Clone, JsonSchema)]
--- a/harmony/src/modules/monitoring/mod.rs
+++ b/harmony/src/modules/monitoring/mod.rs
@@ -4,4 +4,5 @@ pub mod application_monitoring;
 pub mod grafana;
 pub mod kube_prometheus;
 pub mod ntfy;
 pub mod okd;
 pub mod prometheus;
--- a/harmony/src/modules/monitoring/okd/enable_user_workload.rs
+++ b/harmony/src/modules/monitoring/okd/enable_user_workload.rs
@@ -0,0 +1,149 @@
 use std::{collections::BTreeMap, sync::Arc};
 use crate::{
    data::Version,
    interpret::{Interpret, InterpretError, InterpretName, InterpretStatus, Outcome},
    inventory::Inventory,
    score::Score,
    topology::{K8sclient, Topology, k8s::K8sClient},
 };
 use async_trait::async_trait;
 use harmony_types::id::Id;
 use k8s_openapi::api::core::v1::ConfigMap;
 use kube::api::ObjectMeta;
 use serde::Serialize;
 #[derive(Clone, Debug, Serialize)]
 pub struct OpenshiftUserWorkloadMonitoring {}
 impl<T: Topology + K8sclient> Score<T> for OpenshiftUserWorkloadMonitoring {
    fn name(&self) -> String {
        "OpenshiftUserWorkloadMonitoringScore".to_string()
    }
    fn create_interpret(&self) -> Box<dyn Interpret<T>> {
        Box::new(OpenshiftUserWorkloadMonitoringInterpret {})
    }
 }
 #[derive(Clone, Debug, Serialize)]
 pub struct OpenshiftUserWorkloadMonitoringInterpret {}
 #[async_trait]
 impl<T: Topology + K8sclient> Interpret<T> for OpenshiftUserWorkloadMonitoringInterpret {
    async fn execute(
        &self,
        _inventory: &Inventory,
        topology: &T,
    ) -> Result<Outcome, InterpretError> {
        let client = topology.k8s_client().await.unwrap();
        self.update_cluster_monitoring_config_cm(&client).await?;
        self.update_user_workload_monitoring_config_cm(&client)
            .await?;
        self.verify_user_workload(&client).await?;
        Ok(Outcome::success(
            "successfully enabled user-workload-monitoring".to_string(),
        ))
    }
    fn get_name(&self) -> InterpretName {
        InterpretName::Custom("OpenshiftUserWorkloadMonitoring")
    }
    fn get_version(&self) -> Version {
        todo!()
    }
    fn get_status(&self) -> InterpretStatus {
        todo!()
    }
    fn get_children(&self) -> Vec<Id> {
        todo!()
    }
 }
 impl OpenshiftUserWorkloadMonitoringInterpret {
    pub async fn update_cluster_monitoring_config_cm(
        &self,
        client: &Arc<K8sClient>,
    ) -> Result<Outcome, InterpretError> {
        let mut data = BTreeMap::new();
        data.insert(
            "config.yaml".to_string(),
            r#"
 enableUserWorkload: true
 alertmanagerMain:
  enableUserAlertmanagerConfig: true
 "#
            .to_string(),
        );
        let cm = ConfigMap {
            metadata: ObjectMeta {
                name: Some("cluster-monitoring-config".to_string()),
                namespace: Some("openshift-monitoring".to_string()),
                ..Default::default()
            },
            data: Some(data),
            ..Default::default()
        };
        client.apply(&cm, Some("openshift-monitoring")).await?;
        Ok(Outcome::success(
            "updated cluster-monitoring-config-map".to_string(),
        ))
    }
    pub async fn update_user_workload_monitoring_config_cm(
        &self,
        client: &Arc<K8sClient>,
    ) -> Result<Outcome, InterpretError> {
        let mut data = BTreeMap::new();
        data.insert(
            "config.yaml".to_string(),
            r#"
 alertmanager: 
  enabled: true
  enableAlertmanagerConfig: true
 "#
            .to_string(),
        );
        let cm = ConfigMap {
            metadata: ObjectMeta {
                name: Some("user-workload-monitoring-config".to_string()),
                namespace: Some("openshift-user-workload-monitoring".to_string()),
                ..Default::default()
            },
            data: Some(data),
            ..Default::default()
        };
        client
            .apply(&cm, Some("openshift-user-workload-monitoring"))
            .await?;
        Ok(Outcome::success(
            "updated openshift-user-monitoring-config-map".to_string(),
        ))
    }
    pub async fn verify_user_workload(
        &self,
        client: &Arc<K8sClient>,
    ) -> Result<Outcome, InterpretError> {
        let namespace = "openshift-user-workload-monitoring";
        let alertmanager_name = "alertmanager-user-workload-0";
        let prometheus_name = "prometheus-user-workload-0";
        client
            .wait_for_pod_ready(alertmanager_name, Some(namespace))
            .await?;
        client
            .wait_for_pod_ready(prometheus_name, Some(namespace))
            .await?;
        Ok(Outcome::success(format!(
            "pods: {}, {} ready in ns: {}",
            alertmanager_name, prometheus_name, namespace
        )))
    }
 }
--- a/harmony/src/modules/monitoring/okd/mod.rs
+++ b/harmony/src/modules/monitoring/okd/mod.rs
@@ -0,0 +1 @@
 pub mod enable_user_workload;
--- a/harmony/src/modules/okd/bootstrap_02_bootstrap.rs
+++ b/harmony/src/modules/okd/bootstrap_02_bootstrap.rs
@@ -52,6 +52,12 @@ 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();
@@ -98,9 +104,9 @@ impl OKDSetup02BootstrapInterpret {
                InterpretError::new(format!("Failed to create okd installation directory : {e}"))
            })?;
        if !exit_status.success() {
-            return Err(InterpretError::new(format!(
+            return Err(InterpretError::new(
-                "Failed to create okd installation directory"
+                "Failed to create okd installation directory".to_string(),
-            )));
+            ));
        } else {
            info!(
                "Created OKD installation directory {}",
--- a/harmony/src/modules/okd/bootstrap_03_control_plane.rs
+++ b/harmony/src/modules/okd/bootstrap_03_control_plane.rs
@@ -5,10 +5,8 @@ use crate::{
    interpret::{Interpret, InterpretError, InterpretName, InterpretStatus, Outcome},
    inventory::{HostRole, Inventory},
    modules::{
-        dhcp::DhcpHostBindingScore,
+        dhcp::DhcpHostBindingScore, http::IPxeMacBootFileScore,
-        http::IPxeMacBootFileScore,
+        inventory::DiscoverHostForRoleScore, okd::templates::BootstrapIpxeTpl,
        inventory::DiscoverHostForRoleScore,
        okd::{host_network::HostNetworkConfigurationScore, templates::BootstrapIpxeTpl},
    },
    score::Score,
    topology::{HAClusterTopology, HostBinding},
@@ -30,7 +28,7 @@ pub struct OKDSetup03ControlPlaneScore {}
 impl Score<HAClusterTopology> for OKDSetup03ControlPlaneScore {
    fn create_interpret(&self) -> Box<dyn Interpret<HAClusterTopology>> {
-        Box::new(OKDSetup03ControlPlaneInterpret::new())
+        Box::new(OKDSetup03ControlPlaneInterpret::new(self.clone()))
    }
    fn name(&self) -> String {
@@ -40,15 +38,17 @@ impl Score<HAClusterTopology> for OKDSetup03ControlPlaneScore {
 #[derive(Debug, Clone)]
 pub struct OKDSetup03ControlPlaneInterpret {
    score: OKDSetup03ControlPlaneScore,
    version: Version,
    status: InterpretStatus,
 }
 impl OKDSetup03ControlPlaneInterpret {
-    pub fn new() -> Self {
+    pub fn new(score: OKDSetup03ControlPlaneScore) -> Self {
        let version = Version::from("1.0.0").unwrap();
        Self {
            version,
            score,
            status: InterpretStatus::QUEUED,
        }
    }
@@ -159,7 +159,7 @@ impl OKDSetup03ControlPlaneInterpret {
        }
        .to_string();
-        debug!("[ControlPlane] iPXE content template:\n{content}");
+        debug!("[ControlPlane] iPXE content template:\n{}", content);
        // Create and apply an iPXE boot file for each node.
        for node in nodes {
@@ -189,13 +189,16 @@ impl OKDSetup03ControlPlaneInterpret {
    /// Prompts the user to reboot the target control plane nodes.
    async fn reboot_targets(&self, nodes: &Vec<PhysicalHost>) -> Result<(), InterpretError> {
        let node_ids: Vec<String> = nodes.iter().map(|n| n.id.to_string()).collect();
-        info!("[ControlPlane] Requesting reboot for control plane nodes: {node_ids:?}",);
+        info!(
            "[ControlPlane] Requesting reboot for control plane nodes: {:?}",
            node_ids
        );
        let confirmation = inquire::Confirm::new(
                &format!("Please reboot the {} control plane nodes ({}) to apply their PXE configuration. Press enter when ready.", nodes.len(), node_ids.join(", ")),
        )
        .prompt()
-        .map_err(|e| InterpretError::new(format!("User prompt failed: {e}")))?;
+        .map_err(|e| InterpretError::new(format!("User prompt failed: {}", e)))?;
        if !confirmation {
            return Err(InterpretError::new(
@@ -207,23 +210,14 @@ impl OKDSetup03ControlPlaneInterpret {
    }
    /// Placeholder for automating network bonding configuration.
-    async fn persist_network_bond(
+    async fn persist_network_bond(&self) -> Result<(), InterpretError> {
-        &self,
+        // Generate MC or NNCP from inventory NIC data; apply via ignition or post-join.
-        inventory: &Inventory,
+        info!("[ControlPlane] Ensuring persistent bonding via MachineConfig/NNCP");
        topology: &HAClusterTopology,
        hosts: &Vec<PhysicalHost>,
    ) -> Result<(), InterpretError> {
        info!("[ControlPlane] Ensuring persistent bonding");
        let score = HostNetworkConfigurationScore {
            hosts: hosts.clone(), // FIXME: Avoid clone if possible
        };
        score.interpret(inventory, topology).await?;
        inquire::Confirm::new(
            "Network configuration for control plane nodes is not automated yet. Configure it manually if needed.",
        )
        .prompt()
-        .map_err(|e| InterpretError::new(format!("User prompt failed: {e}")))?;
+        .map_err(|e| InterpretError::new(format!("User prompt failed: {}", e)))?;
        Ok(())
    }
@@ -266,8 +260,7 @@ impl Interpret<HAClusterTopology> for OKDSetup03ControlPlaneInterpret {
        self.reboot_targets(&nodes).await?;
        // 5. Placeholder for post-boot network configuration (e.g., bonding).
-        self.persist_network_bond(inventory, topology, &nodes)
+        self.persist_network_bond().await?;
            .await?;
        // TODO: Implement a step to wait for the control plane nodes to join the cluster
        // and for the cluster operators to become available. This would be similar to
--- a/harmony/src/modules/okd/crd/mod.rs
+++ b/harmony/src/modules/okd/crd/mod.rs
@@ -1,41 +0,0 @@
 use kube::CustomResource;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 pub mod nmstate;
 #[derive(CustomResource, Deserialize, Serialize, Clone, Debug, JsonSchema)]
 #[kube(
    group = "operators.coreos.com",
    version = "v1",
    kind = "OperatorGroup",
    namespaced
 )]
 #[serde(rename_all = "camelCase")]
 pub struct OperatorGroupSpec {
    pub target_namespaces: Vec<String>,
 }
 #[derive(CustomResource, Deserialize, Serialize, Clone, Debug, JsonSchema)]
 #[kube(
    group = "operators.coreos.com",
    version = "v1alpha1",
    kind = "Subscription",
    namespaced
 )]
 #[serde(rename_all = "camelCase")]
 pub struct SubscriptionSpec {
    pub name: String,
    pub source: String,
    pub source_namespace: String,
    pub channel: Option<String>,
    pub install_plan_approval: Option<InstallPlanApproval>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, JsonSchema)]
 pub enum InstallPlanApproval {
    #[serde(rename = "Automatic")]
    Automatic,
    #[serde(rename = "Manual")]
    Manual,
 }
--- a/harmony/src/modules/okd/crd/nmstate.rs
+++ b/harmony/src/modules/okd/crd/nmstate.rs
@@ -1,251 +0,0 @@
 use std::collections::BTreeMap;
 use kube::CustomResource;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 #[derive(CustomResource, Deserialize, Serialize, Clone, Debug, JsonSchema)]
 #[kube(group = "nmstate.io", version = "v1", kind = "NMState", namespaced)]
 #[serde(rename_all = "camelCase")]
 pub struct NMStateSpec {
    pub probe_configuration: Option<ProbeConfig>,
 }
 impl Default for NMState {
    fn default() -> Self {
        Self {
            metadata: Default::default(),
            spec: NMStateSpec {
                probe_configuration: None,
            },
        }
    }
 }
 #[derive(Deserialize, Serialize, Clone, Debug, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct ProbeConfig {
    pub dns: ProbeDns,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct ProbeDns {
    pub host: String,
 }
 #[derive(CustomResource, Deserialize, Serialize, Clone, Debug, JsonSchema)]
 #[kube(
    group = "nmstate.io",
    version = "v1",
    kind = "NodeNetworkConfigurationPolicy",
    namespaced
 )]
 #[serde(rename_all = "camelCase")]
 pub struct NodeNetworkConfigurationPolicySpec {
    pub node_selector: Option<BTreeMap<String, String>>,
    pub desired_state: DesiredStateSpec,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct DesiredStateSpec {
    pub interfaces: Vec<InterfaceSpec>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct InterfaceSpec {
    pub name: String,
    pub description: Option<String>,
    pub r#type: String,
    pub state: String,
    pub mac_address: Option<String>,
    pub mtu: Option<u32>,
    pub controller: Option<String>,
    pub ipv4: Option<IpStackSpec>,
    pub ipv6: Option<IpStackSpec>,
    pub ethernet: Option<EthernetSpec>,
    pub link_aggregation: Option<BondSpec>,
    pub vlan: Option<VlanSpec>,
    pub vxlan: Option<VxlanSpec>,
    pub mac_vtap: Option<MacVtapSpec>,
    pub mac_vlan: Option<MacVlanSpec>,
    pub infiniband: Option<InfinibandSpec>,
    pub linux_bridge: Option<LinuxBridgeSpec>,
    pub ovs_bridge: Option<OvsBridgeSpec>,
    pub ethtool: Option<EthtoolSpec>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct IpStackSpec {
    pub enabled: Option<bool>,
    pub dhcp: Option<bool>,
    pub autoconf: Option<bool>,
    pub address: Option<Vec<IpAddressSpec>>,
    pub auto_dns: Option<bool>,
    pub auto_gateway: Option<bool>,
    pub auto_routes: Option<bool>,
    pub dhcp_client_id: Option<String>,
    pub dhcp_duid: Option<String>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct IpAddressSpec {
    pub ip: String,
    pub prefix_length: u8,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct EthernetSpec {
    pub speed: Option<u32>,
    pub duplex: Option<String>,
    pub auto_negotiation: Option<bool>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct BondSpec {
    pub mode: String,
    pub ports: Vec<String>,
    pub options: Option<BTreeMap<String, Value>>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct VlanSpec {
    pub base_iface: String,
    pub id: u16,
    pub protocol: Option<String>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct VxlanSpec {
    pub base_iface: String,
    pub id: u32,
    pub remote: String,
    pub local: Option<String>,
    pub learning: Option<bool>,
    pub destination_port: Option<u16>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct MacVtapSpec {
    pub base_iface: String,
    pub mode: String,
    pub promiscuous: Option<bool>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct MacVlanSpec {
    pub base_iface: String,
    pub mode: String,
    pub promiscuous: Option<bool>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct InfinibandSpec {
    pub base_iface: String,
    pub pkey: String,
    pub mode: String,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct LinuxBridgeSpec {
    pub options: Option<LinuxBridgeOptions>,
    pub ports: Option<Vec<LinuxBridgePort>>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct LinuxBridgeOptions {
    pub mac_ageing_time: Option<u32>,
    pub multicast_snooping: Option<bool>,
    pub stp: Option<StpOptions>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct StpOptions {
    pub enabled: Option<bool>,
    pub forward_delay: Option<u16>,
    pub hello_time: Option<u16>,
    pub max_age: Option<u16>,
    pub priority: Option<u16>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct LinuxBridgePort {
    pub name: String,
    pub vlan: Option<LinuxBridgePortVlan>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct LinuxBridgePortVlan {
    pub mode: Option<String>,
    pub trunk_tags: Option<Vec<VlanTag>>,
    pub tag: Option<u16>,
    pub enable_native: Option<bool>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct VlanTag {
    pub id: u16,
    pub id_range: Option<VlanIdRange>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct VlanIdRange {
    pub min: u16,
    pub max: u16,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct OvsBridgeSpec {
    pub options: Option<OvsBridgeOptions>,
    pub ports: Option<Vec<OvsPortSpec>>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct OvsBridgeOptions {
    pub stp: Option<bool>,
    pub rstp: Option<bool>,
    pub mcast_snooping_enable: Option<bool>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct OvsPortSpec {
    pub name: String,
    pub link_aggregation: Option<BondSpec>,
    pub vlan: Option<LinuxBridgePortVlan>,
    pub r#type: Option<String>,
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct EthtoolSpec {
    // FIXME: Properly describe this spec (https://nmstate.io/devel/yaml_api.html#ethtool)
 }
 #[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub struct EthtoolFecSpec {
    pub auto: Option<bool>,
    pub mode: Option<String>,
 }
--- a/harmony/src/modules/okd/host_network.rs
+++ b/harmony/src/modules/okd/host_network.rs
@@ -1,340 +0,0 @@
 use async_trait::async_trait;
 use harmony_types::id::Id;
 use log::{debug, info, warn};
 use serde::Serialize;
 use crate::{
    data::Version,
    hardware::PhysicalHost,
    interpret::{Interpret, InterpretError, InterpretName, InterpretStatus, Outcome},
    inventory::Inventory,
    score::Score,
    topology::{HostNetworkConfig, NetworkInterface, Switch, SwitchPort, Topology},
 };
 #[derive(Debug, Clone, Serialize)]
 pub struct HostNetworkConfigurationScore {
    pub hosts: Vec<PhysicalHost>,
 }
 impl<T: Topology + Switch> Score<T> for HostNetworkConfigurationScore {
    fn name(&self) -> String {
        "HostNetworkConfigurationScore".into()
    }
    fn create_interpret(&self) -> Box<dyn Interpret<T>> {
        Box::new(HostNetworkConfigurationInterpret {
            score: self.clone(),
        })
    }
 }
 #[derive(Debug)]
 pub struct HostNetworkConfigurationInterpret {
    score: HostNetworkConfigurationScore,
 }
 #[async_trait]
 impl<T: Topology + Switch> Interpret<T> for HostNetworkConfigurationInterpret {
    fn get_name(&self) -> InterpretName {
        InterpretName::Custom("HostNetworkConfigurationInterpret")
    }
    fn get_version(&self) -> Version {
        todo!()
    }
    fn get_status(&self) -> InterpretStatus {
        todo!()
    }
    fn get_children(&self) -> Vec<Id> {
        vec![]
    }
    async fn execute(
        &self,
        _inventory: &Inventory,
        topology: &T,
    ) -> Result<Outcome, InterpretError> {
        info!(
            "Started network configuration for {} host(s)...",
            self.score.hosts.len()
        );
        let mut configured_host_count = 0;
        for host in &self.score.hosts {
            let mut switch_ports = vec![];
            for network_interface in &host.network {
                let mac_address = network_interface.mac_address;
                match topology.get_port_for_mac_address(&mac_address).await {
                    Ok(Some(port)) => {
                        switch_ports.push(SwitchPort {
                            interface: NetworkInterface {
                                name: network_interface.name.clone(),
                                mac_address,
                                speed_mbps: network_interface.speed_mbps,
                                mtu: network_interface.mtu,
                            },
                            port,
                        });
                    }
                    Ok(None) => debug!("No port found for host '{}', skipping", host.id),
                    Err(e) => warn!("Failed to get port for host '{}': {}", host.id, e),
                }
            }
            if !switch_ports.is_empty() {
                configured_host_count += 1;
                topology
                    .configure_host_network(host, HostNetworkConfig { switch_ports })
                    .await
                    .map_err(|e| InterpretError::new(format!("Failed to configure host: {e}")))?;
            }
        }
        if configured_host_count > 0 {
            Ok(Outcome::success(format!(
                "Configured {configured_host_count}/{} host(s)",
                self.score.hosts.len()
            )))
        } else {
            Ok(Outcome::noop("No hosts configured".into()))
        }
    }
 }
 #[cfg(test)]
 mod tests {
    use assertor::*;
    use harmony_types::{net::MacAddress, switch::PortLocation};
    use lazy_static::lazy_static;
    use crate::{
        hardware::HostCategory,
        topology::{
            HostNetworkConfig, PreparationError, PreparationOutcome, SwitchError, SwitchPort,
        },
    };
    use std::{
        str::FromStr,
        sync::{Arc, Mutex},
    };
    use super::*;
    lazy_static! {
        pub static ref HOST_ID: Id = Id::from_str("host-1").unwrap();
        pub static ref ANOTHER_HOST_ID: Id = Id::from_str("host-2").unwrap();
        pub static ref EXISTING_INTERFACE: NetworkInterface = NetworkInterface {
            mac_address: MacAddress::try_from("AA:BB:CC:DD:EE:F1".to_string()).unwrap(),
            name: "interface-1".into(),
            speed_mbps: None,
            mtu: 1,
        };
        pub static ref ANOTHER_EXISTING_INTERFACE: NetworkInterface = NetworkInterface {
            mac_address: MacAddress::try_from("AA:BB:CC:DD:EE:F2".to_string()).unwrap(),
            name: "interface-2".into(),
            speed_mbps: None,
            mtu: 1,
        };
        pub static ref UNKNOWN_INTERFACE: NetworkInterface = NetworkInterface {
            mac_address: MacAddress::try_from("11:22:33:44:55:61".to_string()).unwrap(),
            name: "unknown-interface".into(),
            speed_mbps: None,
            mtu: 1,
        };
        pub static ref PORT: PortLocation = PortLocation(1, 0, 42);
        pub static ref ANOTHER_PORT: PortLocation = PortLocation(2, 0, 42);
    }
    #[tokio::test]
    async fn host_with_one_mac_address_should_create_bond_with_one_interface() {
        let host = given_host(&HOST_ID, vec![EXISTING_INTERFACE.clone()]);
        let score = given_score(vec![host]);
        let topology = TopologyWithSwitch::new();
        let _ = score.interpret(&Inventory::empty(), &topology).await;
        let configured_host_networks = topology.configured_host_networks.lock().unwrap();
        assert_that!(*configured_host_networks).contains_exactly(vec![(
            HOST_ID.clone(),
            HostNetworkConfig {
                switch_ports: vec![SwitchPort {
                    interface: EXISTING_INTERFACE.clone(),
                    port: PORT.clone(),
                }],
            },
        )]);
    }
    #[tokio::test]
    async fn host_with_multiple_mac_addresses_should_create_one_bond_with_all_interfaces() {
        let score = given_score(vec![given_host(
            &HOST_ID,
            vec![
                EXISTING_INTERFACE.clone(),
                ANOTHER_EXISTING_INTERFACE.clone(),
            ],
        )]);
        let topology = TopologyWithSwitch::new();
        let _ = score.interpret(&Inventory::empty(), &topology).await;
        let configured_host_networks = topology.configured_host_networks.lock().unwrap();
        assert_that!(*configured_host_networks).contains_exactly(vec![(
            HOST_ID.clone(),
            HostNetworkConfig {
                switch_ports: vec![
                    SwitchPort {
                        interface: EXISTING_INTERFACE.clone(),
                        port: PORT.clone(),
                    },
                    SwitchPort {
                        interface: ANOTHER_EXISTING_INTERFACE.clone(),
                        port: ANOTHER_PORT.clone(),
                    },
                ],
            },
        )]);
    }
    #[tokio::test]
    async fn multiple_hosts_should_create_one_bond_per_host() {
        let score = given_score(vec![
            given_host(&HOST_ID, vec![EXISTING_INTERFACE.clone()]),
            given_host(&ANOTHER_HOST_ID, vec![ANOTHER_EXISTING_INTERFACE.clone()]),
        ]);
        let topology = TopologyWithSwitch::new();
        let _ = score.interpret(&Inventory::empty(), &topology).await;
        let configured_host_networks = topology.configured_host_networks.lock().unwrap();
        assert_that!(*configured_host_networks).contains_exactly(vec![
            (
                HOST_ID.clone(),
                HostNetworkConfig {
                    switch_ports: vec![SwitchPort {
                        interface: EXISTING_INTERFACE.clone(),
                        port: PORT.clone(),
                    }],
                },
            ),
            (
                ANOTHER_HOST_ID.clone(),
                HostNetworkConfig {
                    switch_ports: vec![SwitchPort {
                        interface: ANOTHER_EXISTING_INTERFACE.clone(),
                        port: ANOTHER_PORT.clone(),
                    }],
                },
            ),
        ]);
    }
    #[tokio::test]
    async fn port_not_found_for_mac_address_should_not_configure_interface() {
        // FIXME: Should it still configure an empty bond/port channel?
        let score = given_score(vec![given_host(&HOST_ID, vec![UNKNOWN_INTERFACE.clone()])]);
        let topology = TopologyWithSwitch::new_port_not_found();
        let _ = score.interpret(&Inventory::empty(), &topology).await;
        let configured_host_networks = topology.configured_host_networks.lock().unwrap();
        assert_that!(*configured_host_networks).is_empty();
    }
    fn given_score(hosts: Vec<PhysicalHost>) -> HostNetworkConfigurationScore {
        HostNetworkConfigurationScore { hosts }
    }
    fn given_host(id: &Id, network_interfaces: Vec<NetworkInterface>) -> PhysicalHost {
        let network = network_interfaces.iter().map(given_interface).collect();
        PhysicalHost {
            id: id.clone(),
            category: HostCategory::Server,
            network,
            storage: vec![],
            labels: vec![],
            memory_modules: vec![],
            cpus: vec![],
        }
    }
    fn given_interface(
        interface: &NetworkInterface,
    ) -> harmony_inventory_agent::hwinfo::NetworkInterface {
        harmony_inventory_agent::hwinfo::NetworkInterface {
            name: interface.name.clone(),
            mac_address: interface.mac_address,
            speed_mbps: interface.speed_mbps,
            is_up: true,
            mtu: interface.mtu,
            ipv4_addresses: vec![],
            ipv6_addresses: vec![],
            driver: "driver".into(),
            firmware_version: None,
        }
    }
    struct TopologyWithSwitch {
        available_ports: Arc<Mutex<Vec<PortLocation>>>,
        configured_host_networks: Arc<Mutex<Vec<(Id, HostNetworkConfig)>>>,
    }
    impl TopologyWithSwitch {
        fn new() -> Self {
            Self {
                available_ports: Arc::new(Mutex::new(vec![PORT.clone(), ANOTHER_PORT.clone()])),
                configured_host_networks: Arc::new(Mutex::new(vec![])),
            }
        }
        fn new_port_not_found() -> Self {
            Self {
                available_ports: Arc::new(Mutex::new(vec![])),
                configured_host_networks: Arc::new(Mutex::new(vec![])),
            }
        }
    }
    #[async_trait]
    impl Topology for TopologyWithSwitch {
        fn name(&self) -> &str {
            "SwitchWithPortTopology"
        }
        async fn ensure_ready(&self) -> Result<PreparationOutcome, PreparationError> {
            Ok(PreparationOutcome::Success { details: "".into() })
        }
    }
    #[async_trait]
    impl Switch for TopologyWithSwitch {
        async fn get_port_for_mac_address(
            &self,
            _mac_address: &MacAddress,
        ) -> Result<Option<PortLocation>, SwitchError> {
            let mut ports = self.available_ports.lock().unwrap();
            if ports.is_empty() {
                return Ok(None);
            }
            Ok(Some(ports.remove(0)))
        }
        async fn configure_host_network(
            &self,
            host: &PhysicalHost,
            config: HostNetworkConfig,
        ) -> Result<(), SwitchError> {
            let mut configured_host_networks = self.configured_host_networks.lock().unwrap();
            configured_host_networks.push((host.id.clone(), config.clone()));
            Ok(())
        }
    }
 }
--- a/harmony/src/modules/okd/mod.rs
+++ b/harmony/src/modules/okd/mod.rs
@@ -19,5 +19,3 @@ pub use bootstrap_03_control_plane::*;
 pub use bootstrap_04_workers::*;
 pub use bootstrap_05_sanity_check::*;
 pub use bootstrap_06_installation_report::*;
 pub mod crd;
 pub mod host_network;
--- a/harmony/src/modules/prometheus/rhob_alerting_score.rs
+++ b/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()).into()),
+                name: Some(format!("{}-monitoring", self.sender.namespace.clone())),
                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 = format!("alertmanager-operated");
+        let backend_service = "alertmanager-operated".to_string();
        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 = format!("prometheus-operated");
+        let backend_service = "prometheus-operated".to_string();
        let prometheus_ingress = K8sIngressScore {
            name: fqdn!(&name),
            host: fqdn!(&prometheus_domain),
--- a/harmony/src/modules/storage/ceph/ceph_osd_replacement_score.rs
+++ b/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 {
-        format!("CephRemoveOsdScore")
+        "CephRemoveOsdScore".to_string()
    }
    #[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 {
-                        return Ok(Outcome::success(format!(
+                        Ok(Outcome::success(format!(
                            "'{}' is ready with {} replica(s).",
                            &toolbox_dep, ready_count
-                        )));
+                        )))
                    } else {
-                        return Err(InterpretError::new(
+                        Err(InterpretError::new(
                            "ceph-tool-box not ready in cluster".to_string(),
-                        ));
+                        ))
                    }
                } else {
                    Err(InterpretError::new(format!(
@@ -181,15 +181,14 @@ impl CephRemoveOsdInterpret {
                )
                .await?;
-            if let Some(deployment) = dep {
+            if let Some(deployment) = dep
-                if let Some(status) = deployment.status {
+                && let Some(status) = deployment.status
-                    if status.replicas.unwrap_or(1) == 0 && status.ready_replicas.unwrap_or(1) == 0
+                && status.replicas.unwrap_or(1) == 0
-                    {
+                && status.ready_replicas.unwrap_or(1) == 0
-                        return Ok(Outcome::success(
+            {
-                            "Deployment successfully scaled down.".to_string(),
+                return Ok(Outcome::success(
-                        ));
+                    "Deployment successfully scaled down.".to_string(),
-                    }
+                ));
                }
            }
            if start.elapsed() > timeout {
--- a/harmony/src/modules/storage/ceph/ceph_validate_health_score.rs
+++ b/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 {
-        format!("CephValidateClusterHealth")
+        "CephValidateClusterHealth".to_string()
    }
    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 {
-                        return Ok(Outcome::success(format!(
+                        Ok(Outcome::success(format!(
                            "'{}' is ready with {} replica(s).",
                            &toolbox_dep, ready_count
-                        )));
+                        )))
                    } else {
-                        return Err(InterpretError::new(
+                        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") {
-            return Ok(Outcome::success(
+            Ok(Outcome::success(
                "Ceph Cluster in healthy state".to_string(),
-            ));
+            ))
        } else {
            Err(InterpretError::new(format!(
                "Ceph cluster unhealthy {}",
--- a/harmony_composer/src/main.rs
+++ b/harmony_composer/src/main.rs
@@ -54,9 +54,6 @@ struct DeployArgs {
    #[arg(long = "profile", short = 'p', default_value = "dev")]
    harmony_profile: HarmonyProfile,
    #[arg(long = "dry-run", short = 'd', default_value = "false")]
    dry_run: bool,
 }
 #[derive(Args, Clone, Debug)]
@@ -181,7 +178,6 @@ async fn main() {
                command
                    .env("HARMONY_USE_LOCAL_K3D", format!("{use_local_k3d}"))
                    .env("HARMONY_PROFILE", format!("{}", args.harmony_profile))
                    .env("HARMONY_DRY_RUN", format!("{}", args.dry_run))
                    .arg("-y")
                    .arg("-a");
--- a/harmony_types/src/id.rs
+++ b/harmony_types/src/id.rs
@@ -19,7 +19,7 @@ use serde::{Deserialize, Serialize};
 ///
 /// **It is not meant to be very secure or unique**, it is suitable to generate up to 10 000 items per
 /// second with a reasonable collision rate of 0,000014 % as calculated by this calculator : https://kevingal.com/apps/collision.html
-#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct Id {
    value: String,
 }
--- a/harmony_types/src/lib.rs
+++ b/harmony_types/src/lib.rs
@@ -1,3 +1,2 @@
 pub mod id;
 pub mod net;
 pub mod switch;
--- a/harmony_types/src/net.rs
+++ b/harmony_types/src/net.rs
@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, PartialOrd, Ord)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct MacAddress(pub [u8; 6]);
 impl MacAddress {
@@ -41,7 +41,7 @@ impl TryFrom<String> for MacAddress {
            bytes[i] = u8::from_str_radix(part, 16).map_err(|_| {
                std::io::Error::new(
                    std::io::ErrorKind::InvalidInput,
-                    format!("Invalid hex value in part {i}: '{part}'"),
+                    format!("Invalid hex value in part {}: '{}'", i, part),
                )
            })?;
        }
@@ -106,8 +106,8 @@ impl Serialize for Url {
 impl std::fmt::Display for Url {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
-            Url::LocalFolder(path) => write!(f, "{path}"),
+            Url::LocalFolder(path) => write!(f, "{}", path),
-            Url::Url(url) => write!(f, "{url}"),
+            Url::Url(url) => write!(f, "{}", url),
        }
    }
 }
--- a/harmony_types/src/switch.rs
+++ b/harmony_types/src/switch.rs
@@ -1,176 +0,0 @@
 use std::{fmt, str::FromStr};
 /// Simple error type for port parsing failures.
 #[derive(Debug)]
 pub enum PortParseError {
    /// The port string did not conform to the expected S/M/P or range format.
    InvalidFormat,
    /// A stack, module, or port segment could not be parsed as a number.
    InvalidSegment(String),
 }
 impl fmt::Display for PortParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            PortParseError::InvalidFormat => write!(f, "Port string is in an unexpected format."),
            PortParseError::InvalidSegment(s) => write!(f, "Invalid segment in port string: {}", s),
        }
    }
 }
 /// Represents the atomic, physical location of a switch port: `<Stack>/<Module>/<Port>`.
 ///
 /// Example: `1/1/1`
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
 pub struct PortLocation(pub u8, pub u8, pub u8);
 impl fmt::Display for PortLocation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}/{}/{}", self.0, self.1, self.2)
    }
 }
 impl FromStr for PortLocation {
    type Err = PortParseError;
    /// Parses a string slice into a `PortLocation`.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::str::FromStr;
    /// use harmony_types::switch::PortLocation;
    ///
    /// assert_eq!(PortLocation::from_str("1/1/1").unwrap(), PortLocation(1, 1, 1));
    /// assert_eq!(PortLocation::from_str("12/5/48").unwrap(), PortLocation(12, 5, 48));
    /// assert!(PortLocation::from_str("1/A/1").is_err());
    /// ```
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let parts: Vec<&str> = s.split('/').collect();
        if parts.len() != 3 {
            return Err(PortParseError::InvalidFormat);
        }
        let parse_segment = |part: &str| -> Result<u8, Self::Err> {
            u8::from_str(part).map_err(|_| PortParseError::InvalidSegment(part.to_string()))
        };
        let stack = parse_segment(parts[0])?;
        let module = parse_segment(parts[1])?;
        let port = parse_segment(parts[2])?;
        Ok(PortLocation(stack, module, port))
    }
 }
 /// Represents a Port configuration input, which can be a single port, a sequential range,
 /// or an explicit set defined by endpoints.
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
 pub enum PortDeclaration {
    /// A single switch port defined by its location. Example: `PortDeclaration::Single(1/1/1)`
    Single(PortLocation),
    /// A strictly sequential range defined by two endpoints using the hyphen separator (`-`).
    /// All ports between the endpoints (inclusive) are implicitly included.
    /// Example: `PortDeclaration::Range(1/1/1, 1/1/4)`
    Range(PortLocation, PortLocation),
    /// A set of ports defined by two endpoints using the asterisk separator (`*`).
    /// The actual member ports must be determined contextually (e.g., from MAC tables or
    /// explicit configuration lists).
    /// Example: `PortDeclaration::Set(1/1/1, 1/1/3)` where only ports 1 and 3 might be active.
    Set(PortLocation, PortLocation),
 }
 impl PortDeclaration {
    /// Parses a port configuration string into a structured `PortDeclaration` enum.
    ///
    /// This function performs only basic format and numerical parsing, assuming the input
    /// strings (e.g., from `show` commands) are semantically valid and logically ordered.
    ///
    /// # Supported Formats
    ///
    /// * **Single Port:** `"1/1/1"`
    /// * **Range (Hyphen, `-`):** `"1/1/1-1/1/4"`
    /// * **Set (Asterisk, `*`):** `"1/1/1*1/1/4"`
    ///
    /// # Errors
    ///
    /// Returns `PortParseError` if the string format is incorrect or numerical segments
    /// cannot be parsed.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use harmony_types::switch::{PortDeclaration, PortLocation};
    ///
    /// // Single Port
    /// assert_eq!(PortDeclaration::parse("3/2/15").unwrap(), PortDeclaration::Single(PortLocation(3, 2, 15)));
    ///
    /// // Range (Hyphen) - implies sequential ports
    /// let result_range = PortDeclaration::parse("1/1/1-1/1/4").unwrap();
    /// assert_eq!(result_range, PortDeclaration::Range(PortLocation(1, 1, 1), PortLocation(1, 1, 4)));
    ///
    /// // Set (Asterisk) - implies non-sequential set defined by endpoints
    /// let result_set = PortDeclaration::parse("1/1/48*2/1/48").unwrap();
    /// assert_eq!(result_set, PortDeclaration::Set(PortLocation(1, 1, 48), PortLocation(2, 1, 48)));
    ///
    /// // Invalid Format (will still fail basic parsing)
    /// assert!(PortDeclaration::parse("1/1/1/1").is_err());
    /// ```
    pub fn parse(port_str: &str) -> Result<Self, PortParseError> {
        if let Some((start_str, end_str)) = port_str.split_once('-') {
            let start_port = PortLocation::from_str(start_str.trim())?;
            let end_port = PortLocation::from_str(end_str.trim())?;
            return Ok(PortDeclaration::Range(start_port, end_port));
        }
        if let Some((start_str, end_str)) = port_str.split_once('*') {
            let start_port = PortLocation::from_str(start_str.trim())?;
            let end_port = PortLocation::from_str(end_str.trim())?;
            return Ok(PortDeclaration::Set(start_port, end_port));
        }
        let location = PortLocation::from_str(port_str)?;
        Ok(PortDeclaration::Single(location))
    }
 }
 impl fmt::Display for PortDeclaration {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            PortDeclaration::Single(port) => write!(f, "{port}"),
            PortDeclaration::Range(start, end) => write!(f, "{start}-{end}"),
            PortDeclaration::Set(start, end) => write!(f, "{start}*{end}"),
        }
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn test_parse_port_location_invalid() {
        assert!(PortLocation::from_str("1/1").is_err());
        assert!(PortLocation::from_str("1/A/1").is_err());
        assert!(PortLocation::from_str("1/1/256").is_err());
    }
    #[test]
    fn test_parse_declaration_single() {
        let single_result = PortDeclaration::parse("1/1/4").unwrap();
        assert!(matches!(single_result, PortDeclaration::Single(_)));
    }
    #[test]
    fn test_parse_declaration_range() {
        let range_result = PortDeclaration::parse("1/1/1-1/1/4").unwrap();
        assert!(matches!(range_result, PortDeclaration::Range(_, _)));
    }
    #[test]
    fn test_parse_declaration_set() {
        let set_result = PortDeclaration::parse("1/1/48*2/1/48").unwrap();
        assert!(matches!(set_result, PortDeclaration::Set(_, _)));
    }
 }
Author	SHA1	Message	Date
Jean-Gabriel Gill-Couture	6e53397a58	commit All checks were successful Run Check Script / check (pull_request) Successful in 1m22s Details	2025-10-02 17:11:02 -04:00
Jean-Gabriel Gill-Couture	8baf75a4fd	commit	2025-10-02 16:59:08 -04:00
Jean-Gabriel Gill-Couture	d53d040bac	commit	2025-10-02 16:56:17 -04:00
Jean-Gabriel Gill-Couture	687f11b261	commit	2025-10-02 16:53:25 -04:00
Jean-Gabriel Gill-Couture	58e609767b	cargo fmt	2025-10-02 16:46:43 -04:00
Jean-Gabriel Gill-Couture	f75765408d	fix: clippy Some checks failed Run Check Script / check (pull_request) Failing after 35s Details	2025-10-02 16:25:07 -04:00
Willem	cbbaae2ac8	okd_enable_user_workload_monitoring (#160 ) Reviewed-on: #160 Co-authored-by: Willem <wrolleman@nationtech.io> Co-committed-by: Willem <wrolleman@nationtech.io>	2025-09-29 14:32:38 +00:00