enable multiple dns servers

dns-comunications/Cargo.toml

@@ -6,3 +6,4 @@ edition = "2024"
 [dependencies]
 dns-update = "0.1"
 base64 = "*"
+dns-config = {path = "../dns-config"}

dns-comunications/src/lib.rs

@@ -1,39 +1,53 @@
 use std::net::Ipv4Addr;
 
-use dns_update::{DnsRecord, DnsRecordType, DnsUpdater, TsigAlgorithm};
-use base64::engine::general_purpose::STANDARD;
 use base64::Engine;
+use base64::engine::general_purpose::STANDARD;
+use dns_update::{DnsUpdater, TsigAlgorithm};
+
+use dns_config::ServerZonesConnection;
+
+mod utils;
 
 pub struct DnsManager {
-    pub dns_updater: DnsUpdater,
-    pub zone: String
+    pub dns_updaters: Vec<DnsUpdater>,
+    pub zone: String,
 }
 
 impl DnsManager {
-    pub fn new(conection_str: String, key_name: String, key: String, zone: String) -> Self {
-        Self {
-            dns_updater: DnsUpdater::new_rfc2136_tsig(
-                    conection_str,
-                    key_name,
-                    STANDARD.decode(key).unwrap(),
-                    TsigAlgorithm::HmacSha256.into()
-                ).unwrap(),
-            zone
+    pub fn new(zones_data: ServerZonesConnection) -> Result<Self, dns_update::Error> {
+        let mut dns_updaters = Vec::new();
+        for zone_data in zones_data.servers_data {
+            dns_updaters.push(DnsUpdater::new_rfc2136_tsig(
+                zone_data.conection_str,
+                zone_data.key_name,
+                #[allow(unreachable_code)]
+                STANDARD.decode(zone_data.key).unwrap_or(continue),
+                TsigAlgorithm::HmacSha256.into(),
+            )?);
         }
+        Ok(Self {
+            dns_updaters,
+            zone: zones_data.root_domain,
+        })
     }
 
-    pub async fn add_domain(&self, domain_name: &String, domain_ip: Ipv4Addr) {
+    pub async fn add_domain(
+        &self,
+        domain_name: &String,
+        domain_ip: Ipv4Addr,
+    ) -> Result<(), dns_update::Error> {
         let domain = format!("{}.{}", domain_name, self.zone);
-        self.dns_updater.create(
-            domain,
-            DnsRecord::A { content: domain_ip },
-            300,
-            self.zone.clone()
-        ).await.unwrap();
+        for dns_updater in &self.dns_updaters {
+            utils::add_domain(dns_updater, &domain, &self.zone, domain_ip).await?;
+        }
+        Ok(())
     }
 
-    pub async fn del_domain(&self, domain_name: &String) {
+    pub async fn del_domain(&self, domain_name: &String) -> Result<(), dns_update::Error> {
         let domain = format!("{}.{}", domain_name, self.zone);
-        self.dns_updater.delete(domain, self.zone.clone(), DnsRecordType::A).await.unwrap();
+        for dns_updater in &self.dns_updaters {
+            utils::del_domain(dns_updater, &domain, &self.zone).await?;
+        }
+        Ok(())
     }
 }

dns-comunications/src/utils.rs

@@ -0,0 +1,22 @@
+use std::net::Ipv4Addr;
+
+use dns_update::{DnsRecord, DnsRecordType, DnsUpdater};
+
+pub async fn add_domain(
+    dns_updater: &DnsUpdater,
+    domain: &str,
+    zone: &str,
+    domain_ip: Ipv4Addr,
+) -> Result<(), dns_update::Error> {
+    dns_updater
+        .create(domain, DnsRecord::A { content: domain_ip }, 300, zone)
+        .await
+}
+
+pub async fn del_domain(
+    dns_updater: &DnsUpdater,
+    domain: &str,
+    zone: &str,
+) -> Result<(), dns_update::Error> {
+    dns_updater.delete(domain, zone, DnsRecordType::A).await
+}