84 lines
2.5 KiB
Rust
84 lines
2.5 KiB
Rust
pub use crate::message::{Level, Message};
|
|
pub use crate::monitor::*;
|
|
|
|
use serde::Deserialize;
|
|
|
|
// use std::net::*;
|
|
use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
|
|
use trust_dns_resolver::Resolver;
|
|
|
|
// #[derive(Debug)]
|
|
pub struct DNS {
|
|
config: DNSConfig,
|
|
resolver: Resolver,
|
|
}
|
|
#[derive(Debug, Deserialize)]
|
|
struct DNSConfig {
|
|
#[serde(default)]
|
|
records: Vec<DNSConfigRecord>,
|
|
#[serde(default)]
|
|
period: Option<f64>,
|
|
}
|
|
#[derive(Debug, Deserialize)]
|
|
struct DNSConfigRecord {
|
|
domain_name: String,
|
|
#[serde(default)]
|
|
resolver: Option<String>,
|
|
#[serde(default)]
|
|
entries: Vec<DNSConfigEntry>,
|
|
}
|
|
#[derive(Debug, Deserialize)]
|
|
struct DNSConfigEntry {
|
|
record_type: String,
|
|
#[serde(default)]
|
|
record_value: Option<String>,
|
|
#[serde(default)]
|
|
resolver: Option<String>,
|
|
}
|
|
|
|
impl Monitor for DNS {
|
|
fn new(config: serde_yaml::Value) -> Result<Self, Box<dyn std::error::Error>> {
|
|
let config: DNSConfig = serde_yaml::from_value(config)?;
|
|
|
|
let mut resolver =
|
|
Resolver::new(ResolverConfig::default(), ResolverOpts::default()).unwrap();
|
|
|
|
Ok(DNS {
|
|
config: config,
|
|
resolver: resolver,
|
|
})
|
|
}
|
|
fn run(&mut self, sender: &mpsc::Sender<Message>) {
|
|
for record in &self.config.records {
|
|
//let mut response = match &record.record_type {
|
|
// "ipv4" => self.resolver.ipv4_lookup(&record.domain_name),
|
|
// // "ipv6" => self.resolver.ipv6_lookup(&record.domain_name),
|
|
// _ => self.resolver.ipv4_lookup(&record.domain_name),
|
|
//};
|
|
|
|
// let mut response = self.resolver.lookup_ip(&record.domain_name);
|
|
// if let Err(e) = response {
|
|
// sender
|
|
// .send(Message {
|
|
// emitter: "dns".to_owned(),
|
|
// msg_type: "dns.resolve".to_owned(),
|
|
// level: Level::Issue,
|
|
// text: format!("Cannot resolve hostname {}", &record.domain_name),
|
|
// })
|
|
// .unwrap();
|
|
// continue;
|
|
// }
|
|
// let Ok(response) = response;
|
|
// while let Some(res) = response.next() {
|
|
// println!("res={:?}", res);
|
|
// }
|
|
}
|
|
|
|
let delay_ms = match self.config.period {
|
|
Some(sec) => (sec * 1000.0) as u64,
|
|
None => 2000,
|
|
};
|
|
std::thread::sleep(std::time::Duration::from_millis(delay_ms));
|
|
}
|
|
}
|