remove unnecessary unwrap

dns-comunications/src/lib.rs

@@ -17,11 +17,16 @@ impl DnsManager {
     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 {
+            let decode_zone_data = match STANDARD.decode(zone_data.key) {
+                Ok(d_data) => d_data,
+                Err(_e) => continue,
+            };
+
             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),
+                decode_zone_data,
                 TsigAlgorithm::HmacSha256.into(),
             )?);
         }

dns-config/src/lib.rs

@@ -1,5 +1,5 @@
-use std::fs::read_to_string;
+use std::{error::Error, fs::read_to_string, io};
-use toml::Table;
+use toml::{Table, Value};
 
 pub struct ZoneConnectionData {
     pub conection_str: String,
@@ -13,34 +13,54 @@ pub struct ServerZonesConnection {
 }
 
 impl ZoneConnectionData {
-    pub fn get_config(file_name: &String) -> Vec<Self> {
+    pub fn get_config(file_name: &String) -> Result<Vec<Self>, Box<dyn Error>> {
         let mut ret = Vec::new();
-        let key_toml = read_to_string(file_name).unwrap().parse::<Table>().unwrap();
+        let key_toml = read_to_string(file_name)?.parse::<Table>()?;
-        for servers in key_toml["server"].as_array().unwrap() {
+
-            let conection_str: String = servers["connection_str"].as_str().unwrap().to_string();
+        for servers in key_toml["server"]
-            let key_name: String = servers["key"]["name"].as_str().unwrap().to_string();
+            .as_array()
-            let key: String = servers["key"]["value"].as_str().unwrap().to_string();
+            .ok_or(generate_toml_parser_error_in_field("server"))?
+        {
+            let conection_str: String = servers["connection_str"]
+                .as_str()
+                .ok_or(generate_toml_parser_error_in_field("connection_str"))?
+                .to_string();
+            let key_name: String = servers["key"]["name"]
+                .as_str()
+                .ok_or(generate_toml_parser_error_in_field("key name"))?
+                .to_string();
+            let key: String = servers["key"]["value"]
+                .as_str()
+                .ok_or(generate_toml_parser_error_in_field("key value"))?
+                .to_string();
             ret.push(Self {
                 conection_str,
                 key_name,
                 key,
             });
         }
-        ret
+        Ok(ret)
     }
 }
 
 impl ServerZonesConnection {
-    pub fn get_config(file_name: &String) -> Self {
+    pub fn get_config(file_name: &String) -> Result<Self, Box<dyn Error>> {
-        let key_toml = read_to_string(file_name).unwrap().parse::<Table>().unwrap();
+        let root_domain: String =
-        let root_domain: String = key_toml["zone"]["root_domain"]
+            read_to_string(file_name)?.parse::<Table>()?["zone"]["root_domain"]
                 .as_str()
-            .unwrap()
+                .ok_or(generate_toml_parser_error_in_field("zone root_domain"))?
                 .to_string();
 
-        Self {
+        Ok(Self {
             root_domain,
-            servers_data: ZoneConnectionData::get_config(file_name),
+            servers_data: ZoneConnectionData::get_config(file_name)?,
+        })
     }
 }
+
+fn generate_toml_parser_error_in_field(field: &str) -> io::Error {
+    io::Error::new(
+        io::ErrorKind::InvalidData,
+        format!("Invalid format for config.toml in {} field", field),
+    )
 }

src/main.rs

@@ -5,7 +5,8 @@ use dns_config;
 
 #[tokio::main]
 async fn main() {
-    let zone_data = dns_config::ServerZonesConnection::get_config(&"config.toml".to_string());
+    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