fix: de-duplicate backend servers list mapped from topology

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

harmony/src/modules/okd/bootstrap_load_balancer.rs

@@ -67,6 +67,8 @@ 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: String,
+    pub default_backend: Option<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: String,
+    pub address: Option<String>,
-    pub port: u16,
+    pub port: Option<u16>,
     pub checkport: MaybeString,
     pub mode: String,
     pub multiplexer_protocol: MaybeString,

opnsense-config/src/modules/load_balancer.rs

@@ -47,9 +47,22 @@ 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) {
@@ -63,7 +76,7 @@ impl<'a> LoadBalancerConfig<'a> {
             };
 
             remove_healthcheck(haproxy, &old_backend);
-            remove_servers(haproxy, &old_backend);
+            remove_linked_servers(haproxy, &old_backend);
         });
     }
 
@@ -81,19 +94,7 @@ impl<'a> LoadBalancerConfig<'a> {
                 haproxy.healthchecks.healthchecks.push(check);
             }
 
-            let mut existing_server_names: HashSet<_> = haproxy
+            haproxy.servers.servers.extend(servers);
-                .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);
         });
@@ -139,11 +140,12 @@ 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 == old_frontend.default_backend);
+        .position(|b| b.uuid == default_backend);
 
     match pos {
         Some(pos) => Some(haproxy.backends.backends.remove(pos)),
@@ -161,7 +163,7 @@ fn remove_healthcheck(haproxy: &mut HAProxy, backend: &HAProxyBackend) {
 }
 
 /// Remove the backend's servers. This assumes servers are not shared between services.
-fn remove_servers(haproxy: &mut HAProxy, backend: &HAProxyBackend) {
+fn remove_linked_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