src/main.rs

@@ -2,6 +2,7 @@
 use reqwest::blocking::get;
 use std::{thread::{sleep}};
 use std::error::Error;
+use std::fmt::format;
 use std::net::{Ipv4Addr, Ipv6Addr};
 use std::str::FromStr;
 use chrono::{Utc, Duration};
@@ -10,6 +11,7 @@ use log::{info, warn, error, LevelFilter};
 use reqwest::StatusCode;
 use systemd_journal_logger::{connected_to_journal, JournalLog};
 use crate::cloudflare::{CloudflareZone, DnsRecordType};
+use crate::config::{InterfaceConfig, ZoneConfig, ZoneEntry};
 
 mod config;
 mod cloudflare;
@@ -145,13 +147,100 @@ impl Addresses {
     }
 }
 
+fn compare_zones(old_zone: &ZoneConfig, new_zone: &ZoneConfig) -> Vec<String> {
+    let mut info_pieces = vec![];
+    if old_zone.id != new_zone.id || old_zone.email != new_zone.email {
+        let msg = "changed id or email".to_owned();
+        info_pieces.push(msg);
+    }
+
+    if old_zone.entries != new_zone.entries {
+        let mut added: Vec<&ZoneEntry> = vec![];
+        let mut deleted: Vec<&ZoneEntry>;
+        let mut modified: Vec<&ZoneEntry> = vec![];
+
+        new_zone.entries.iter().for_each(|entry| {
+            let matches: Vec<&ZoneEntry> = old_zone.entries.iter().filter(|old_entry| {
+                if old_entry.name == entry.name {
+                    if old_entry != &entry {
+                        modified.push(entry);
+                    }
+                    true
+                }
+                else {
+                    false
+                }
+            }).collect();
+
+            if matches.len() == 0 {
+                added.push(entry);
+            }
+        });
+
+        deleted = old_zone.entries.iter().filter(|old_entry| {
+            !new_zone.entries.contains(old_entry) &&
+                new_zone.entries.iter().find(|changed_entry| { changed_entry.name == old_entry.name }).is_none()
+        }).collect();
+
+        if deleted.len() != 0 {
+            let mut deleted_entries_vec = vec![];
+
+            for entry in deleted {
+                deleted_entries_vec.push(entry.name.clone());
+            }
+
+            let deleted_entries = match deleted_entries_vec.len() {
+                1 => deleted_entries_vec[0].clone(),
+                2 => deleted_entries_vec.join(" & "),
+                _ => deleted_entries_vec.join(", "),
+            };
+            let msg = format!("deleted {deleted_entries}");
+            info_pieces.push(msg);
+        }
+
+        if added.len() != 0 {
+            let mut added_entries_vec = vec![];
+
+            for entry in added {
+                added_entries_vec.push(entry.name.clone());
+            }
+
+            let added_entries = match added_entries_vec.len() {
+                1 => added_entries_vec[0].clone(),
+                2 => added_entries_vec.join(" & "),
+                _ => added_entries_vec.join(", "),
+            };
+            let msg = format!("added {added_entries}");
+            info_pieces.push(msg);
+        }
+
+        if modified.len() != 0 {
+            let mut modified_entries_vec = vec![];
+
+            for entry in modified {
+                modified_entries_vec.push(entry.name.clone());
+            }
+
+            let modified_entries = match modified_entries_vec.len() {
+                1 => modified_entries_vec[0].clone(),
+                2 => modified_entries_vec.join(" & "),
+                _ => modified_entries_vec.join(", "),
+            };
+            let msg = format!("modified {modified_entries}");
+            info_pieces.push(msg);
+        }
+    }
+
+    info_pieces
+}
+
 fn main() {
     dotenv().ok();
     JournalLog::new().expect("Systemd-Logger crate error").install().expect("Systemd-Logger crate error");
     log::set_max_level(LevelFilter::Info);
 
-    let mut ifaces = config::InterfaceConfig::load().unwrap();
-    let mut zone_cfgs= config::ZoneConfig::load().unwrap();
+    let mut ifaces = InterfaceConfig::load().unwrap();
+    let mut zone_cfgs = ZoneConfig::load().unwrap();
 
     let mut now = Utc::now() - Duration::seconds(59);
     let mut start = now;
@@ -166,7 +255,7 @@ fn main() {
         if now >= start + Duration::seconds(10) { // DEBUG was 60
             start = now;
 
-            match config::InterfaceConfig::load() {
+            match InterfaceConfig::load() {
                 Ok(new_cfg) => {
                     if ifaces != new_cfg {
                         if ifaces.host_address != new_cfg.host_address {
@@ -179,7 +268,7 @@ fn main() {
 
                         if ifaces.interfaces != new_cfg.interfaces {
                             let mut new: Vec<(&String, &Ipv6Addr)> = vec![];
-                            let mut deleted: Vec<(&String, &Ipv6Addr)>;
+                            let deleted: Vec<(&String, &Ipv6Addr)>;
                             let mut modified: Vec<(&String, &Ipv6Addr)> = vec![];
 
                             new_cfg.interfaces.iter().for_each(|(interface, address)| {
@@ -256,8 +345,137 @@ fn main() {
                 }
             }
 
-            match config::ZoneConfig::load() {
-                Ok(new) => zone_cfgs = new,
+            match ZoneConfig::load() {
+                Ok(new_cfgs) => {
+                    if zone_cfgs != new_cfgs {
+                        if zone_cfgs.len() != new_cfgs.len() {
+                            let new_zones: Vec<&ZoneConfig> = new_cfgs.iter().filter(|zone_cfg| {
+                                !zone_cfgs.contains(zone_cfg)
+                            }).collect();
+
+                            let deleted_zones: Vec<&ZoneConfig> = zone_cfgs.iter().filter(|zone_cfg| {
+                                !new_cfgs.contains(zone_cfg)
+                            }).collect();
+
+                            for new_zone in new_zones {
+                                let name = new_zone.name.as_str();
+                                let entry_count = new_zone.entries.len();
+                                let info_msg = format!("Added Zone '{name}' with {entry_count} entries");
+                                match connected_to_journal() {
+                                    true => info!("[INFO] {info_msg}"),
+                                    false => println!("[INFO] {info_msg}"),
+                                }
+                            }
+
+                            for deleted_zone in deleted_zones {
+                                let name = deleted_zone.name.as_str();
+                                let entry_count = deleted_zone.entries.len();
+                                let info_msg = format!("Deleted Zone '{name}' with {entry_count} entries");
+                                match connected_to_journal() {
+                                    true => info!("[INFO] {info_msg}"),
+                                    false => println!("[INFO] {info_msg}"),
+                                }
+                            }
+                        }
+                        else {
+                            let changed_zones: Vec<&ZoneConfig> = new_cfgs.iter().filter(|new_cfg| {
+                                zone_cfgs.iter().find(|old_cfg| {
+                                    old_cfg.name == new_cfg.name && old_cfg != new_cfg
+                                }).is_some()
+                            }).collect();
+
+                            let deleted_zones: Vec<&ZoneConfig> = zone_cfgs.iter().filter(|old_cfg| {
+                                new_cfgs.iter().find(|new_cfg| {
+                                    old_cfg.name == new_cfg.name
+                                }).is_none()
+                            }).collect();
+
+                            let added_zones: Vec<&ZoneConfig> = new_cfgs.iter().filter(|new_cfg| {
+                                zone_cfgs.iter().find(|old_cfg| {
+                                    old_cfg.name == new_cfg.name
+                                }).is_none()
+                            }).collect();
+
+                            if deleted_zones.len() == 1 && added_zones.len() == 1 {
+                                let new_zone = added_zones[0];
+                                let old_zone = deleted_zones[0];
+
+                                let mut info_pieces = vec![];
+
+                                {
+                                    let msg = format!("name from '{}' to '{}'", old_zone.name, new_zone.name);
+                                    info_pieces.push(msg);
+                                }
+
+                                let info_pieces = [info_pieces, compare_zones(old_zone, new_zone)].concat();
+
+                                println!("{}", info_pieces.join(", "));
+                            }
+                            else {
+                                if deleted_zones.len() != 0 {
+                                    let mut info_pieces = vec![];
+                                    for deleted_zone in deleted_zones {
+                                        info_pieces.push(deleted_zone.name.clone());
+                                    }
+                                    let deleted_info = match info_pieces.len() {
+                                        1 => info_pieces[0].clone(),
+                                        2 => info_pieces.join(" & "),
+                                        _ => info_pieces.join(", "),
+                                    };
+                                    let info_msg = format!("Deleted {deleted_info}");
+                                    match connected_to_journal() {
+                                        true => info!("[INFO] {info_msg}"),
+                                        false => println!("[INFO] {info_msg}"),
+                                    }
+                                }
+
+                                if added_zones.len() != 0 {
+                                    let mut info_pieces = vec![];
+                                    for added_zone in added_zones {
+                                        info_pieces.push(added_zone.name.clone());
+                                    }
+                                    let added_info = match info_pieces.len() {
+                                        1 => info_pieces[0].clone(),
+                                        2 => info_pieces.join(" & "),
+                                        _ => info_pieces.join(", "),
+                                    };
+                                    let info_msg = format!("Added {added_info}");
+                                    match connected_to_journal() {
+                                        true => info!("[INFO] {info_msg}"),
+                                        false => println!("[INFO] {info_msg}"),
+                                    }
+                                }
+                            }
+
+                            for changed_zone in changed_zones {
+                                // try find element where one of these is unchanged
+                                let old_zone = zone_cfgs.iter().find(|zone_cfg| {
+                                        zone_cfg.name == changed_zone.name
+                                }).expect("This element should exist because it was added to the changed_zones vector");
+
+                                let info_pieces = compare_zones(old_zone, changed_zone);
+
+                                let changed_info = match info_pieces.len() {
+                                    1 => info_pieces[0].clone(),
+                                    2 => info_pieces.join(" & "),
+                                    _ => info_pieces.join(", "),
+                                };
+                                let info_msg_raw = format!("{changed_info} for {}", changed_zone.name);
+                                let mut info_msg_chars = info_msg_raw.chars();
+                                let info_msg = match info_msg_chars.next() {
+                                    None => String::new(),
+                                    Some(first) => first.to_uppercase().collect::<String>() + info_msg_chars.as_str(),
+                                };
+                                match connected_to_journal() {
+                                    true => info!("[INFO] {info_msg}"),
+                                    false => println!("[INFO] {info_msg}"),
+                                }
+                            }
+                        }
+
+                        zone_cfgs = new_cfgs
+                    }
+                }
                 Err(e) => {
                     let err_msg = format!("Unable to load from zones.d with error: {}", e);
                     match connected_to_journal() {