wip: FailoverTopology implementation for PostgreSQL on the way!

Also alias `port` to support both `port` and `ports` as per the nmstate spec.

Reviewed-on: #186

Cargo.lock

@@ -690,23 +690,6 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "brocade-switch"
-version = "0.1.0"
-dependencies = [
- "async-trait",
- "brocade",
- "env_logger",
- "harmony",
- "harmony_cli",
- "harmony_macros",
- "harmony_types",
- "log",
- "serde",
- "tokio",
- "url",
-]
-
 [[package]]
 name = "brotli"
 version = "8.0.2"
@@ -2496,19 +2479,6 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "harmony_inventory_builder"
-version = "0.1.0"
-dependencies = [
- "cidr",
- "harmony",
- "harmony_cli",
- "harmony_macros",
- "harmony_types",
- "tokio",
- "url",
-]
-
 [[package]]
 name = "harmony_macros"
 version = "0.1.0"
@@ -2574,7 +2544,6 @@ dependencies = [
 name = "harmony_types"
 version = "0.1.0"
 dependencies = [
- "log",
  "rand 0.9.2",
  "serde",
  "url",

brocade/examples/main.rs

@@ -1,6 +1,6 @@
 use std::net::{IpAddr, Ipv4Addr};
 
-use brocade::{BrocadeOptions, ssh};
+use brocade::BrocadeOptions;
 use harmony_secret::{Secret, SecretManager};
 use harmony_types::switch::PortLocation;
 use serde::{Deserialize, Serialize};
@@ -16,28 +16,23 @@ async fn main() {
     env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
 
     // let ip = IpAddr::V4(Ipv4Addr::new(10, 0, 0, 250)); // old brocade @ ianlet
-    let ip = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)); // brocade @ sto1
+    let ip = IpAddr::V4(Ipv4Addr::new(192, 168, 55, 101)); // brocade @ sto1
     // let ip = IpAddr::V4(Ipv4Addr::new(192, 168, 4, 11)); // brocade @ st
     let switch_addresses = vec![ip];
 
-    // let config = SecretManager::get_or_prompt::<BrocadeSwitchAuth>()
-    //     .await
-    //     .unwrap();
+    let config = SecretManager::get_or_prompt::<BrocadeSwitchAuth>()
+        .await
+        .unwrap();
 
     let brocade = brocade::init(
         &switch_addresses,
-        // &config.username,
-        // &config.password,
-        "admin",
-        "password",
-        BrocadeOptions {
+        22,
+        &config.username,
+        &config.password,
+        Some(BrocadeOptions {
             dry_run: true,
-            ssh: ssh::SshOptions {
-                port: 2222,
             ..Default::default()
-            },
-            ..Default::default()
-        },
+        }),
     )
     .await
     .expect("Brocade client failed to connect");
@@ -59,7 +54,6 @@ async fn main() {
     }
 
     println!("--------------");
-    todo!();
     let channel_name = "1";
     brocade.clear_port_channel(channel_name).await.unwrap();
 

brocade/src/fast_iron.rs

@@ -140,7 +140,7 @@ impl BrocadeClient for FastIronClient {
 
     async fn configure_interfaces(
         &self,
-        _interfaces: &Vec<(String, PortOperatingMode)>,
+        _interfaces: Vec<(String, PortOperatingMode)>,
     ) -> Result<(), Error> {
         todo!()
     }

brocade/src/lib.rs

@@ -14,12 +14,11 @@ use async_trait::async_trait;
 use harmony_types::net::MacAddress;
 use harmony_types::switch::{PortDeclaration, PortLocation};
 use regex::Regex;
-use serde::Serialize;
 
 mod fast_iron;
 mod network_operating_system;
 mod shell;
-pub mod ssh;
+mod ssh;
 
 #[derive(Default, Clone, Debug)]
 pub struct BrocadeOptions {
@@ -119,7 +118,7 @@ impl fmt::Display for InterfaceType {
 }
 
 /// Defines the primary configuration mode of a switch interface, representing mutually exclusive roles.
-#[derive(Debug, PartialEq, Eq, Clone, Serialize)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum PortOperatingMode {
     /// The interface is explicitly configured for Brocade fabric roles (ISL or Trunk enabled).
     Fabric,
@@ -142,11 +141,12 @@ pub enum InterfaceStatus {
 
 pub async fn init(
     ip_addresses: &[IpAddr],
+    port: u16,
     username: &str,
     password: &str,
-    options: BrocadeOptions,
+    options: Option<BrocadeOptions>,
 ) -> Result<Box<dyn BrocadeClient + Send + Sync>, Error> {
-    let shell = BrocadeShell::init(ip_addresses, username, password, options).await?;
+    let shell = BrocadeShell::init(ip_addresses, port, username, password, options).await?;
 
     let version_info = shell
         .with_session(ExecutionMode::Regular, |session| {
@@ -208,7 +208,7 @@ pub trait BrocadeClient: std::fmt::Debug {
     /// Configures a set of interfaces to be operated with a specified mode (access ports, ISL, etc.).
     async fn configure_interfaces(
         &self,
-        interfaces: &Vec<(String, PortOperatingMode)>,
+        interfaces: Vec<(String, PortOperatingMode)>,
     ) -> Result<(), Error>;
 
     /// Scans the existing configuration to find the next available (unused)

brocade/src/network_operating_system.rs

@@ -187,7 +187,7 @@ impl BrocadeClient for NetworkOperatingSystemClient {
 
     async fn configure_interfaces(
         &self,
-        interfaces: &Vec<(String, PortOperatingMode)>,
+        interfaces: Vec<(String, PortOperatingMode)>,
     ) -> Result<(), Error> {
         info!("[Brocade] Configuring {} interface(s)...", interfaces.len());
 
@@ -204,12 +204,9 @@ impl BrocadeClient for NetworkOperatingSystemClient {
                 PortOperatingMode::Trunk => {
                     commands.push("switchport".into());
                     commands.push("switchport mode trunk".into());
-                    commands.push("switchport trunk allowed vlan all".into());
-                    commands.push("no switchport trunk tag native-vlan".into());
-                    commands.push("spanning-tree shutdown".into());
+                    commands.push("no spanning-tree shutdown".into());
                     commands.push("no fabric isl enable".into());
                     commands.push("no fabric trunk enable".into());
-                    commands.push("no shutdown".into());
                 }
                 PortOperatingMode::Access => {
                     commands.push("switchport".into());

brocade/src/shell.rs

@@ -16,6 +16,7 @@ use tokio::time::timeout;
 #[derive(Debug)]
 pub struct BrocadeShell {
     ip: IpAddr,
+    port: u16,
     username: String,
     password: String,
     options: BrocadeOptions,
@@ -26,31 +27,33 @@ pub struct BrocadeShell {
 impl BrocadeShell {
     pub async fn init(
         ip_addresses: &[IpAddr],
+        port: u16,
         username: &str,
         password: &str,
-        options: BrocadeOptions,
+        options: Option<BrocadeOptions>,
     ) -> Result<Self, Error> {
         let ip = ip_addresses
             .first()
             .ok_or_else(|| Error::ConfigurationError("No IP addresses provided".to_string()))?;
 
-        let brocade_ssh_client_options =
-            ssh::try_init_client(username, password, ip, options).await?;
+        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(),
             before_all_commands: vec![],
             after_all_commands: vec![],
-            options: brocade_ssh_client_options,
+            options,
         })
     }
 
     pub async fn open_session(&self, mode: ExecutionMode) -> Result<BrocadeSession, Error> {
         BrocadeSession::open(
             self.ip,
-            self.options.ssh.port,
+            self.port,
             &self.username,
             &self.password,
             self.options.clone(),

brocade/src/ssh.rs

@@ -2,7 +2,6 @@ use std::borrow::Cow;
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use log::debug;
 use russh::client::Handler;
 use russh::kex::DH_G1_SHA1;
 use russh::kex::ECDH_SHA2_NISTP256;
@@ -11,43 +10,29 @@ use russh_keys::key::SSH_RSA;
 use super::BrocadeOptions;
 use super::Error;
 
-#[derive(Clone, Debug)]
+#[derive(Default, Clone, Debug)]
 pub struct SshOptions {
     pub preferred_algorithms: russh::Preferred,
-    pub port: u16,
-}
-
-impl Default for SshOptions {
-    fn default() -> Self {
-        Self {
-            preferred_algorithms: Default::default(),
-            port: 22,
-        }
-    }
 }
 
 impl SshOptions {
-    fn ecdhsa_sha2_nistp256(port: u16) -> Self {
+    fn ecdhsa_sha2_nistp256() -> Self {
         Self {
             preferred_algorithms: russh::Preferred {
                 kex: Cow::Borrowed(&[ECDH_SHA2_NISTP256]),
                 key: Cow::Borrowed(&[SSH_RSA]),
                 ..Default::default()
             },
-            port,
-            ..Default::default()
         }
     }
 
-    fn legacy(port: u16) -> Self {
+    fn legacy() -> Self {
         Self {
             preferred_algorithms: russh::Preferred {
                 kex: Cow::Borrowed(&[DH_G1_SHA1]),
                 key: Cow::Borrowed(&[SSH_RSA]),
                 ..Default::default()
             },
-            port,
-            ..Default::default()
         }
     }
 }
@@ -72,21 +57,18 @@ pub async fn try_init_client(
     ip: &std::net::IpAddr,
     base_options: BrocadeOptions,
 ) -> Result<BrocadeOptions, Error> {
-    let mut default = SshOptions::default();
-    default.port = base_options.ssh.port;
     let ssh_options = vec![
-        default,
-        SshOptions::ecdhsa_sha2_nistp256(base_options.ssh.port),
-        SshOptions::legacy(base_options.ssh.port),
+        SshOptions::default(),
+        SshOptions::ecdhsa_sha2_nistp256(),
+        SshOptions::legacy(),
     ];
 
     for ssh in ssh_options {
         let opts = BrocadeOptions {
-            ssh: ssh.clone(),
+            ssh,
             ..base_options.clone()
         };
-        debug!("Creating client {ip}:{} {username}", ssh.port);
-        let client = create_client(*ip, ssh.port, username, password, &opts).await;
+        let client = create_client(*ip, 22, username, password, &opts).await;
 
         match client {
             Ok(_) => {

docs/modules/Multisite_PostgreSQL.md

@@ -0,0 +1,105 @@
+# Design Document: Harmony PostgreSQL Module
+
+**Status:** Draft
+**Last Updated:** 2025-12-01
+**Context:** Multi-site Data Replication & Orchestration
+
+## 1. Overview
+
+The Harmony PostgreSQL Module provides a high-level abstraction for deploying and managing high-availability PostgreSQL clusters across geographically distributed Kubernetes/OKD sites.
+
+Instead of manually configuring complex replication slots, firewalls, and operator settings on each cluster, users define a single intent (a **Score**), and Harmony orchestrates the underlying infrastructure (the **Arrangement**) to establish a Primary-Replica architecture.
+
+Currently, the implementation relies on the **CloudNativePG (CNPG)** operator as the backing engine.
+
+## 2. Architecture
+
+### 2.1 The Abstraction Model
+Following **ADR 003 (Infrastructure Abstraction)**, Harmony separates the *intent* from the *implementation*.
+
+1.  **The Score (Intent):** The user defines a `MultisitePostgreSQL` resource. This describes *what* is needed (e.g., "A Postgres 15 cluster with 10GB storage, Primary on Site A, Replica on Site B").
+2.  **The Interpret (Action):** Harmony MultisitePostgreSQLInterpret processes this Score and orchestrates the deployment on both sites to reach the state defined in the Score.
+3.  **The Capability (Implementation):** The PostgreSQL Capability is implemented by the K8sTopology and the interpret can deploy it, configure it and fetch information about it. The concrete implementation will rely on the mature CloudnativePG operator to manage all the Kubernetes resources required.
+
+### 2.2 Network Connectivity (TLS Passthrough)
+
+One of the critical challenges in multi-site orchestration is secure connectivity between clusters that may have dynamic IPs or strict firewalls.
+
+To solve this, we utilize **OKD/OpenShift Routes with TLS Passthrough**.
+
+*   **Mechanism:** The Primary site exposes a `Route` configured for `termination: passthrough`.
+*   **Routing:** The OpenShift HAProxy router inspects the **SNI (Server Name Indication)** header of the incoming TCP connection to route traffic to the correct PostgreSQL Pod.
+*   **Security:** SSL is **not** terminated at the ingress router. The encrypted stream is passed directly to the PostgreSQL instance. Mutual TLS (mTLS) authentication is handled natively by CNPG between the Primary and Replica instances.
+*   **Dynamic IPs:** Because connections are established via DNS hostnames (the Route URL), this architecture is resilient to dynamic IP changes at the Primary site.
+
+#### Traffic Flow Diagram
+
+```text
+[ Site B: Replica ]                 [ Site A: Primary ]
+      |                                     |
+(CNPG Instance) --[Encrypted TCP]--> (OKD HAProxy Router)
+      |           (Port 443)                |
+      |                                     |
+      |                            [SNI Inspection]
+      |                                     |
+      |                                     v
+      |                            (PostgreSQL Primary Pod)
+      |                                   (Port 5432)
+```
+
+## 3. Design Decisions
+
+### Why CloudNativePG?
+We selected CloudNativePG because it relies exclusively on standard Kubernetes primitives and uses the native PostgreSQL replication protocol (WAL shipping/Streaming). This aligns with Harmony's goal of being "K8s Native."
+
+### Why TLS Passthrough instead of VPN/NodePort?
+*   **NodePort:** Requires static IPs and opening non-standard ports on the firewall, which violates our security constraints.
+*   **VPN (e.g., Wireguard/Tailscale):** While secure, it introduces significant complexity (sidecars, key management) and external dependencies.
+*   **TLS Passthrough:** Leverages the existing Ingress/Router infrastructure already present in OKD. It requires zero additional software and respects multi-tenancy (Routes are namespaced).
+
+### Configuration Philosophy (YAGNI)
+The current design exposes a **generic configuration surface**. Users can configure standard parameters (Storage size, CPU/Memory requests, Postgres version).
+
+**We explicitly do not expose advanced CNPG or PostgreSQL configurations at this stage.**
+
+*   **Reasoning:** We aim to keep the API surface small and manageable.
+*   **Future Path:** We plan to implement a "pass-through" mechanism to allow sending raw config maps or custom parameters to the underlying engine (CNPG) *only when a concrete use case arises*. Until then, we adhere to the **YAGNI (You Ain't Gonna Need It)** principle to avoid premature optimization and API bloat.
+
+## 4. Usage Guide
+
+To deploy a multi-site cluster, apply the `MultisitePostgreSQL` resource to the Harmony Control Plane.
+
+### Example Manifest
+
+```yaml
+apiVersion: harmony.io/v1alpha1
+kind: MultisitePostgreSQL
+metadata:
+  name: finance-db
+  namespace: tenant-a
+spec:
+  version: "15"
+  storage: "10Gi"
+  resources:
+    requests:
+      cpu: "500m"
+      memory: "1Gi"
+  
+  # Topology Definition
+  topology:
+    primary:
+      site: "site-paris" # The name of the cluster in Harmony
+    replicas:
+      - site: "site-newyork"
+```
+
+### What happens next?
+1.  Harmony detects the CR.
+2.  **On Site Paris:** It deploys a CNPG Cluster (Primary) and creates a Passthrough Route `postgres-finance-db.apps.site-paris.example.com`.
+3.  **On Site New York:** It deploys a CNPG Cluster (Replica) configured with `externalClusters` pointing to the Paris Route.
+4.  Data begins replicating immediately over the encrypted channel.
+
+## 5. Troubleshooting
+
+*   **Connection Refused:** Ensure the Primary site's Route is successfully admitted by the Ingress Controller.
+*   **Certificate Errors:** CNPG manages mTLS automatically. If errors persist, ensure the CA secrets were correctly propagated by Harmony from Primary to Replica namespaces.

examples/brocade_switch/Cargo.toml

@@ -1,19 +0,0 @@
-[package]
-name = "brocade-switch"
-edition = "2024"
-version.workspace = true
-readme.workspace = true
-license.workspace = true
-
-[dependencies]
-harmony = { path = "../../harmony" }
-harmony_cli = { path = "../../harmony_cli" }
-harmony_macros = { path = "../../harmony_macros" }
-harmony_types = { path = "../../harmony_types" }
-tokio.workspace = true
-url.workspace = true
-async-trait.workspace = true
-serde.workspace = true
-log.workspace = true
-env_logger.workspace = true
-brocade = { path = "../../brocade" }

examples/brocade_switch/src/main.rs

@@ -1,157 +0,0 @@
-use std::str::FromStr;
-
-use async_trait::async_trait;
-use brocade::{BrocadeOptions, PortOperatingMode};
-use harmony::{
-    data::Version,
-    infra::brocade::BrocadeSwitchClient,
-    interpret::{Interpret, InterpretError, InterpretName, InterpretStatus, Outcome},
-    inventory::Inventory,
-    score::Score,
-    topology::{
-        HostNetworkConfig, PortConfig, PreparationError, PreparationOutcome, Switch, SwitchClient,
-        SwitchError, Topology,
-    },
-};
-use harmony_macros::ip;
-use harmony_types::{id::Id, net::MacAddress, switch::PortLocation};
-use log::{debug, info};
-use serde::Serialize;
-
-#[tokio::main]
-async fn main() {
-    let switch_score = BrocadeSwitchScore {
-        port_channels_to_clear: vec![
-            Id::from_str("17").unwrap(),
-            Id::from_str("19").unwrap(),
-            Id::from_str("18").unwrap(),
-        ],
-        ports_to_configure: vec![
-            (PortLocation(2, 0, 17), PortOperatingMode::Trunk),
-            (PortLocation(2, 0, 19), PortOperatingMode::Trunk),
-            (PortLocation(1, 0, 18), PortOperatingMode::Trunk),
-        ],
-    };
-    harmony_cli::run(
-        Inventory::autoload(),
-        SwitchTopology::new().await,
-        vec![Box::new(switch_score)],
-        None,
-    )
-    .await
-    .unwrap();
-}
-
-#[derive(Clone, Debug, Serialize)]
-struct BrocadeSwitchScore {
-    port_channels_to_clear: Vec<Id>,
-    ports_to_configure: Vec<PortConfig>,
-}
-
-impl<T: Topology + Switch> Score<T> for BrocadeSwitchScore {
-    fn name(&self) -> String {
-        "BrocadeSwitchScore".to_string()
-    }
-
-    #[doc(hidden)]
-    fn create_interpret(&self) -> Box<dyn Interpret<T>> {
-        Box::new(BrocadeSwitchInterpret {
-            score: self.clone(),
-        })
-    }
-}
-
-#[derive(Debug)]
-struct BrocadeSwitchInterpret {
-    score: BrocadeSwitchScore,
-}
-
-#[async_trait]
-impl<T: Topology + Switch> Interpret<T> for BrocadeSwitchInterpret {
-    async fn execute(
-        &self,
-        _inventory: &Inventory,
-        topology: &T,
-    ) -> Result<Outcome, InterpretError> {
-        info!("Applying switch configuration {:?}", self.score);
-        debug!(
-            "Clearing port channel {:?}",
-            self.score.port_channels_to_clear
-        );
-        topology
-            .clear_port_channel(&self.score.port_channels_to_clear)
-            .await
-            .map_err(|e| InterpretError::new(e.to_string()))?;
-        debug!("Configuring interfaces {:?}", self.score.ports_to_configure);
-        topology
-            .configure_interface(&self.score.ports_to_configure)
-            .await
-            .map_err(|e| InterpretError::new(e.to_string()))?;
-        Ok(Outcome::success("switch configured".to_string()))
-    }
-    fn get_name(&self) -> InterpretName {
-        InterpretName::Custom("BrocadeSwitchInterpret")
-    }
-    fn get_version(&self) -> Version {
-        todo!()
-    }
-    fn get_status(&self) -> InterpretStatus {
-        todo!()
-    }
-    fn get_children(&self) -> Vec<Id> {
-        todo!()
-    }
-}
-
-struct SwitchTopology {
-    client: Box<dyn SwitchClient>,
-}
-
-#[async_trait]
-impl Topology for SwitchTopology {
-    fn name(&self) -> &str {
-        "SwitchTopology"
-    }
-
-    async fn ensure_ready(&self) -> Result<PreparationOutcome, PreparationError> {
-        Ok(PreparationOutcome::Noop)
-    }
-}
-
-impl SwitchTopology {
-    async fn new() -> Self {
-        let mut options = BrocadeOptions::default();
-        options.ssh.port = 2222;
-        let client =
-            BrocadeSwitchClient::init(&vec![ip!("127.0.0.1")], &"admin", &"password", options)
-                .await
-                .expect("Failed to connect to switch");
-
-        let client = Box::new(client);
-        Self { client }
-    }
-}
-
-#[async_trait]
-impl Switch for SwitchTopology {
-    async fn setup_switch(&self) -> Result<(), SwitchError> {
-        todo!()
-    }
-
-    async fn get_port_for_mac_address(
-        &self,
-        _mac_address: &MacAddress,
-    ) -> Result<Option<PortLocation>, SwitchError> {
-        todo!()
-    }
-
-    async fn configure_port_channel(&self, _config: &HostNetworkConfig) -> Result<(), SwitchError> {
-        todo!()
-    }
-    async fn clear_port_channel(&self, ids: &Vec<Id>) -> Result<(), SwitchError> {
-        self.client.clear_port_channel(ids).await
-    }
-    async fn configure_interface(&self, ports: &Vec<PortConfig>) -> Result<(), SwitchError> {
-        self.client.configure_interface(ports).await
-    }
-}

examples/cli/src/main.rs

@@ -2,7 +2,7 @@ use harmony::{
     inventory::Inventory,
     modules::{
         dummy::{ErrorScore, PanicScore, SuccessScore},
-        inventory::{HarmonyDiscoveryStrategy, LaunchDiscoverInventoryAgentScore},
+        inventory::LaunchDiscoverInventoryAgentScore,
     },
     topology::LocalhostTopology,
 };
@@ -18,7 +18,6 @@ async fn main() {
             Box::new(PanicScore {}),
             Box::new(LaunchDiscoverInventoryAgentScore {
                 discovery_timeout: Some(10),
-                discovery_strategy: HarmonyDiscoveryStrategy::MDNS,
             }),
         ],
         None,

examples/harmony_inventory_builder/Cargo.toml

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

examples/harmony_inventory_builder/build_docker.sh

@@ -1,11 +0,0 @@
-cargo build -p harmony_inventory_builder --release --target x86_64-unknown-linux-musl
-
-SCRIPT_DIR="$(dirname ${0})"
-
-cd "${SCRIPT_DIR}/docker/"
-
-cp ../../../target/x86_64-unknown-linux-musl/release/harmony_inventory_builder .
-
-docker build . -t hub.nationtech.io/harmony/harmony_inventory_builder
-
-docker push hub.nationtech.io/harmony/harmony_inventory_builder

examples/harmony_inventory_builder/docker/Dockerfile

@@ -1,10 +0,0 @@
-FROM debian:12-slim
-
-RUN mkdir  /app
-WORKDIR /app/
-
-COPY harmony_inventory_builder /app/
-
-ENV RUST_LOG=info
-
-CMD ["sleep", "infinity"]

examples/harmony_inventory_builder/src/main.rs

@@ -1,36 +0,0 @@
-use harmony::{
-    inventory::{HostRole, Inventory},
-    modules::inventory::{DiscoverHostForRoleScore, HarmonyDiscoveryStrategy},
-    topology::LocalhostTopology,
-};
-use harmony_macros::cidrv4;
-
-#[tokio::main]
-async fn main() {
-    let discover_worker = DiscoverHostForRoleScore {
-        role: HostRole::Worker,
-        number_desired_hosts: 3,
-        discovery_strategy: HarmonyDiscoveryStrategy::SUBNET {
-            cidr: cidrv4!("192.168.0.1/25"),
-            port: 25000,
-        },
-    };
-
-    let discover_control_plane = DiscoverHostForRoleScore {
-        role: HostRole::ControlPlane,
-        number_desired_hosts: 3,
-        discovery_strategy: HarmonyDiscoveryStrategy::SUBNET {
-            cidr: cidrv4!("192.168.0.1/25"),
-            port: 25000,
-        },
-    };
-
-    harmony_cli::run(
-        Inventory::autoload(),
-        LocalhostTopology::new(),
-        vec![Box::new(discover_worker), Box::new(discover_control_plane)],
-        None,
-    )
-    .await
-    .unwrap();
-}

examples/nanodc/src/main.rs

@@ -39,10 +39,10 @@ async fn main() {
         .expect("Failed to get credentials");
 
     let switches: Vec<IpAddr> = vec![ip!("192.168.33.101")];
-    let brocade_options = BrocadeOptions {
+    let brocade_options = Some(BrocadeOptions {
         dry_run: *harmony::config::DRY_RUN,
         ..Default::default()
-    };
+    });
     let switch_client = BrocadeSwitchClient::init(
         &switches,
         &switch_auth.username,

examples/okd_installation/src/topology.rs

@@ -31,10 +31,10 @@ pub async fn get_topology() -> HAClusterTopology {
         .expect("Failed to get credentials");
 
     let switches: Vec<IpAddr> = vec![ip!("192.168.1.101")]; // TODO: Adjust me
-    let brocade_options = BrocadeOptions {
+    let brocade_options = Some(BrocadeOptions {
         dry_run: *harmony::config::DRY_RUN,
         ..Default::default()
-    };
+    });
     let switch_client = BrocadeSwitchClient::init(
         &switches,
         &switch_auth.username,

examples/okd_pxe/src/topology.rs

@@ -26,10 +26,10 @@ pub async fn get_topology() -> HAClusterTopology {
         .expect("Failed to get credentials");
 
     let switches: Vec<IpAddr> = vec![ip!("192.168.1.101")]; // TODO: Adjust me
-    let brocade_options = BrocadeOptions {
+    let brocade_options = Some(BrocadeOptions {
         dry_run: *harmony::config::DRY_RUN,
         ..Default::default()
-    };
+    });
     let switch_client = BrocadeSwitchClient::init(
         &switches,
         &switch_auth.username,

examples/opnsense/src/main.rs

@@ -35,10 +35,10 @@ async fn main() {
         .expect("Failed to get credentials");
 
     let switches: Vec<IpAddr> = vec![ip!("192.168.5.101")]; // TODO: Adjust me
-    let brocade_options = BrocadeOptions {
+    let brocade_options = Some(BrocadeOptions {
         dry_run: *harmony::config::DRY_RUN,
         ..Default::default()
-    };
+    });
     let switch_client = BrocadeSwitchClient::init(
         &switches,
         &switch_auth.username,

harmony/src/domain/hardware/mod.rs

@@ -152,10 +152,10 @@ impl PhysicalHost {
     pub fn parts_list(&self) -> String {
         let PhysicalHost {
             id,
-            category: _,
+            category,
             network,
             storage,
-            labels: _,
+            labels,
             memory_modules,
             cpus,
         } = self;
@@ -226,8 +226,8 @@ impl PhysicalHost {
                 speed_mhz,
                 manufacturer,
                 part_number,
-                serial_number: _,
-                rank: _,
+                serial_number,
+                rank,
             } = mem;
             parts_list.push_str(&format!(
                 "\n{}Gb, {}Mhz, Manufacturer ({}), Part Number ({})",

harmony/src/domain/interpret/mod.rs

@@ -4,8 +4,6 @@ use std::error::Error;
 use async_trait::async_trait;
 use derive_new::new;
 
-use crate::inventory::HostRole;
-
 use super::{
     data::Version, executors::ExecutorError, inventory::Inventory, topology::PreparationError,
 };

harmony/src/domain/topology/failover.rs

@@ -0,0 +1,141 @@
+use async_trait::async_trait;
+
+use log::{debug, info};
+use std::collections::HashMap;
+
+use crate::{
+    modules::postgresql::capability::{
+        BootstrapConfig, BootstrapStrategy, ExternalClusterConfig, PostgreSQL,
+        PostgreSQLClusterRole, PostgreSQLConfig, PostgreSQLEndpoint, ReplicaConfig,
+        ReplicationCerts,
+    },
+    topology::{PreparationError, PreparationOutcome, Topology},
+};
+
+pub struct FailoverTopology<T> {
+    primary: T,
+    replica: T,
+}
+
+#[async_trait]
+impl<T: Send + Sync> Topology for FailoverTopology<T> {
+    fn name(&self) -> &str {
+        "FailoverTopology"
+    }
+
+    async fn ensure_ready(&self) -> Result<PreparationOutcome, PreparationError> {
+        todo!()
+    }
+}
+
+#[async_trait]
+impl<T: PostgreSQL> PostgreSQL for FailoverTopology<T> {
+    async fn deploy(&self, config: &PostgreSQLConfig) -> Result<String, String> {
+        info!(
+            "Starting deployment of failover topology '{}'",
+            config.cluster_name
+        );
+
+        let primary_config = PostgreSQLConfig {
+            cluster_name: config.cluster_name.clone(),
+            instances: config.instances,
+            storage_size: config.storage_size.clone(),
+            role: PostgreSQLClusterRole::Primary,
+        };
+
+        info!(
+            "Deploying primary cluster '{{}}' ({} instances, {:?} storage)",
+            primary_config.cluster_name, primary_config.storage_size
+        );
+
+        let primary_cluster_name = self.primary.deploy(&primary_config).await?;
+
+        info!("Primary cluster '{primary_cluster_name}' deployed successfully");
+
+        info!("Retrieving replication certificates for primary '{primary_cluster_name}'");
+
+        let certs = self
+            .primary
+            .get_replication_certs(&primary_cluster_name)
+            .await?;
+
+        info!("Replication certificates retrieved successfully");
+
+        info!("Retrieving public endpoint for primary '{primary_cluster_name}");
+
+        let endpoint = self
+            .primary
+            .get_public_endpoint(&primary_cluster_name)
+            .await?
+            .ok_or_else(|| "No public endpoint configured on primary cluster".to_string())?;
+
+        info!(
+            "Public endpoint '{}:{}' retrieved for primary",
+            endpoint.host, endpoint.port
+        );
+
+        info!("Configuring replica connection parameters and bootstrap");
+
+        let mut connection_parameters = HashMap::new();
+        connection_parameters.insert("host".to_string(), endpoint.host);
+        connection_parameters.insert("port".to_string(), endpoint.port.to_string());
+        connection_parameters.insert("dbname".to_string(), "postgres".to_string());
+        connection_parameters.insert("user".to_string(), "streaming_replica".to_string());
+        connection_parameters.insert("sslmode".to_string(), "verify-ca".to_string());
+        connection_parameters.insert("sslnegotiation".to_string(), "direct".to_string());
+
+        debug!("Replica connection parameters: {:?}", connection_parameters);
+
+        let external_cluster = ExternalClusterConfig {
+            name: primary_cluster_name.clone(),
+            connection_parameters,
+        };
+
+        let bootstrap_config = BootstrapConfig {
+            strategy: BootstrapStrategy::PgBasebackup,
+        };
+
+        let replica_cluster_config = ReplicaConfig {
+            primary_cluster_name: primary_cluster_name.clone(),
+            replication_certs: certs,
+            bootstrap: bootstrap_config,
+            external_cluster,
+        };
+
+        let replica_config = PostgreSQLConfig {
+            cluster_name: format!("{}-replica", primary_cluster_name),
+            instances: config.instances,
+            storage_size: config.storage_size.clone(),
+            role: PostgreSQLClusterRole::Replica(replica_cluster_config),
+        };
+
+        info!(
+            "Deploying replica cluster '{}' ({} instances, {:?} storage) on replica topology",
+            replica_config.cluster_name, replica_config.instances, replica_config.storage_size
+        );
+
+        self.replica.deploy(&replica_config).await?;
+
+        info!(
+            "Replica cluster '{}' deployed successfully; failover topology '{}' ready",
+            replica_config.cluster_name, config.cluster_name
+        );
+
+        Ok(primary_cluster_name)
+    }
+
+    async fn get_replication_certs(&self, cluster_name: &str) -> Result<ReplicationCerts, String> {
+        self.primary.get_replication_certs(cluster_name).await
+    }
+
+    async fn get_endpoint(&self, cluster_name: &str) -> Result<PostgreSQLEndpoint, String> {
+        self.primary.get_endpoint(cluster_name).await
+    }
+
+    async fn get_public_endpoint(
+        &self,
+        cluster_name: &str,
+    ) -> Result<Option<PostgreSQLEndpoint>, String> {
+        self.primary.get_public_endpoint(cluster_name).await
+    }
+}

harmony/src/domain/topology/ha_cluster.rs

@@ -1,5 +1,4 @@
 use async_trait::async_trait;
-use brocade::PortOperatingMode;
 use harmony_macros::ip;
 use harmony_types::{
     id::Id,
@@ -9,7 +8,7 @@ use harmony_types::{
 use log::debug;
 use log::info;
 
-use crate::{infra::network_manager::OpenShiftNmStateNetworkManager, topology::PortConfig};
+use crate::infra::network_manager::OpenShiftNmStateNetworkManager;
 use crate::topology::PxeOptions;
 use crate::{data::FileContent, executors::ExecutorError};
 
@@ -299,16 +298,6 @@ impl Switch for HAClusterTopology {
 
         Ok(())
     }
-
-    async fn clear_port_channel(&self, ids: &Vec<Id>) -> Result<(), SwitchError> {
-        todo!()
-    }
-    async fn configure_interface(
-        &self,
-        ports: &Vec<PortConfig>,
-    ) -> Result<(), SwitchError> {
-        todo!()
-    }
 }
 
 #[async_trait]
@@ -532,6 +521,4 @@ impl SwitchClient for DummyInfra {
     ) -> Result<u8, SwitchError> {
         unimplemented!("{}", UNIMPLEMENTED_DUMMY_INFRA)
     }
-    async fn clear_port_channel(&self, ids: &Vec<Id>) -> Result<(), SwitchError> {todo!()}
-    async fn configure_interface(&self, ports: &Vec<PortConfig>) -> Result<(), SwitchError> {todo!()}
 }

harmony/src/domain/topology/mod.rs

@@ -1,5 +1,7 @@
 mod ha_cluster;
 pub mod ingress;
+mod failover;
+pub use failover::*;
 use harmony_types::net::IpAddress;
 mod host_binding;
 mod http;

harmony/src/domain/topology/network.rs

@@ -7,7 +7,6 @@ use std::{
 };
 
 use async_trait::async_trait;
-use brocade::PortOperatingMode;
 use derive_new::new;
 use harmony_types::{
     id::Id,
@@ -215,8 +214,6 @@ impl From<String> for NetworkError {
     }
 }
 
-pub type PortConfig = (PortLocation, PortOperatingMode);
-
 #[async_trait]
 pub trait Switch: Send + Sync {
     async fn setup_switch(&self) -> Result<(), SwitchError>;
@@ -227,8 +224,6 @@ pub trait Switch: Send + Sync {
     ) -> Result<Option<PortLocation>, SwitchError>;
 
     async fn configure_port_channel(&self, config: &HostNetworkConfig) -> Result<(), SwitchError>;
-    async fn clear_port_channel(&self, ids: &Vec<Id>) -> Result<(), SwitchError>;
-    async fn configure_interface(&self, ports: &Vec<PortConfig>) -> Result<(), SwitchError>;
 }
 
 #[derive(Clone, Debug, PartialEq)]
@@ -288,9 +283,6 @@ pub trait SwitchClient: Debug + Send + Sync {
         channel_name: &str,
         switch_ports: Vec<PortLocation>,
     ) -> Result<u8, SwitchError>;
-
-    async fn clear_port_channel(&self, ids: &Vec<Id>) -> Result<(), SwitchError>;
-    async fn configure_interface(&self, ports: &Vec<PortConfig>) -> Result<(), SwitchError>;
 }
 
 #[cfg(test)]

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

@@ -14,7 +14,7 @@ use k8s_openapi::{
     },
     apimachinery::pkg::util::intstr::IntOrString,
 };
-use kube::{Resource, api::DynamicObject};
+use kube::Resource;
 use log::debug;
 use serde::de::DeserializeOwned;
 use serde_json::json;

harmony/src/infra/brocade.rs

@@ -1,13 +1,12 @@
 use async_trait::async_trait;
 use brocade::{BrocadeClient, BrocadeOptions, InterSwitchLink, InterfaceStatus, PortOperatingMode};
 use harmony_types::{
-    id::Id,
     net::{IpAddress, MacAddress},
     switch::{PortDeclaration, PortLocation},
 };
 use option_ext::OptionExt;
 
-use crate::topology::{PortConfig, SwitchClient, SwitchError};
+use crate::topology::{SwitchClient, SwitchError};
 
 #[derive(Debug)]
 pub struct BrocadeSwitchClient {
@@ -19,9 +18,9 @@ impl BrocadeSwitchClient {
         ip_addresses: &[IpAddress],
         username: &str,
         password: &str,
-        options: BrocadeOptions,
+        options: Option<BrocadeOptions>,
     ) -> Result<Self, brocade::Error> {
-        let brocade = brocade::init(ip_addresses, username, password, options).await?;
+        let brocade = brocade::init(ip_addresses, 22, username, password, options).await?;
         Ok(Self { brocade })
     }
 }
@@ -60,7 +59,7 @@ impl SwitchClient for BrocadeSwitchClient {
         }
 
         self.brocade
-            .configure_interfaces(&interfaces)
+            .configure_interfaces(interfaces)
             .await
             .map_err(|e| SwitchError::new(e.to_string()))?;
 
@@ -112,24 +111,6 @@ impl SwitchClient for BrocadeSwitchClient {
 
         Ok(channel_id)
     }
-    async fn clear_port_channel(&self, ids: &Vec<Id>) -> Result<(), SwitchError> {
-        for i in ids {
-            self.brocade
-                .clear_port_channel(&i.to_string())
-                .await
-                .map_err(|e| SwitchError::new(e.to_string()))?;
-        }
-        Ok(())
-    }
-    async fn configure_interface(&self, ports: &Vec<PortConfig>) -> Result<(), SwitchError> {
-        // FIXME hardcoded TenGigabitEthernet = bad
-        let ports = ports.iter().map(|p| (format!("TenGigabitEthernet {}", p.0), p.1.clone())).collect();
-        self.brocade
-            .configure_interfaces(&ports)
-            .await
-            .map_err(|e| SwitchError::new(e.to_string()))?;
-        Ok(())
-    }
 }
 
 #[cfg(test)]
@@ -166,8 +147,8 @@ mod tests {
 
         let configured_interfaces = brocade.configured_interfaces.lock().unwrap();
         assert_that!(*configured_interfaces).contains_exactly(vec![
-            (first_interface.port_location, PortOperatingMode::Access),
-            (second_interface.port_location, PortOperatingMode::Access),
+            (first_interface.name.clone(), PortOperatingMode::Access),
+            (second_interface.name.clone(), PortOperatingMode::Access),
         ]);
     }
 
@@ -274,10 +255,10 @@ mod tests {
 
         async fn configure_interfaces(
             &self,
-            interfaces: &Vec<(String, PortOperatingMode)>,
+            interfaces: Vec<(String, PortOperatingMode)>,
         ) -> Result<(), Error> {
             let mut configured_interfaces = self.configured_interfaces.lock().unwrap();
-            *configured_interfaces = interfaces.clone();
+            *configured_interfaces = interfaces;
 
             Ok(())
         }

harmony/src/infra/kube.rs

@@ -121,7 +121,7 @@ mod test {
     #[test]
     fn deployment_to_dynamic_roundtrip() {
         // Create a sample Deployment with nested structures
-        let deployment = Deployment {
+        let mut deployment = Deployment {
             metadata: ObjectMeta {
                 name: Some("my-deployment".to_string()),
                 labels: Some({

harmony/src/infra/network_manager.rs

@@ -135,8 +135,6 @@ impl OpenShiftNmStateNetworkManager {
                 description: Some(format!("Member of bond {bond_name}")),
                 r#type: nmstate::InterfaceType::Ethernet,
                 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()
@@ -162,7 +160,7 @@ impl OpenShiftNmStateNetworkManager {
 
         interfaces.push(nmstate::Interface {
             name: bond_name.to_string(),
-            description: Some(format!("Network bond for host {host}")),
+            description: Some(format!("HARMONY - Network bond for host {host}")),
             r#type: nmstate::InterfaceType::Bond,
             state: "up".to_string(),
             copy_mac_from,

harmony/src/infra/opnsense/mod.rs

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

harmony/src/modules/dhcp.rs

@@ -19,11 +19,8 @@ pub struct DhcpScore {
     pub host_binding: Vec<HostBinding>,
     pub next_server: Option<IpAddress>,
     pub boot_filename: Option<String>,
-    /// Boot filename to be provided to PXE clients identifying as BIOS
     pub filename: Option<String>,
-    /// Boot filename to be provided to PXE clients identifying as uefi but NOT iPXE
     pub filename64: Option<String>,
-    /// Boot filename to be provided to PXE clients identifying as iPXE
     pub filenameipxe: Option<String>,
     pub dhcp_range: (IpAddress, IpAddress),
     pub domain: Option<String>,

harmony/src/modules/inventory/discovery.rs

@@ -5,10 +5,11 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     data::Version,
+    hardware::PhysicalHost,
     infra::inventory::InventoryRepositoryFactory,
     interpret::{Interpret, InterpretError, InterpretName, InterpretStatus, Outcome},
     inventory::{HostRole, Inventory},
-    modules::inventory::{HarmonyDiscoveryStrategy, LaunchDiscoverInventoryAgentScore},
+    modules::inventory::LaunchDiscoverInventoryAgentScore,
     score::Score,
     topology::Topology,
 };
@@ -16,13 +17,11 @@ use crate::{
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DiscoverHostForRoleScore {
     pub role: HostRole,
-    pub number_desired_hosts: i16,
-    pub discovery_strategy : HarmonyDiscoveryStrategy,
 }
 
 impl<T: Topology> Score<T> for DiscoverHostForRoleScore {
     fn name(&self) -> String {
-        format!("DiscoverHostForRoleScore({:?})", self.role)
+        "DiscoverInventoryAgentScore".to_string()
     }
 
     fn create_interpret(&self) -> Box<dyn Interpret<T>> {
@@ -49,15 +48,13 @@ impl<T: Topology> Interpret<T> for DiscoverHostForRoleInterpret {
         );
         LaunchDiscoverInventoryAgentScore {
             discovery_timeout: None,
-            discovery_strategy: self.score.discovery_strategy.clone(),
         }
         .interpret(inventory, topology)
         .await?;
 
-        let mut chosen_hosts = vec![];
+        let host: PhysicalHost;
         let host_repo = InventoryRepositoryFactory::build().await?;
 
-        let mut assigned_hosts = 0;
         loop {
             let all_hosts = host_repo.get_all_hosts().await?;
 
@@ -78,25 +75,16 @@ impl<T: Topology> Interpret<T> for DiscoverHostForRoleInterpret {
             match ans {
                 Ok(choice) => {
                     info!(
-                        "Assigned role {:?} for node {}",
-                        self.score.role,
-                        choice.summary()
+                        "Selected {} as the {:?} node.",
+                        choice.summary(),
+                        self.score.role
                     );
                     host_repo
                         .save_role_mapping(&self.score.role, &choice)
                         .await?;
-                    chosen_hosts.push(choice);
-                    assigned_hosts += 1;
-
-                    info!(
-                        "Found {assigned_hosts} hosts for role {:?}",
-                        self.score.role
-                    );
-
-                    if assigned_hosts == self.score.number_desired_hosts {
+                    host = choice;
                     break;
                 }
-                }
                 Err(inquire::InquireError::OperationCanceled) => {
                     info!("Refresh requested. Fetching list of discovered hosts again...");
                     continue;
@@ -112,13 +100,8 @@ impl<T: Topology> Interpret<T> for DiscoverHostForRoleInterpret {
         }
 
         Ok(Outcome::success(format!(
-            "Successfully discovered {} hosts {} for role {:?}",
-            self.score.number_desired_hosts,
-            chosen_hosts
-                .iter()
-                .map(|h| h.summary())
-                .collect::<Vec<String>>()
-                .join(", "),
+            "Successfully discovered host {} for role {:?}",
+            host.summary(),
             self.score.role
         )))
     }

harmony/src/modules/inventory/mod.rs

@@ -1,10 +1,6 @@
 mod discovery;
 pub mod inspect;
-use std::net::Ipv4Addr;
-
-use cidr::{Ipv4Cidr, Ipv4Inet};
 pub use discovery::*;
-use tokio::time::{Duration, timeout};
 
 use async_trait::async_trait;
 use harmony_inventory_agent::local_presence::DiscoveryEvent;
@@ -28,7 +24,6 @@ use harmony_types::id::Id;
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LaunchDiscoverInventoryAgentScore {
     pub discovery_timeout: Option<u64>,
-    pub discovery_strategy: HarmonyDiscoveryStrategy,
 }
 
 impl<T: Topology> Score<T> for LaunchDiscoverInventoryAgentScore {
@@ -48,12 +43,6 @@ struct DiscoverInventoryAgentInterpret {
     score: LaunchDiscoverInventoryAgentScore,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum HarmonyDiscoveryStrategy {
-    MDNS,
-    SUBNET { cidr: cidr::Ipv4Cidr, port: u16 },
-}
-
 #[async_trait]
 impl<T: Topology> Interpret<T> for DiscoverInventoryAgentInterpret {
     async fn execute(
@@ -68,37 +57,6 @@ impl<T: Topology> Interpret<T> for DiscoverInventoryAgentInterpret {
             ),
         };
 
-        match self.score.discovery_strategy {
-            HarmonyDiscoveryStrategy::MDNS => self.launch_mdns_discovery().await,
-            HarmonyDiscoveryStrategy::SUBNET { cidr, port } => {
-                self.launch_cidr_discovery(&cidr, port).await
-            }
-        };
-
-        Ok(Outcome::success(
-            "Discovery process completed successfully".to_string(),
-        ))
-    }
-
-    fn get_name(&self) -> InterpretName {
-        InterpretName::DiscoverInventoryAgent
-    }
-
-    fn get_version(&self) -> Version {
-        todo!()
-    }
-
-    fn get_status(&self) -> InterpretStatus {
-        todo!()
-    }
-
-    fn get_children(&self) -> Vec<Id> {
-        todo!()
-    }
-}
-
-impl DiscoverInventoryAgentInterpret {
-    async fn launch_mdns_discovery(&self) {
         harmony_inventory_agent::local_presence::discover_agents(
             self.score.discovery_timeout,
             |event: DiscoveryEvent| -> Result<(), String> {
@@ -154,8 +112,6 @@ impl DiscoverInventoryAgentInterpret {
                                 cpus,
                             };
 
-                            // FIXME only save the host when it is new or something changed in it.
-                            // we currently are saving the host every time it is discovered.
                             let repo = InventoryRepositoryFactory::build()
                                 .await
                                 .map_err(|e| format!("Could not build repository : {e}"))
@@ -176,111 +132,25 @@ impl DiscoverInventoryAgentInterpret {
                 Ok(())
             },
         )
-        .await
+        .await;
+        Ok(Outcome::success(
+            "Discovery process completed successfully".to_string(),
+        ))
     }
 
-    // async fn launch_cidr_discovery(&self, cidr : &Ipv4Cidr, port: u16) {
-    //     todo!("launnch cidr discovery for {cidr} : {port}
-    //         - Iterate over all possible addresses in cidr
-    //         - make calls in batches of 20 attempting to reach harmony inventory agent on <addr, port> using same as above harmony_inventory_agent::client::get_host_inventory(&address, port)
-    //         - Log warn when response is 404, it means the port was used by something else unexpected
-    //         - Log error when response is 5xx
-    //         - Log debug when no response (timeout 15 seconds)
-    //         - Log info when found and response is 2xx
-    //         ");
-    // }
-    async fn launch_cidr_discovery(&self, cidr: &Ipv4Cidr, port: u16) {
-        let addrs: Vec<Ipv4Inet> = cidr.iter().collect();
-        let total = addrs.len();
-        info!(
-            "Starting CIDR discovery for {} hosts on {}/{} (port {})",
-            total,
-            cidr.network_length(),
-            cidr,
-            port
-        );
-
-        let batch_size: usize = 20;
-        let timeout_secs = 5;
-        let request_timeout = Duration::from_secs(timeout_secs);
-
-        let mut current_batch = 0;
-        let num_batches = addrs.len() / batch_size;
-
-        for batch in addrs.chunks(batch_size) {
-            current_batch += 1;
-            info!("Starting query batch {current_batch} of {num_batches}, timeout {timeout_secs}");
-            let mut tasks = Vec::with_capacity(batch.len());
-
-            for addr in batch {
-                let addr = addr.address().to_string();
-                let port = port;
-
-                let task = tokio::spawn(async move {
-                    match timeout(
-                        request_timeout,
-                        harmony_inventory_agent::client::get_host_inventory(&addr, port),
-                    )
-                    .await
-                    {
-                        Ok(Ok(host)) => {
-                            info!("Found and response is 2xx for {addr}:{port}");
-
-                            // Reuse the same conversion to PhysicalHost as MDNS flow
-                            let harmony_inventory_agent::hwinfo::PhysicalHost {
-                                storage_drives,
-                                storage_controller,
-                                memory_modules,
-                                cpus,
-                                chipset,
-                                network_interfaces,
-                                management_interface,
-                                host_uuid,
-                            } = host;
-
-                            let host = PhysicalHost {
-                                id: Id::from(host_uuid),
-                                category: HostCategory::Server,
-                                network: network_interfaces,
-                                storage: storage_drives,
-                                labels: vec![Label {
-                                    name: "discovered-by".to_string(),
-                                    value: "harmony-inventory-agent".to_string(),
-                                }],
-                                memory_modules,
-                                cpus,
-                            };
-
-                            // Save host to inventory
-                            let repo = InventoryRepositoryFactory::build()
-                                .await
-                                .map_err(|e| format!("Could not build repository : {e}"))
-                                .unwrap();
-                            if let Err(e) = repo.save(&host).await {
-                                log::debug!("Failed to save host {}: {e}", host.id);
-                            } else {
-                                info!("Saved host id {}, summary : {}", host.id, host.summary());
-                            }
-                        }
-                        Ok(Err(e)) => {
-                            log::info!("Error querying inventory agent on {addr}:{port} : {e}");
-                        }
-                        Err(_) => {
-                            // Timeout for this host
-                            log::debug!("No response (timeout) for {addr}:{port}");
-                        }
-                    }
-                });
-
-                tasks.push(task);
+    fn get_name(&self) -> InterpretName {
+        InterpretName::DiscoverInventoryAgent
     }
 
-            // Wait for this batch to complete
-            for t in tasks {
-                let _ = t.await;
-            }
+    fn get_version(&self) -> Version {
+        todo!()
     }
 
-        info!("CIDR discovery completed");
+    fn get_status(&self) -> InterpretStatus {
+        todo!()
+    }
+
+    fn get_children(&self) -> Vec<Id> {
+        todo!()
     }
 }

harmony/src/modules/mod.rs

@@ -17,3 +17,4 @@ pub mod prometheus;
 pub mod storage;
 pub mod tenant;
 pub mod tftp;
+pub mod postgresql;

harmony/src/modules/okd/bootstrap_01_prepare.rs

@@ -4,7 +4,7 @@ use crate::{
     infra::inventory::InventoryRepositoryFactory,
     interpret::{Interpret, InterpretError, InterpretName, InterpretStatus, Outcome},
     inventory::{HostRole, Inventory},
-    modules::inventory::{DiscoverHostForRoleScore, HarmonyDiscoveryStrategy},
+    modules::inventory::DiscoverHostForRoleScore,
     score::Score,
     topology::HAClusterTopology,
 };
@@ -104,8 +104,6 @@ When you can dig them, confirm to continue.
             bootstrap_host = hosts.into_iter().next().to_owned();
             DiscoverHostForRoleScore {
                 role: HostRole::Bootstrap,
-                number_desired_hosts: 1,
-                discovery_strategy: HarmonyDiscoveryStrategy::MDNS,
             }
             .interpret(inventory, topology)
             .await?;

harmony/src/modules/okd/bootstrap_03_control_plane.rs

@@ -6,7 +6,7 @@ use crate::{
     inventory::{HostRole, Inventory},
     modules::{
         dhcp::DhcpHostBindingScore, http::IPxeMacBootFileScore,
-        inventory::{DiscoverHostForRoleScore, HarmonyDiscoveryStrategy}, okd::templates::BootstrapIpxeTpl,
+        inventory::DiscoverHostForRoleScore, okd::templates::BootstrapIpxeTpl,
     },
     score::Score,
     topology::{HAClusterTopology, HostBinding},
@@ -58,10 +58,11 @@ impl OKDSetup03ControlPlaneInterpret {
         inventory: &Inventory,
         topology: &HAClusterTopology,
     ) -> Result<Vec<PhysicalHost>, InterpretError> {
-        const REQUIRED_HOSTS: i16 = 3;
+        const REQUIRED_HOSTS: usize = 3;
         let repo = InventoryRepositoryFactory::build().await?;
-        let control_plane_hosts = repo.get_host_for_role(&HostRole::ControlPlane).await?;
+        let mut control_plane_hosts = repo.get_host_for_role(&HostRole::ControlPlane).await?;
 
+        while control_plane_hosts.len() < REQUIRED_HOSTS {
             info!(
                 "Discovery of {} control plane hosts in progress, current number {}",
                 REQUIRED_HOSTS,
@@ -70,28 +71,26 @@ impl OKDSetup03ControlPlaneInterpret {
             // This score triggers the discovery agent for a specific role.
             DiscoverHostForRoleScore {
                 role: HostRole::ControlPlane,
-            number_desired_hosts: REQUIRED_HOSTS,
-            discovery_strategy: HarmonyDiscoveryStrategy::MDNS,
             }
             .interpret(inventory, topology)
             .await?;
+            control_plane_hosts = repo.get_host_for_role(&HostRole::ControlPlane).await?;
+        }
 
-        let control_plane_hosts = repo.get_host_for_role(&HostRole::ControlPlane).await?;
-
-        if control_plane_hosts.len() < REQUIRED_HOSTS as usize {
-            return Err(InterpretError::new(format!(
+        if control_plane_hosts.len() < REQUIRED_HOSTS {
+            Err(InterpretError::new(format!(
                 "OKD Requires at least {} control plane hosts, but only found {}. Cannot proceed.",
                 REQUIRED_HOSTS,
                 control_plane_hosts.len()
-            )));
-        }
-
+            )))
+        } else {
             // Take exactly the number of required hosts to ensure consistency.
             Ok(control_plane_hosts
                 .into_iter()
-            .take(REQUIRED_HOSTS as usize)
+                .take(REQUIRED_HOSTS)
                 .collect())
         }
+    }
 
     /// Configures DHCP host bindings for all control plane nodes.
     async fn configure_host_binding(

harmony/src/modules/okd/crd/nmstate.rs

@@ -417,6 +417,7 @@ pub struct EthernetSpec {
 #[serde(rename_all = "kebab-case")]
 pub struct BondSpec {
     pub mode: String,
+    #[serde(alias = "port")]
     pub ports: Vec<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub options: Option<BTreeMap<String, Value>>,

harmony/src/modules/okd/host_network.rs

@@ -251,14 +251,14 @@ impl<T: Topology + NetworkManager + Switch> Interpret<T> for HostNetworkConfigur
 #[cfg(test)]
 mod tests {
     use assertor::*;
-    use brocade::PortOperatingMode;
     use harmony_types::{net::MacAddress, switch::PortLocation};
     use lazy_static::lazy_static;
 
     use crate::{
         hardware::HostCategory,
         topology::{
-            HostNetworkConfig, NetworkError, PortConfig, PreparationError, PreparationOutcome, SwitchError, SwitchPort
+            HostNetworkConfig, NetworkError, PreparationError, PreparationOutcome, SwitchError,
+            SwitchPort,
         },
     };
     use std::{
@@ -692,14 +692,5 @@ mod tests {
 
             Ok(())
         }
-        async fn clear_port_channel(&self, ids: &Vec<Id>) -> Result<(), SwitchError> {
-            todo!()
-        }
-        async fn configure_interface(
-            &self,
-            port_config: &Vec<PortConfig>,
-        ) -> Result<(), SwitchError> {
-            todo!()
-        }
     }
 }

harmony/src/modules/postgresql/capability.rs

@@ -0,0 +1,81 @@
+use async_trait::async_trait;
+use harmony_types::storage::StorageSize;
+use std::collections::HashMap;
+
+#[async_trait]
+pub trait PostgreSQL {
+    async fn deploy(&self, config: &PostgreSQLConfig) -> Result<String, String>;
+
+    /// Extracts PostgreSQL-specific replication certs (PEM format) from a deployed primary cluster.
+    /// Abstracts away storage/retrieval details (e.g., secrets, files).
+    async fn get_replication_certs(&self, cluster_name: &str) -> Result<ReplicationCerts, String>;
+
+    /// Gets the internal/private endpoint (e.g., k8s service FQDN:5432) for the cluster.
+    async fn get_endpoint(&self, cluster_name: &str) -> Result<PostgreSQLEndpoint, String>;
+
+    /// Gets the public/externally routable endpoint if configured (e.g., OKD Route:443 for TLS passthrough).
+    /// Returns None if no public endpoint (internal-only cluster).
+    /// UNSTABLE: This is opinionated for initial multisite use cases. Networking abstraction is complex
+    /// (cf. k8s Ingress -> Gateway API evolution); may move to higher-order Networking/PostgreSQLNetworking trait.
+    async fn get_public_endpoint(&self, cluster_name: &str) -> Result<Option<PostgreSQLEndpoint>, String>;
+}
+
+#[derive(Clone, Debug)]
+pub struct PostgreSQLConfig {
+    pub cluster_name: String,
+    pub instances: u32,
+    pub storage_size: StorageSize,
+    pub role: PostgreSQLClusterRole,
+}
+
+#[derive(Clone, Debug)]
+pub enum PostgreSQLClusterRole {
+    Primary,
+    Replica(ReplicaClusterConfig),
+}
+
+#[derive(Clone, Debug)]
+pub struct ReplicaConfig {
+    /// Name of the primary cluster this replica will sync from
+    pub primary_cluster_name: String,
+    /// Certs extracted from primary via Topology::get_replication_certs()
+    pub replication_certs: ReplicationCerts,
+    /// Bootstrap method (e.g., pg_basebackup from primary)
+    pub bootstrap: BootstrapConfig,
+    /// External cluster connection details for CNPG spec.externalClusters
+    pub external_cluster: ExternalClusterConfig,
+}
+
+#[derive(Clone, Debug)]
+pub struct BootstrapConfig {
+    pub strategy: BootstrapStrategy,
+}
+
+#[derive(Clone, Debug)]
+pub enum BootstrapStrategy {
+    PgBasebackup,
+}
+
+#[derive(Clone, Debug)]
+pub struct ExternalClusterConfig {
+    /// Name used in CNPG externalClusters list
+    pub name: String,
+    /// Connection params (host/port set by multisite logic, sslmode='verify-ca', etc.)
+    pub connection_parameters: HashMap<String, String>,
+}
+
+#[derive(Clone, Debug)]
+pub struct ReplicationCerts {
+    /// PEM-encoded CA cert from primary
+    pub ca_cert_pem: String,
+    /// PEM-encoded streaming_replica client cert (tls.crt)
+    pub streaming_replica_cert_pem: String,
+    /// PEM-encoded streaming_replica client key (tls.key)
+    pub streaming_replica_key_pem: String,
+}
+
+#[derive(Clone, Debug)]
+pub struct PostgreSQLEndpoint {
+    pub host: String,
+    pub port: u16,
+}

harmony/src/modules/postgresql/mod.rs

@@ -0,0 +1,7 @@
+
+pub mod capability;
+mod score;
+
+
+pub mod failover;
+

harmony/src/modules/postgresql/score.rs

@@ -0,0 +1,236 @@
+use crate::{
+    domain::{data::Version, interpret::InterpretStatus},
+    interpret::{Interpret, InterpretError, InterpretName, Outcome},
+    inventory::Inventory,
+    modules::postgresql::capability::PostgreSQL,
+    score::Score,
+    topology::Topology,
+};
+
+use super::capability::*;
+
+use derive_new::new;
+use harmony_types::{id::Id, storage::StorageSize};
+
+use async_trait::async_trait;
+use log::info;
+use serde::Serialize;
+
+pub struct PostgreSQLScore {
+    config: PostgreSQLConfig,
+}
+
+#[derive(Debug, Clone)]
+pub struct PostgreSQLInterpret {
+    config: PostgreSQLConfig,
+    version: Version,
+    status: InterpretStatus,
+}
+
+impl PostgreSQLInterpret {
+    pub fn new(config: PostgreSQLConfig) -> Self {
+        let version = Version::from("1.0.0").expect("Version should be valid");
+        Self {
+            config,
+            version,
+            status: InterpretStatus::QUEUED,
+        }
+    }
+}
+
+impl<T: Topology + PostgreSQL> Score<T> for PostgreSQLScore {
+    fn name(&self) -> String {
+        "PostgreSQLScore".to_string()
+    }
+
+    fn create_interpret(&self) -> Box<dyn Interpret<T>> {
+        Box::new(PostgreSQLInterpret::new(self.config.clone()))
+    }
+}
+
+#[async_trait]
+impl<T: Topology + PostgreSQL> Interpret<T> for PostgreSQLInterpret {
+    fn get_name(&self) -> InterpretName {
+        InterpretName::Custom("PostgreSQLInterpret")
+    }
+
+    fn get_version(&self) -> crate::domain::data::Version {
+        self.version.clone()
+    }
+
+    fn get_status(&self) -> InterpretStatus {
+        self.status.clone()
+    }
+
+    fn get_children(&self) -> Vec<Id> {
+        todo!()
+    }
+
+    async fn execute(
+        &self,
+        _inventory: &Inventory,
+        topology: &T,
+    ) -> Result<Outcome, InterpretError> {
+        info!(
+            "Executing PostgreSQLInterpret with config {:?}",
+            self.config
+        );
+
+        let cluster_name = topology
+            .deploy(&self.config)
+            .await
+            .map_err(|e| InterpretError::from(e))?;
+
+        Ok(Outcome::success(format!(
+            "Deployed PostgreSQL cluster `{cluster_name}`"
+        )))
+    }
+}
+
+#[derive(Debug, new, Clone, Serialize)]
+pub struct MultisitePostgreSQLScore {
+    pub cluster_name: String,
+    pub primary_site: Id,
+    pub replica_sites: Vec<Id>,
+    pub instances: u32,
+    pub storage_size: StorageSize,
+}
+
+impl<T: FailoverTopology + crate::modules::postgresql::capability::PostgreSQL> Score<T> for MultisitePostgreSQLScore {
+
+    fn create_interpret(&self) -> Box<dyn Interpret<T>> {
+        Box::new(MultisitePostgreSQLInterpret::new(self.clone()))
+    }
+
+    fn name(&self) -> String {
+        "MultisitePostgreSQLScore".to_string()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct MultisitePostgreSQLInterpret {
+    score: MultisitePostgreSQLScore,
+    version: Version,
+    status: InterpretStatus,
+}
+
+impl MultisitePostgreSQLInterpret {
+    pub fn new(score: MultisitePostgreSQLScore) -> Self {
+        let version = Version::from("1.0.0").expect("Version should be valid");
+        Self {
+            score,
+            version,
+            status: InterpretStatus::QUEUED,
+        }
+    }
+}
+
+#[async_trait]
+impl<T: MultisiteTopology + PostgreSQL> Interpret<T> for MultisitePostgreSQLInterpret {
+    fn get_name(&self) -> InterpretName {
+        InterpretName::Custom("MultisitePostgreSQLInterpret")
+    }
+
+    fn get_version(&self) -> Version {
+        self.version.clone()
+    }
+
+    fn get_status(&self) -> InterpretStatus {
+        self.status.clone()
+    }
+
+    fn get_children(&self) -> Vec<Id> {
+        todo!("Track child interprets per site")
+    }
+
+async fn execute(
+    &self,
+    inventory: &Inventory,
+    topology: &T,
+) -> Result<Outcome, InterpretError> {
+
+        info!(
+            "Orchestrating multisite PostgreSQL: primary {:?}, replicas {:?}",
+            self.score.primary_site, self.score.replica_sites
+        );
+
+        // 1. Deploy primary
+        let primary_topo = topology.primary();
+
+        let primary_config = PostgreSQLConfig {
+            cluster_name: self.score.cluster_name.clone(),
+            instances: self.score.instances,
+            storage_size: self.score.storage_size.clone(),
+            role: ClusterRole::Primary,
+        };
+        let primary_cluster_name = primary_topo
+            .deploy(&primary_config)
+            .await
+            .map_err(|e| InterpretError::from(format!("Primary deploy failed: {e}")))?;
+
+        // 2. Extract certs & public endpoint from primary
+        let certs = primary_topo
+            .get_replication_certs(&primary_cluster_name)
+            .await
+            .map_err(|e| InterpretError::from(format!("Certs extract failed: {e}")))?;
+        let public_endpoint = primary_topo
+            .get_public_endpoint(&primary_cluster_name)
+            .await??
+            .ok_or_else(|| InterpretError::from("No public endpoint on primary"))?;
+
+        // 3. Deploy replicas
+        for replica_site in &self.score.replica_sites {
+let replica_topo = topology.replica();
+
+                .map_err(|e| {
+                    InterpretError::from(format!(
+                        "Replica site {:?} lookup failed: {e}",
+                        replica_site
+                    ))
+                })?;
+
+            let connection_params: HashMap<String, String> = [
+                ("host".to_string(), public_endpoint.host.clone()),
+                ("port".to_string(), public_endpoint.port.to_string()),
+                ("dbname".to_string(), "postgres".to_string()),
+                ("user".to_string(), "streaming_replica".to_string()),
+                ("sslmode".to_string(), "verify-ca".to_string()),
+                ("sslnegotiation".to_string(), "direct".to_string()),
+            ]
+            .into_iter()
+            .collect();
+
+            let external_cluster = ExternalClusterConfig {
+                name: "primary-cluster".to_string(),
+                connection_parameters: connection_params,
+            };
+
+            let replica_config_struct = ReplicaConfig {
+                primary_cluster_name: primary_cluster_name.clone(),
+                replication_certs: certs.clone(),
+                bootstrap: BootstrapConfig {
+                    strategy: BootstrapStrategy::PgBasebackup,
+                },
+                external_cluster,
+            };
+
+            let replica_config = PostgreSQLConfig {
+                cluster_name: format!("{}-replica-{}", self.score.cluster_name, replica_site),
+                instances: self.score.instances,
+                storage_size: self.score.storage_size.clone(),
+                role: ClusterRole::Replica(replica_config_struct),
+            };
+
+            let _replica_cluster = replica_topo.deploy(&replica_config).await.map_err(|e| {
+                InterpretError::from(format!("Replica {:?} deploy failed: {e}", replica_site))
+            })?;
+        }
+
+        Ok(Outcome::success(format!(
+            "Multisite PostgreSQL `{}` deployed: primary `{}`, {} replicas",
+            self.score.cluster_name,
+            primary_cluster_name,
+            self.score.replica_sites.len()
+        )))
+    }
+}

harmony_inventory_agent/build_docker.sh

@@ -1,11 +0,0 @@
-cargo build -p harmony_inventory_agent --release --target x86_64-unknown-linux-musl
-
-SCRIPT_DIR="$(dirname ${0})"
-
-cd "${SCRIPT_DIR}/docker/"
-
-cp ../../target/x86_64-unknown-linux-musl/release/harmony_inventory_agent .
-
-docker build . -t hub.nationtech.io/harmony/harmony_inventory_agent
-
-docker push hub.nationtech.io/harmony/harmony_inventory_agent

harmony_inventory_agent/docker/.gitignore

@@ -1 +0,0 @@
-harmony_inventory_agent

harmony_inventory_agent/docker/Dockerfile

@@ -1,17 +0,0 @@
-FROM debian:12-slim
-
-# install packages required to make these commands available : lspci, lsmod, dmidecode, smartctl, ip
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends pciutils kmod dmidecode smartmontools iproute2 && \
-    rm -rf /var/lib/apt/lists/*
-
-
-RUN mkdir  /app
-WORKDIR /app/
-
-COPY harmony_inventory_agent /app/
-
-ENV RUST_LOG=info
-
-CMD [ "/app/harmony_inventory_agent" ]
-

harmony_inventory_agent/harmony-inventory-agent-daemonset.yaml

@@ -1,117 +0,0 @@
-apiVersion: v1
-kind: Namespace
-metadata:
-  name: harmony-inventory-agent
-  labels:
-    pod-security.kubernetes.io/enforce: privileged
-    pod-security.kubernetes.io/audit: privileged
-    pod-security.kubernetes.io/warn: privileged
----
-apiVersion: v1
-kind: ServiceAccount
-metadata:
-  name: harmony-inventory-agent
-  namespace: harmony-inventory-agent
----
-# Grant the built-in "privileged" SCC to the SA
-apiVersion: rbac.authorization.k8s.io/v1
-kind: Role
-metadata:
-  name: use-privileged-scc
-  namespace: harmony-inventory-agent
-rules:
-- apiGroups: ["security.openshift.io"]
-  resources: ["securitycontextconstraints"]
-  resourceNames: ["privileged"]
-  verbs: ["use"]
----
-apiVersion: rbac.authorization.k8s.io/v1
-kind: RoleBinding
-metadata:
-  name: use-privileged-scc
-  namespace: harmony-inventory-agent
-subjects:
-- kind: ServiceAccount
-  name: harmony-inventory-agent
-  namespace: harmony-inventory-agent
-roleRef:
-  apiGroup: rbac.authorization.k8s.io
-  kind: Role
-  name: use-privileged-scc
----
-apiVersion: apps/v1
-kind: DaemonSet
-metadata:
-  name: harmony-inventory-agent
-  namespace: harmony-inventory-agent
-spec:
-  selector:
-    matchLabels:
-      app: harmony-inventory-agent
-  template:
-    metadata:
-      labels:
-        app: harmony-inventory-agent
-    spec:
-      serviceAccountName: harmony-inventory-agent
-      hostNetwork: true
-      dnsPolicy: ClusterFirstWithHostNet
-      tolerations:
-      - key: "node-role.kubernetes.io/master"
-        operator: "Exists"
-        effect: "NoSchedule"
-      containers:
-      - name: inventory-agent
-        image: hub.nationtech.io/harmony/harmony_inventory_agent
-        imagePullPolicy: Always
-        env:
-          - name: RUST_LOG
-            value: "harmony_inventory_agent=trace,info"
-        resources:
-          limits:
-            cpu: 200m
-            memory: 256Mi
-          requests:
-            cpu: 100m
-            memory: 128Mi
-        securityContext:
-          privileged: true
-          # optional: leave the rest unset since privileged SCC allows it
-          #
----
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: harmony-inventory-builder
-  namespace: harmony-inventory-agent
-spec:
-  replicas: 1
-  strategy: {}
-  selector:
-    matchLabels:
-      app: harmony-inventory-builder
-  template:
-    metadata:
-      labels:
-        app: harmony-inventory-builder
-    spec:
-      serviceAccountName: harmony-inventory-agent
-      hostNetwork: true
-      dnsPolicy: ClusterFirstWithHostNet
-      containers:
-      - name: inventory-agent
-        image: hub.nationtech.io/harmony/harmony_inventory_builder
-        imagePullPolicy: Always
-        env:
-          - name: RUST_LOG
-            value: "harmony_inventory_builder=trace,info"
-        resources:
-          limits:
-            cpu: 200m
-            memory: 256Mi
-          requests:
-            cpu: 100m
-            memory: 128Mi
-        securityContext:
-          privileged: true
-          # optional: leave the rest unset since privileged SCC allows it

harmony_inventory_agent/src/hwinfo.rs

@@ -1,5 +1,5 @@
 use harmony_types::net::MacAddress;
-use log::{debug, trace, warn};
+use log::{debug, warn};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::fs;
@@ -121,48 +121,20 @@ pub struct ManagementInterface {
 
 impl PhysicalHost {
     pub fn gather() -> Result<Self, String> {
-        trace!("Start gathering physical host information");
         let mut sys = System::new_all();
-        trace!("System new_all called");
         sys.refresh_all();
-        trace!("System refresh_all called");
 
         Self::all_tools_available()?;
 
-        trace!("All tools_available success");
-
-        let storage_drives = Self::gather_storage_drives()?;
-        trace!("got storage drives");
-
-        let storage_controller = Self::gather_storage_controller()?;
-        trace!("got storage controller");
-
-        let memory_modules = Self::gather_memory_modules()?;
-        trace!("got memory_modules");
-
-        let cpus = Self::gather_cpus(&sys)?;
-        trace!("got cpus");
-
-        let chipset = Self::gather_chipset()?;
-        trace!("got chipsets");
-
-        let network_interfaces = Self::gather_network_interfaces()?;
-        trace!("got network_interfaces");
-
-        let management_interface = Self::gather_management_interface()?;
-        trace!("got management_interface");
-
-        let host_uuid = Self::get_host_uuid()?;
-
         Ok(Self {
-            storage_drives,
-            storage_controller,
-            memory_modules,
-            cpus,
-            chipset,
-            network_interfaces,
-            management_interface,
-            host_uuid,
+            storage_drives: Self::gather_storage_drives()?,
+            storage_controller: Self::gather_storage_controller()?,
+            memory_modules: Self::gather_memory_modules()?,
+            cpus: Self::gather_cpus(&sys)?,
+            chipset: Self::gather_chipset()?,
+            network_interfaces: Self::gather_network_interfaces()?,
+            management_interface: Self::gather_management_interface()?,
+            host_uuid: Self::get_host_uuid()?,
         })
     }
 
@@ -236,8 +208,6 @@ impl PhysicalHost {
             ));
         }
 
-        debug!("All tools found!");
-
         Ok(())
     }
 
@@ -261,10 +231,7 @@ impl PhysicalHost {
     fn gather_storage_drives() -> Result<Vec<StorageDrive>, String> {
         let mut drives = Vec::new();
 
-        trace!("Starting storage drive discovery using lsblk");
-
         // Use lsblk with JSON output for robust parsing
-        trace!("Executing 'lsblk -d -o NAME,MODEL,SERIAL,SIZE,ROTA,WWN -n -e 7 --json'");
         let output = Command::new("lsblk")
             .args([
                 "-d",
@@ -278,18 +245,13 @@ impl PhysicalHost {
             .output()
             .map_err(|e| format!("Failed to execute lsblk: {}", e))?;
 
-        trace!(
-            "lsblk command executed successfully (status: {:?})",
-            output.status
-        );
-
         if !output.status.success() {
-            let stderr_str = String::from_utf8_lossy(&output.stderr);
-            debug!("lsblk command failed: {stderr_str}");
-            return Err(format!("lsblk command failed: {stderr_str}"));
+            return Err(format!(
+                "lsblk command failed: {}",
+                String::from_utf8_lossy(&output.stderr)
+            ));
         }
 
-        trace!("Parsing lsblk JSON output");
         let json: Value = serde_json::from_slice(&output.stdout)
             .map_err(|e| format!("Failed to parse lsblk JSON output: {}", e))?;
 
@@ -298,8 +260,6 @@ impl PhysicalHost {
             .and_then(|v| v.as_array())
             .ok_or("Invalid lsblk JSON: missing 'blockdevices' array")?;
 
-        trace!("Found {} blockdevices in lsblk output", blockdevices.len());
-
         for device in blockdevices {
             let name = device
                 .get("name")
@@ -308,72 +268,52 @@ impl PhysicalHost {
                 .to_string();
 
             if name.is_empty() {
-                trace!("Skipping unnamed device entry: {:?}", device);
                 continue;
             }
 
-            trace!("Inspecting block device: {name}");
-
-            // Extract metadata fields
             let model = device
                 .get("model")
                 .and_then(|v| v.as_str())
                 .map(|s| s.trim().to_string())
                 .unwrap_or_default();
-            trace!("Model for {name}: '{}'", model);
 
             let serial = device
                 .get("serial")
                 .and_then(|v| v.as_str())
                 .map(|s| s.trim().to_string())
                 .unwrap_or_default();
-            trace!("Serial for {name}: '{}'", serial);
 
             let size_str = device
                 .get("size")
                 .and_then(|v| v.as_str())
                 .ok_or("Missing 'size' in lsblk device")?;
-            trace!("Reported size for {name}: {}", size_str);
             let size_bytes = Self::parse_size(size_str)?;
-            trace!("Parsed size for {name}: {} bytes", size_bytes);
 
             let rotational = device
                 .get("rota")
                 .and_then(|v| v.as_bool())
                 .ok_or("Missing 'rota' in lsblk device")?;
-            trace!("Rotational flag for {name}: {}", rotational);
 
             let wwn = device
                 .get("wwn")
                 .and_then(|v| v.as_str())
                 .map(|s| s.trim().to_string())
                 .filter(|s| !s.is_empty() && s != "null");
-            trace!("WWN for {name}: {:?}", wwn);
 
             let device_path = Path::new("/sys/block").join(&name);
-            trace!("Sysfs path for {name}: {:?}", device_path);
 
-            trace!("Reading logical block size for {name}");
             let logical_block_size = Self::read_sysfs_u32(
                 &device_path.join("queue/logical_block_size"),
             )
             .map_err(|e| format!("Failed to read logical block size for {}: {}", name, e))?;
-            trace!("Logical block size for {name}: {}", logical_block_size);
 
-            trace!("Reading physical block size for {name}");
             let physical_block_size = Self::read_sysfs_u32(
                 &device_path.join("queue/physical_block_size"),
             )
             .map_err(|e| format!("Failed to read physical block size for {}: {}", name, e))?;
-            trace!("Physical block size for {name}: {}", physical_block_size);
 
-            trace!("Determining interface type for {name}");
             let interface_type = Self::get_interface_type(&name, &device_path)?;
-            trace!("Interface type for {name}: {}", interface_type);
-
-            trace!("Getting SMART status for {name}");
             let smart_status = Self::get_smart_status(&name)?;
-            trace!("SMART status for {name}: {:?}", smart_status);
 
             let mut drive = StorageDrive {
                 name: name.clone(),
@@ -390,31 +330,19 @@ impl PhysicalHost {
 
             // Enhance with additional sysfs info if available
             if device_path.exists() {
-                trace!("Enhancing drive {name} with extra sysfs metadata");
                 if drive.model.is_empty() {
-                    trace!("Reading model from sysfs for {name}");
                     drive.model = Self::read_sysfs_string(&device_path.join("device/model"))
-                        .unwrap_or_else(|_| format!("Failed to read model for {}", name));
+                        .unwrap_or(format!("Failed to read model for {}", name));
                 }
                 if drive.serial.is_empty() {
-                    trace!("Reading serial from sysfs for {name}");
                     drive.serial = Self::read_sysfs_string(&device_path.join("device/serial"))
-                        .unwrap_or_else(|_| format!("Failed to read serial for {}", name));
+                        .unwrap_or(format!("Failed to read serial for {}", name));
                 }
-            } else {
-                trace!(
-                    "Sysfs path {:?} not found for drive {name}, skipping extra metadata",
-                    device_path
-                );
             }
 
-            debug!("Discovered storage drive: {drive:?}");
             drives.push(drive);
         }
 
-        debug!("Discovered total {} storage drives", drives.len());
-        trace!("All discovered dives: {drives:?}");
-
         Ok(drives)
     }
 
@@ -490,8 +418,6 @@ impl PhysicalHost {
             }
         }
 
-        debug!("Found storage controller {controller:?}");
-
         Ok(controller)
     }
 
@@ -560,7 +486,6 @@ impl PhysicalHost {
             }
         }
 
-        debug!("Found memory modules {modules:?}");
         Ok(modules)
     }
 
@@ -576,30 +501,22 @@ impl PhysicalHost {
             frequency_mhz: global_cpu.frequency(),
         });
 
-        debug!("Found cpus {cpus:?}");
-
         Ok(cpus)
     }
 
     fn gather_chipset() -> Result<Chipset, String> {
-        let chipset = Chipset {
+        Ok(Chipset {
             name: Self::read_dmi("baseboard-product-name")?,
             vendor: Self::read_dmi("baseboard-manufacturer")?,
-        };
-
-        debug!("Found chipset {chipset:?}");
-
-        Ok(chipset)
+        })
     }
 
     fn gather_network_interfaces() -> Result<Vec<NetworkInterface>, String> {
         let mut interfaces = Vec::new();
         let sys_net_path = Path::new("/sys/class/net");
-        trace!("Reading /sys/class/net");
 
         let entries = fs::read_dir(sys_net_path)
             .map_err(|e| format!("Failed to read /sys/class/net: {}", e))?;
-        trace!("Got entries {entries:?}");
 
         for entry in entries {
             let entry = entry.map_err(|e| format!("Failed to read directory entry: {}", e))?;
@@ -608,7 +525,6 @@ impl PhysicalHost {
                 .into_string()
                 .map_err(|_| "Invalid UTF-8 in interface name")?;
             let iface_path = entry.path();
-            trace!("Inspecting interface {iface_name} path {iface_path:?}");
 
             // Skip virtual interfaces
             if iface_name.starts_with("lo")
@@ -619,101 +535,70 @@ impl PhysicalHost {
                 || iface_name.starts_with("tun")
                 || iface_name.starts_with("wg")
             {
-                trace!(
-                    "Skipping interface {iface_name} because it appears to be virtual/unsupported"
-                );
                 continue;
             }
 
             // Check if it's a physical interface by looking for device directory
             if !iface_path.join("device").exists() {
-                trace!(
-                    "Skipping interface {iface_name} since {iface_path:?}/device does not exist"
-                );
                 continue;
             }
 
-            trace!("Reading MAC address for {iface_name}");
             let mac_address = Self::read_sysfs_string(&iface_path.join("address"))
                 .map_err(|e| format!("Failed to read MAC address for {}: {}", iface_name, e))?;
             let mac_address = MacAddress::try_from(mac_address).map_err(|e| e.to_string())?;
-            trace!("MAC address for {iface_name}: {mac_address}");
 
-            let speed_path = iface_path.join("speed");
-            let speed_mbps = if speed_path.exists() {
-                trace!("Reading speed for {iface_name} from {:?}", speed_path);
-                match Self::read_sysfs_u32(&speed_path) {
-                    Ok(speed) => {
-                        trace!("Speed for {iface_name}: {speed} Mbps");
-                        Some(speed)
-                    }
+            let speed_mbps = if iface_path.join("speed").exists() {
+                match Self::read_sysfs_u32(&iface_path.join("speed")) {
+                    Ok(speed) => Some(speed),
                     Err(e) => {
                         debug!(
-                            "Failed to read speed for {}: {} (this may be expected on Wi‑Fi interfaces)",
+                            "Failed to read speed for {}: {} . This is expected to fail on wifi interfaces.",
                             iface_name, e
                         );
                         None
                     }
                 }
             } else {
-                trace!("Speed file not found for {iface_name}, skipping");
                 None
             };
 
-            trace!("Reading operstate for {iface_name}");
             let operstate = Self::read_sysfs_string(&iface_path.join("operstate"))
                 .map_err(|e| format!("Failed to read operstate for {}: {}", iface_name, e))?;
-            trace!("Operstate for {iface_name}: {operstate}");
 
-            trace!("Reading MTU for {iface_name}");
             let mtu = Self::read_sysfs_u32(&iface_path.join("mtu"))
                 .map_err(|e| format!("Failed to read MTU for {}: {}", iface_name, e))?;
-            trace!("MTU for {iface_name}: {mtu}");
 
-            trace!("Reading driver for {iface_name}");
             let driver =
                 Self::read_sysfs_symlink_basename(&iface_path.join("device/driver/module"))
                     .map_err(|e| format!("Failed to read driver for {}: {}", iface_name, e))?;
-            trace!("Driver for {iface_name}: {driver}");
 
-            trace!("Reading firmware version for {iface_name}");
             let firmware_version = Self::read_sysfs_opt_string(
                 &iface_path.join("device/firmware_version"),
             )
             .map_err(|e| format!("Failed to read firmware version for {}: {}", iface_name, e))?;
-            trace!("Firmware version for {iface_name}: {firmware_version:?}");
 
-            trace!("Fetching IP addresses for {iface_name}");
+            // Get IP addresses using ip command with JSON output
             let (ipv4_addresses, ipv6_addresses) = Self::get_interface_ips_json(&iface_name)
                 .map_err(|e| format!("Failed to get IP addresses for {}: {}", iface_name, e))?;
-            trace!("Interface {iface_name} has IPv4: {ipv4_addresses:?}, IPv6: {ipv6_addresses:?}");
 
-            let is_up = operstate == "up";
-            trace!("Constructing NetworkInterface for {iface_name} (is_up={is_up})");
-
-            let iface = NetworkInterface {
-                name: iface_name.clone(),
+            interfaces.push(NetworkInterface {
+                name: iface_name,
                 mac_address,
                 speed_mbps,
-                is_up,
+                is_up: operstate == "up",
                 mtu,
                 ipv4_addresses,
                 ipv6_addresses,
                 driver,
                 firmware_version,
-            };
-
-            debug!("Discovered interface: {iface:?}");
-            interfaces.push(iface);
+            });
         }
 
-        debug!("Discovered total {} network interfaces", interfaces.len());
-        trace!("Interfaces collected: {interfaces:?}");
         Ok(interfaces)
     }
 
     fn gather_management_interface() -> Result<Option<ManagementInterface>, String> {
-        let mgmt = if Path::new("/dev/ipmi0").exists() {
+        if Path::new("/dev/ipmi0").exists() {
             Ok(Some(ManagementInterface {
                 kind: "IPMI".to_string(),
                 address: None,
@@ -727,16 +612,11 @@ impl PhysicalHost {
             }))
         } else {
             Ok(None)
-        };
-
-        debug!("Found management interface {mgmt:?}");
-        mgmt
+        }
     }
 
     fn get_host_uuid() -> Result<String, String> {
-        let uuid = Self::read_dmi("system-uuid");
-        debug!("Found uuid {uuid:?}");
-        uuid
+        Self::read_dmi("system-uuid")
     }
 
     // Helper methods
@@ -829,8 +709,7 @@ impl PhysicalHost {
             Ok("Ramdisk".to_string())
         } else {
             // Try to determine from device path
-            let subsystem = Self::read_sysfs_string(&device_path.join("device/subsystem"))
-                .unwrap_or(String::new());
+            let subsystem = Self::read_sysfs_string(&device_path.join("device/subsystem"))?;
             Ok(subsystem
                 .split('/')
                 .next_back()
@@ -900,8 +779,6 @@ impl PhysicalHost {
         size.map(|s| s as u64)
     }
 
-    // FIXME when scanning an interface that is part of a bond/bridge we won't get an address on the
-    // interface, we should be looking at the bond/bridge device. For example, br-ex on k8s nodes.
     fn get_interface_ips_json(iface_name: &str) -> Result<(Vec<String>, Vec<String>), String> {
         let mut ipv4 = Vec::new();
         let mut ipv6 = Vec::new();

harmony_inventory_agent/src/local_presence/advertise.rs

@@ -1,4 +1,4 @@
-use log::{debug, error, info, trace, warn};
+use log::{debug, error, info, warn};
 use mdns_sd::{ServiceDaemon, ServiceInfo};
 use std::collections::HashMap;
 
@@ -12,7 +12,6 @@ use crate::{
 /// This function is synchronous and non-blocking. It spawns a background Tokio task
 /// to handle the mDNS advertisement for the lifetime of the application.
 pub fn advertise(service_port: u16) -> Result<(), PresenceError> {
-    trace!("starting advertisement process for port {service_port}");
     let host_id = match PhysicalHost::gather() {
         Ok(host) => Some(host.host_uuid),
         Err(e) => {
@@ -21,15 +20,11 @@ pub fn advertise(service_port: u16) -> Result<(), PresenceError> {
         }
     };
 
-    trace!("Found host id {host_id:?}");
-
     let instance_name = format!(
         "inventory-agent-{}",
         host_id.clone().unwrap_or("unknown".to_string())
     );
 
-    trace!("Found host id {host_id:?}, name : {instance_name}");
-
     let spawned_msg = format!("Spawned local presence advertisement task for '{instance_name}'.");
 
     tokio::spawn(async move {

harmony_inventory_agent/src/main.rs

@@ -28,7 +28,7 @@ async fn inventory() -> impl Responder {
 async fn main() -> std::io::Result<()> {
     env_logger::init();
 
-    let port = env::var("HARMONY_INVENTORY_AGENT_PORT").unwrap_or_else(|_| "25000".to_string());
+    let port = env::var("HARMONY_INVENTORY_AGENT_PORT").unwrap_or_else(|_| "8080".to_string());
     let port = port
         .parse::<u16>()
         .expect(&format!("Invalid port number, cannot parse to u16 {port}"));

harmony_types/Cargo.toml

@@ -9,4 +9,3 @@ license.workspace = true
 serde.workspace = true
 url.workspace = true
 rand.workspace = true
-log.workspace = true

harmony_types/src/lib.rs

@@ -1,3 +1,4 @@
 pub mod id;
 pub mod net;
 pub mod switch;
+pub mod storage;

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, PartialEq, Eq, Hash, Serialize, Deserialize, PartialOrd, Ord)]
 pub struct MacAddress(pub [u8; 6]);
 
 impl MacAddress {
@@ -19,6 +19,14 @@ impl From<&MacAddress> for String {
     }
 }
 
+impl std::fmt::Debug for MacAddress {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("MacAddress")
+            .field(&String::from(self))
+            .finish()
+    }
+}
+
 impl std::fmt::Display for MacAddress {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str(&String::from(self))

harmony_types/src/storage.rs

@@ -0,0 +1,6 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, PartialOrd, Ord, Debug)]
+pub struct StorageSize {
+    size_bytes: u64,
+}

harmony_types/src/switch.rs

@@ -1,6 +1,4 @@
 use std::{fmt, str::FromStr};
-use log::trace;
-use serde::Serialize;
 
 /// Simple error type for port parsing failures.
 #[derive(Debug)]
@@ -23,7 +21,7 @@ impl fmt::Display for PortParseError {
 /// Represents the atomic, physical location of a switch port: `<Stack>/<Module>/<Port>`.
 ///
 /// Example: `1/1/1`
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Serialize)]
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
 pub struct PortLocation(pub u8, pub u8, pub u8);
 
 impl fmt::Display for PortLocation {
@@ -72,11 +70,6 @@ impl FromStr for PortLocation {
 pub enum PortDeclaration {
     /// A single switch port defined by its location. Example: `PortDeclaration::Single(1/1/1)`
     Single(PortLocation),
-    /// A Named port, often used for virtual ports such as PortChannels. Example
-    /// ```rust
-    /// PortDeclaration::Named("1".to_string())
-    /// ```
-    Named(String),
     /// 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)`
@@ -137,14 +130,8 @@ impl PortDeclaration {
             return Ok(PortDeclaration::Set(start_port, end_port));
         }
 
-        match PortLocation::from_str(port_str) {
-            Ok(loc) => Ok(PortDeclaration::Single(loc)),
-            Err(e) => {
-                trace!("Failed to parse PortLocation {port_str} : {e}");
-                trace!("Falling back on named port");
-                Ok(PortDeclaration::Named(port_str.to_string()))
-            }
-        }
+        let location = PortLocation::from_str(port_str)?;
+        Ok(PortDeclaration::Single(location))
     }
 }
 
@@ -154,7 +141,6 @@ impl fmt::Display for PortDeclaration {
             PortDeclaration::Single(port) => write!(f, "{port}"),
             PortDeclaration::Range(start, end) => write!(f, "{start}-{end}"),
             PortDeclaration::Set(start, end) => write!(f, "{start}*{end}"),
-            PortDeclaration::Named(name) => write!(f, "{name}"),
         }
     }
 }

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

@@ -195,7 +195,7 @@ pub struct System {
     pub disablechecksumoffloading: u8,
     pub disablesegmentationoffloading: u8,
     pub disablelargereceiveoffloading: u8,
-    pub ipv6allow: Option<u8>,
+    pub ipv6allow: u8,
     pub powerd_ac_mode: String,
     pub powerd_battery_mode: String,
     pub powerd_normal_mode: String,
@@ -226,7 +226,6 @@ pub struct System {
     pub dns6gw: Option<String>,
     pub dns7gw: Option<String>,
     pub dns8gw: Option<String>,
-    pub prefer_ipv4: Option<String>,
     pub dnsallowoverride: u8,
     pub dnsallowoverride_exclude: Option<MaybeString>,
 }
@@ -330,7 +329,6 @@ pub struct Range {
 pub struct StaticMap {
     pub mac: String,
     pub ipaddr: String,
-    pub cid: Option<MaybeString>,
     pub hostname: String,
     pub descr: Option<MaybeString>,
     pub winsserver: MaybeString,
@@ -766,19 +764,9 @@ pub struct Jobs {
 pub struct Job {
     #[yaserde(attribute = true)]
     pub uuid: MaybeString,
-    pub name: Option<MaybeString>,
+    #[yaserde(rename = "name")]
+    pub name: MaybeString,
     // Add other fields as needed
-    pub origin: Option<MaybeString>,
-    pub enabled: Option<MaybeString>,
-    pub minutes: Option<MaybeString>,
-    pub hours: Option<MaybeString>,
-    pub days: Option<MaybeString>,
-    pub months: Option<MaybeString>,
-    pub weekdays: Option<MaybeString>,
-    pub who: Option<MaybeString>,
-    pub command: Option<MaybeString>,
-    pub parameters: Option<MaybeString>,
-    pub description: Option<MaybeString>,
 }
 
 #[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
@@ -907,28 +895,28 @@ pub struct Proxy {
 #[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
 pub struct ProxyGeneral {
     pub enabled: i8,
-    pub error_pages: Option<MaybeString>,
+    pub error_pages: String,
     #[yaserde(rename = "icpPort")]
     pub icp_port: MaybeString,
     pub logging: Logging,
     #[yaserde(rename = "alternateDNSservers")]
     pub alternate_dns_servers: MaybeString,
     #[yaserde(rename = "dnsV4First")]
-    pub dns_v4_first: Option<MaybeString>,
+    pub dns_v4_first: i8,
     #[yaserde(rename = "forwardedForHandling")]
-    pub forwarded_for_handling: Option<MaybeString>,
+    pub forwarded_for_handling: String,
     #[yaserde(rename = "uriWhitespaceHandling")]
-    pub uri_whitespace_handling: Option<MaybeString>,
+    pub uri_whitespace_handling: String,
     #[yaserde(rename = "enablePinger")]
     pub enable_pinger: i8,
     #[yaserde(rename = "useViaHeader")]
-    pub use_via_header: Option<MaybeString>,
+    pub use_via_header: i8,
     #[yaserde(rename = "suppressVersion")]
-    pub suppress_version: Option<MaybeString>,
+    pub suppress_version: i32,
     #[yaserde(rename = "connecttimeout")]
-    pub connect_timeout: Option<MaybeString>,
+    pub connect_timeout: MaybeString,
     #[yaserde(rename = "VisibleEmail")]
-    pub visible_email: Option<MaybeString>,
+    pub visible_email: String,
     #[yaserde(rename = "VisibleHostname")]
     pub visible_hostname: MaybeString,
     pub cache: Cache,
@@ -965,7 +953,7 @@ pub struct LocalCache {
     pub cache_mem: i32,
     pub maximum_object_size: MaybeString,
     pub maximum_object_size_in_memory: MaybeString,
-    pub memory_cache_mode: MaybeString,
+    pub memory_cache_mode: String,
     pub size: i32,
     pub l1: i32,
     pub l2: i32,
@@ -977,13 +965,13 @@ pub struct LocalCache {
 pub struct Traffic {
     pub enabled: i32,
     #[yaserde(rename = "maxDownloadSize")]
-    pub max_download_size: MaybeString,
+    pub max_download_size: i32,
     #[yaserde(rename = "maxUploadSize")]
-    pub max_upload_size: MaybeString,
+    pub max_upload_size: i32,
     #[yaserde(rename = "OverallBandwidthTrotteling")]
-    pub overall_bandwidth_trotteling: MaybeString,
+    pub overall_bandwidth_trotteling: i32,
     #[yaserde(rename = "perHostTrotteling")]
-    pub per_host_trotteling: MaybeString,
+    pub per_host_trotteling: i32,
 }
 
 #[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
@@ -1000,7 +988,7 @@ pub struct ParentProxy {
 
 #[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
 pub struct Forward {
-    pub interfaces: MaybeString,
+    pub interfaces: String,
     pub port: i32,
     pub sslbumpport: i32,
     pub sslbump: i32,
@@ -1045,9 +1033,9 @@ pub struct Acl {
     pub google_apps: MaybeString,
     pub youtube: MaybeString,
     #[yaserde(rename = "safePorts")]
-    pub safe_ports: MaybeString,
+    pub safe_ports: String,
     #[yaserde(rename = "sslPorts")]
-    pub ssl_ports: MaybeString,
+    pub ssl_ports: String,
     #[yaserde(rename = "remoteACLs")]
     pub remote_acls: RemoteAcls,
 }
@@ -1063,9 +1051,9 @@ pub struct RemoteAcls {
 pub struct Icap {
     pub enable: i32,
     #[yaserde(rename = "RequestURL")]
-    pub request_url: MaybeString,
+    pub request_url: String,
     #[yaserde(rename = "ResponseURL")]
-    pub response_url: MaybeString,
+    pub response_url: String,
     #[yaserde(rename = "SendClientIP")]
     pub send_client_ip: i32,
     #[yaserde(rename = "SendUsername")]
@@ -1073,7 +1061,7 @@ pub struct Icap {
     #[yaserde(rename = "EncodeUsername")]
     pub encode_username: i32,
     #[yaserde(rename = "UsernameHeader")]
-    pub username_header: MaybeString,
+    pub username_header: String,
     #[yaserde(rename = "EnablePreview")]
     pub enable_preview: i32,
     #[yaserde(rename = "PreviewSize")]
@@ -1088,9 +1076,9 @@ pub struct Authentication {
     pub method: MaybeString,
     #[yaserde(rename = "authEnforceGroup")]
     pub auth_enforce_group: MaybeString,
-    pub realm: MaybeString,
-    pub credentialsttl: MaybeString, // This field is already in snake_case
-    pub children: MaybeString,
+    pub realm: String,
+    pub credentialsttl: i32, // This field is already in snake_case
+    pub children: i32,
 }
 
 #[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
@@ -1305,7 +1293,6 @@ pub struct WireguardServerItem {
     pub peers: String,
     pub endpoint: MaybeString,
     pub peer_dns: MaybeString,
-    pub debug: Option<MaybeString>,
 }
 
 #[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
@@ -1490,7 +1477,6 @@ pub struct Ppp {
     pub ports: Option<MaybeString>,
     pub username: Option<MaybeString>,
     pub password: Option<MaybeString>,
-    pub provider: Option<MaybeString>,
 }
 
 #[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]

opnsense-config/src/modules/dhcp_legacy.rs

@@ -86,7 +86,10 @@ impl<'a> DhcpConfigLegacyISC<'a> {
             mac,
             ipaddr: ipaddr.to_string(),
             hostname,
-            ..Default::default()
+            descr: Default::default(),
+            winsserver: Default::default(),
+            dnsserver: Default::default(),
+            ntpserver: Default::default(),
         };
 
         existing_mappings.push(static_map);
@@ -123,7 +126,9 @@ impl<'a> DhcpConfigLegacyISC<'a> {
                 ipaddr: entry["ipaddr"].as_str().unwrap_or_default().to_string(),
                 hostname: entry["hostname"].as_str().unwrap_or_default().to_string(),
                 descr: entry["descr"].as_str().map(MaybeString::from),
-                ..Default::default()
+                winsserver: MaybeString::default(),
+                dnsserver: MaybeString::default(),
+                ntpserver: MaybeString::default(),
             })
             .collect();