refactor to work as a lib

Cargo.lock

@@ -174,9 +174,8 @@ dependencies = [
 
 [[package]]
 name = "dns-update"
-version = "0.1.5"
+version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+source = "git+ssh://git@github.com/groche97/dns-update.git#a72bdf31817f27b9e5fea22fa7e3690749b6c380"
-checksum = "42788b21a1231c646c46508c406db9bf628342a781c24888bf60e1a29396deb2"
 dependencies = [
  "hickory-client",
  "reqwest",

config_template.toml

@@ -1,16 +1,16 @@
 [zone]
 root_domain = "root.domain.example"
 
-[[server]]
+[[dns_server]]
-conection_str = "tcp://127.0.0.1:53"
+connection_str = "tcp://127.0.0.1:53"
 
-[server.key]
+[dns_server.key]
-name = "key name"
+name = "key 0 name"
-value = "key in base64"
+value = "key 0 in base64"
 
-[[server]]
+[[dns_server]]
-conection_str = "udp://192.168.1.1:53"
+connection_str = "udp://192.168.1.1:53"
 
-[server.key]
+[dns_server.key]
-name = "key name"
+name = "key 1 name"
-value = "key in base64"
+value = "key 1 in base64"

dns-comunications/Cargo.toml

@@ -4,6 +4,6 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-dns-update = "0.1"
+dns-update = { git = "ssh://git@github.com/groche97/dns-update.git" }
 base64 = "*"
 dns-config = {path = "../dns-config"}

dns-comunications/src/lib.rs

@@ -38,21 +38,25 @@ impl DnsManager {
 
     pub async fn add_domain(
         &self,
-        domain_name: &String,
+        domain_name: &str,
         domain_ip: Ipv4Addr,
     ) -> Result<(), dns_update::Error> {
-        let domain = format!("{}.{}", domain_name, self.zone);
+        let domain = self.get_full_domain(domain_name);
         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) -> Result<(), dns_update::Error> {
+    pub async fn del_domain(&self, domain_name: &str) -> Result<(), dns_update::Error> {
-        let domain = format!("{}.{}", domain_name, self.zone);
+        let domain = self.get_full_domain(domain_name);
         for dns_updater in &self.dns_updaters {
             utils::del_domain(dns_updater, &domain, &self.zone).await?;
         }
         Ok(())
     }
+
+    pub fn get_full_domain(&self, domain_name: &str) -> String {
+        format!("{}.{}", domain_name, self.zone)
+    }
 }

dns-config/src/lib.rs

@@ -1,25 +1,27 @@
 use std::{error::Error, fs::read_to_string, io};
-use toml::{Table, Value};
+use toml::Table;
 
+#[derive(Clone)]
 pub struct ZoneConnectionData {
     pub conection_str: String,
     pub key_name: String,
     pub key: String,
 }
 
+#[derive(Clone)]
 pub struct ServerZonesConnection {
     pub root_domain: String,
     pub servers_data: Vec<ZoneConnectionData>,
 }
 
 impl ZoneConnectionData {
-    pub fn get_config(file_name: &String) -> Result<Vec<Self>, Box<dyn Error>> {
+    pub fn get_config(file_name: &str) -> Result<Vec<Self>, Box<dyn Error>> {
         let mut ret = Vec::new();
         let key_toml = read_to_string(file_name)?.parse::<Table>()?;
 
-        for servers in key_toml["server"]
+        for servers in key_toml["dns_server"]
             .as_array()
-            .ok_or(generate_toml_parser_error_in_field("server"))?
+            .ok_or(generate_toml_parser_error_in_field("dns_server"))?
         {
             let conection_str: String = servers["connection_str"]
                 .as_str()
@@ -44,9 +46,9 @@ impl ZoneConnectionData {
 }
 
 impl ServerZonesConnection {
-    pub fn get_config(file_name: &String) -> Result<Self, Box<dyn Error>> {
+    pub fn get_config(file_name: &str) -> Result<Self, Box<dyn Error>> {
-        let root_domain: String =
+        let root_domain: String = read_to_string(file_name)?.parse::<Table>()?["zone"]
-            read_to_string(file_name)?.parse::<Table>()?["zone"]["root_domain"]
+            ["root_domain"]
             .as_str()
             .ok_or(generate_toml_parser_error_in_field("zone root_domain"))?
             .to_string();

src/lib.rs

@@ -0,0 +1,2 @@
+pub use dns_comunications::DnsManager;
+pub use dns_config::ServerZonesConnection;

src/main.rs

@@ -1,19 +0,0 @@
-use std::{net::Ipv4Addr, str::FromStr};
-
-use dns_comunications;
-use dns_config;
-
-#[tokio::main]
-async fn main() {
-    let zone_data =
-        dns_config::ServerZonesConnection::get_config(&"config.toml".to_string()).unwrap();
-    let dns_manager = dns_comunications::DnsManager::new(zone_data).unwrap();
-
-    _ = dns_manager
-        .add_domain(
-            &"testzone".to_string(),
-            Ipv4Addr::from_str("1.1.1.1").unwrap(),
-        )
-        .await;
-    _ = dns_manager.del_domain(&"testzone".to_string()).await;
-}

tests/test_config.rs

@@ -0,0 +1,20 @@
+use dns_config;
+
+#[test]
+fn test_config() {
+    let zone_data =
+        dns_config::ServerZonesConnection::get_config(&"config_template.toml".to_string()).unwrap();
+    assert_eq!(zone_data.root_domain, "root.domain.example");
+    assert_eq!(
+        zone_data.servers_data.get(1).unwrap().conection_str,
+        "udp://192.168.1.1:53"
+    );
+    assert_eq!(
+        zone_data.servers_data.get(0).unwrap().key,
+        "key 0 in base64"
+    );
+    assert_eq!(
+        zone_data.servers_data.get(1).unwrap().key_name,
+        "key 1 name"
+    );
+}

tests/test_management.rs

@@ -0,0 +1,27 @@
+use std::{net::Ipv4Addr, str::FromStr};
+
+use dns_comunications::DnsManager;
+
+fn get_manager() -> DnsManager {
+    dns_comunications::DnsManager::new(
+        dns_config::ServerZonesConnection::get_config(&"config.toml".to_string()).unwrap(),
+    )
+    .unwrap()
+}
+
+#[tokio::test]
+async fn test_creating_zone() {
+    let res = get_manager()
+        .add_domain(
+            &"testzone".to_string(),
+            Ipv4Addr::from_str("1.1.1.1").unwrap(),
+        )
+        .await;
+    assert!(res.is_ok());
+}
+
+#[tokio::test]
+async fn test_deleting_zone() {
+    let res = get_manager().del_domain(&"testzone".to_string()).await;
+    assert!(res.is_ok());
+}