harmony/src/infra/opnsense/load_balancer.rs

@@ -98,7 +98,7 @@ pub(crate) fn haproxy_xml_config_to_harmony_loadbalancer(
                 .backends
                 .backends
                 .iter()
-                .find(|b| Some(b.uuid.clone()) == frontend.default_backend);
+                .find(|b| b.uuid == frontend.default_backend);
 
             let mut health_check = None;
             match matching_backend {
@@ -108,7 +108,8 @@ pub(crate) fn haproxy_xml_config_to_harmony_loadbalancer(
                 }
                 None => {
                     warn!(
-                        "HAProxy config could not find a matching backend for frontend {frontend:?}"
+                        "HAProxy config could not find a matching backend for frontend {:?}",
+                        frontend
                     );
                 }
             }
@@ -143,11 +144,11 @@ pub(crate) fn get_servers_for_backend(
         .servers
         .iter()
         .filter_map(|server| {
-            let address = server.address.clone()?;
-            let port = server.port?;
-
             if backend_servers.contains(&server.uuid.as_str()) {
-                return Some(BackendServer { address, port });
+                return Some(BackendServer {
+                    address: server.address.clone(),
+                    port: server.port,
+                });
             }
             None
         })
@@ -315,7 +316,7 @@ pub(crate) fn harmony_load_balancer_service_to_haproxy_xml(
         name: format!("frontend_{}", service.listening_port),
         bind: service.listening_port.to_string(),
         mode: "tcp".to_string(), // TODO do not depend on health check here
-        default_backend: Some(backend.uuid.clone()),
+        default_backend: backend.uuid.clone(),
         ..Default::default()
     };
     info!("HAPRoxy frontend and backend mode currently hardcoded to tcp");
@@ -329,8 +330,8 @@ fn server_to_haproxy_server(server: &BackendServer) -> HAProxyServer {
         uuid: Uuid::new_v4().to_string(),
         name: format!("{}_{}", &server.address, &server.port),
         enabled: 1,
-        address: Some(server.address.clone()),
+        address: server.address.clone(),
-        port: Some(server.port),
+        port: server.port,
         mode: "active".to_string(),
         server_type: "static".to_string(),
         ..Default::default()
@@ -353,8 +354,8 @@ mod tests {
         let mut haproxy = HAProxy::default();
         let server = HAProxyServer {
             uuid: "server1".to_string(),
-            address: Some("192.168.1.1".to_string()),
+            address: "192.168.1.1".to_string(),
-            port: Some(80),
+            port: 80,
             ..Default::default()
         };
         haproxy.servers.servers.push(server);
@@ -379,8 +380,8 @@ mod tests {
         let mut haproxy = HAProxy::default();
         let server = HAProxyServer {
             uuid: "server1".to_string(),
-            address: Some("192.168.1.1".to_string()),
+            address: "192.168.1.1".to_string(),
-            port: Some(80),
+            port: 80,
             ..Default::default()
         };
         haproxy.servers.servers.push(server);
@@ -399,8 +400,8 @@ mod tests {
         let mut haproxy = HAProxy::default();
         let server = HAProxyServer {
             uuid: "server1".to_string(),
-            address: Some("192.168.1.1".to_string()),
+            address: "192.168.1.1".to_string(),
-            port: Some(80),
+            port: 80,
             ..Default::default()
         };
         haproxy.servers.servers.push(server);
@@ -421,16 +422,16 @@ mod tests {
         let mut haproxy = HAProxy::default();
         let server = HAProxyServer {
             uuid: "server1".to_string(),
-            address: Some("some-hostname.test.mcd".to_string()),
+            address: "some-hostname.test.mcd".to_string(),
-            port: Some(80),
+            port: 80,
             ..Default::default()
         };
         haproxy.servers.servers.push(server);
 
         let server = HAProxyServer {
             uuid: "server2".to_string(),
-            address: Some("192.168.1.2".to_string()),
+            address: "192.168.1.2".to_string(),
-            port: Some(8080),
+            port: 8080,
             ..Default::default()
         };
         haproxy.servers.servers.push(server);

harmony/src/modules/okd/bootstrap_load_balancer.rs

@@ -67,8 +67,6 @@ impl OKDBootstrapLoadBalancerScore {
             address: topology.bootstrap_host.ip.to_string(),
             port,
         });
-
-        backend.dedup();
         backend
     }
 }

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

@@ -310,7 +310,7 @@ pub struct Frontend {
     pub bind_options: MaybeString,
     pub mode: String,
     #[yaserde(rename = "defaultBackend")]
-    pub default_backend: Option<String>,
+    pub default_backend: String,
     pub ssl_enabled: i32,
     pub ssl_certificates: MaybeString,
     pub ssl_default_certificate: MaybeString,
@@ -543,8 +543,8 @@ pub struct HAProxyServer {
     pub enabled: u8,
     pub name: String,
     pub description: MaybeString,
-    pub address: Option<String>,
+    pub address: String,
-    pub port: Option<u16>,
+    pub port: u16,
     pub checkport: MaybeString,
     pub mode: String,
     pub multiplexer_protocol: MaybeString,

opnsense-config/src/modules/load_balancer.rs

@@ -47,22 +47,9 @@ impl<'a> LoadBalancerConfig<'a> {
         healthcheck: Option<HAProxyHealthCheck>,
     ) {
         self.remove_service_by_bind_address(&frontend.bind);
-        self.remove_servers(&servers);
-
         self.add_new_service(frontend, backend, servers, healthcheck);
     }
 
-    // Remove the corresponding real servers based on their name if they already exist.
-    fn remove_servers(&mut self, servers: &[HAProxyServer]) {
-        let server_names: HashSet<_> = servers.iter().map(|s| s.name.clone()).collect();
-        self.with_haproxy(|haproxy| {
-            haproxy
-                .servers
-                .servers
-                .retain(|s| !server_names.contains(&s.name));
-        });
-    }
-
     /// Removes a service and its dependent components based on the frontend's bind address.
     /// This performs a cascading delete of the frontend, backend, servers, and health check.
     fn remove_service_by_bind_address(&mut self, bind_address: &str) {
@@ -76,7 +63,7 @@ impl<'a> LoadBalancerConfig<'a> {
             };
 
             remove_healthcheck(haproxy, &old_backend);
-            remove_linked_servers(haproxy, &old_backend);
+            remove_servers(haproxy, &old_backend);
         });
     }
 
@@ -94,7 +81,19 @@ impl<'a> LoadBalancerConfig<'a> {
                 haproxy.healthchecks.healthchecks.push(check);
             }
 
-            haproxy.servers.servers.extend(servers);
+            let mut existing_server_names: HashSet<_> = haproxy
+                .servers
+                .servers
+                .iter()
+                .map(|s| s.name.clone())
+                .collect();
+
+            for server in servers {
+                if existing_server_names.insert(server.name.clone()) {
+                    haproxy.servers.servers.push(server);
+                }
+            }
+
             haproxy.backends.backends.push(backend);
             haproxy.frontends.frontend.push(frontend);
         });
@@ -140,12 +139,11 @@ fn remove_frontend_by_bind_address(haproxy: &mut HAProxy, bind_address: &str) ->
 }
 
 fn remove_backend(haproxy: &mut HAProxy, old_frontend: Frontend) -> Option<HAProxyBackend> {
-    let default_backend = old_frontend.default_backend?;
     let pos = haproxy
         .backends
         .backends
         .iter()
-        .position(|b| b.uuid == default_backend);
+        .position(|b| b.uuid == old_frontend.default_backend);
 
     match pos {
         Some(pos) => Some(haproxy.backends.backends.remove(pos)),
@@ -163,7 +161,7 @@ fn remove_healthcheck(haproxy: &mut HAProxy, backend: &HAProxyBackend) {
 }
 
 /// Remove the backend's servers. This assumes servers are not shared between services.
-fn remove_linked_servers(haproxy: &mut HAProxy, backend: &HAProxyBackend) {
+fn remove_servers(haproxy: &mut HAProxy, backend: &HAProxyBackend) {
     if let Some(server_uuids_str) = &backend.linked_servers.content {
         let server_uuids_to_remove: HashSet<_> = server_uuids_str.split(',').collect();
         haproxy