From cebad8abe45d6d4b298e517ffa6082564af438d7 Mon Sep 17 00:00:00 2001 From: Neshura Date: Wed, 27 Dec 2023 20:56:35 +0100 Subject: [PATCH] Log change events done to zones.d --- src/main.rs | 230 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 224 insertions(+), 6 deletions(-) diff --git a/src/main.rs b/src/main.rs index 4028a78..b5753e5 100644 --- a/src/main.rs +++ b/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 { + 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::() + 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() {