webui: add fail query count, add server security status, add error message when audit is disabled.

Author: pymumu

plugin/smartdns-ui/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "smartdns-ui"
-version = "0.1.0"
+version = "1.0.0"
 edition = "2021"
 
 [lib]
@@ -11,13 +11,13 @@ ctor = "0.4.3"
 bytes = "1.10.1"
 rusqlite = { version = "0.37.0", features = ["bundled"] }
 hyper = { version = "1.7.0", features = ["full"] }
-hyper-util = { version = "0.1.16", features = ["full"] }
+hyper-util = { version = "0.1.17", features = ["full"] }
 hyper-tungstenite = "0.18.0"
 tokio = { version = "1.47.1", features = ["full"] }
-serde = { version = "1.0.219", features = ["derive"] }
+serde = { version = "1.0.225", features = ["derive"] }
 tokio-rustls = { version = "0.26.2", optional = true}
 rustls-pemfile = { version = "2.2.0", optional = true}
-serde_json = "1.0.143"
+serde_json = "1.0.145"
 http-body-util = "0.1.3"
 getopts = "0.2.24"
 url = "2.5.7"
@@ -27,7 +27,7 @@ futures = "0.3.31"
 socket2 = "0.6.0"
 cfg-if = "1.0.3"
 urlencoding = "2.1.3"
-chrono = "0.4.41"
+chrono = "0.4.42"
 nix = "0.30.1"
 tokio-fd = "0.3.0"
 pbkdf2 = { version = "0.12.2", features = ["simple"] }
@@ -42,7 +42,7 @@ default = ["https"]
 reqwest = {version = "0.12.23", features = ["blocking"]}
 tungstenite = "0.23.0"
 tokio-tungstenite = "0.23.1"
-tempfile = "3.21.0"
+tempfile = "3.22.0"
 
 [build-dependencies]
 bindgen = "0.69.5"

plugin/smartdns-ui/src/data_server.rs

@@ -61,6 +61,7 @@ pub struct OverviewData {
 pub struct MetricsData {
     pub total_query_count: u64,
     pub block_query_count: u64,
+    pub fail_query_count: u64,
     pub avg_query_time: f64,
     pub cache_hit_rate: f64,
     pub cache_number: u64,
@@ -179,7 +180,7 @@ impl DataServerControl {
                 Plugin::smartdns_exit(1);
             }
 
-            dns_log!(LogLevel::INFO, "data server exit.");
+            dns_log!(LogLevel::DEBUG, "data server exit.");
         });
 
         *self.is_run.lock().unwrap() = true;
@@ -474,6 +475,7 @@ impl DataServer {
         let metrics = MetricsData {
             total_query_count: self.stat.get_total_request(),
             block_query_count: self.stat.get_total_blocked_request(),
+            fail_query_count: self.stat.get_total_failed_request(),
             avg_query_time: smartdns::Stats::get_avg_process_time(),
             cache_hit_rate: smartdns::Stats::get_cache_hit_rate(),
             cache_number: smartdns::Plugin::dns_cache_total_num() as u64,
@@ -522,6 +524,10 @@ impl DataServer {
             self.stat.add_total_blocked_request(1);
         }
 
+        if data.reply_code != 0 {
+            self.stat.add_total_failed_request(1);
+        }   
+
         self.db.insert_domain(&list)
     }
 
@@ -532,6 +538,7 @@ impl DataServer {
         let mut domain_data_list = Vec::new();
         let mut client_data_list = Vec::new();
         let mut blocked_num = 0;
+        let mut failed_num = 0;
         let timestamp_now = get_utc_time_ms();
 
         for req in req_list {
@@ -547,6 +554,10 @@ impl DataServer {
                 blocked_num += 1;
             }
 
+            if req.get_rcode() != 0 {
+                failed_num += 1;
+            }
+
             let domain_data = DomainData {
                 id: 0,
                 domain: req.get_domain(),
@@ -589,6 +600,7 @@ impl DataServer {
 
         this.stat.add_total_request(domain_data_list.len() as u64);
         this.stat.add_total_blocked_request(blocked_num as u64);
+        this.stat.add_total_failed_request(failed_num as u64);
 
         dns_log!(
             LogLevel::DEBUG,
@@ -695,7 +707,7 @@ impl DataServer {
         let mut check_timer = tokio::time::interval(Duration::from_secs(60));
         let is_check_timer_running = Arc::new(AtomicBool::new(false));
 
-        dns_log!(LogLevel::INFO, "data server start.");
+        dns_log!(LogLevel::DEBUG, "data server start.");
 
         loop {
             tokio::select! {

plugin/smartdns-ui/src/data_stats.rs

@@ -39,6 +39,7 @@ use tokio::time::{interval_at, Instant};
 struct DataStatsItem {
     total_request: AtomicU64,
     total_blocked_request: AtomicU64,
+    total_failed_request: AtomicU64,
     qps: AtomicU32,
     qps_count: AtomicU32,
     request_dropped: AtomicU64,
@@ -48,6 +49,7 @@ struct DataStatsItem {
 struct DataStatsItem {
     total_request: Arc<Mutex<u64>>,
     total_blocked_request: Arc<Mutex<u64>>,
+    total_failed_request: Arc<Mutex<u64>>,
     qps: AtomicU32,
     qps_count: AtomicU32,
     request_dropped: Arc<Mutex<u64>>,
@@ -59,6 +61,7 @@ impl DataStatsItem {
         let ret = DataStatsItem {
             total_request: 0.into(),
             total_blocked_request: 0.into(),
+            total_failed_request: 0.into(),
             qps: 0.into(),
             qps_count: 0.into(),
             request_dropped: 0.into(),
@@ -67,6 +70,7 @@ impl DataStatsItem {
         let ret = DataStatsItem {
             total_request: Arc::new(Mutex::new(0)),
             total_blocked_request: Arc::new(Mutex::new(0)),
+            total_failed_request: Arc::new(Mutex::new(0)),
             qps: 0.into(),
             qps_count: 0.into(),
             request_dropped: Arc::new(Mutex::new(0)),
@@ -154,6 +158,33 @@ impl DataStatsItem {
         }
     }
 
+    pub fn add_total_failed_request(&self, total: u64) {
+        #[cfg(target_has_atomic = "64")]
+        {
+            self.total_failed_request
+                .fetch_add(total, Ordering::Relaxed);
+        }
+
+        #[cfg(not(target_has_atomic = "64"))]
+        {
+            let mut total_failed_request = self.total_failed_request.lock().unwrap();
+            *total_failed_request += total;
+        }
+    }
+
+    pub fn get_total_failed_request(&self) -> u64 {
+        #[cfg(target_has_atomic = "64")]
+        {
+            return self.total_failed_request.load(Ordering::Relaxed);
+        }
+
+        #[cfg(not(target_has_atomic = "64"))]
+        {
+            let total = self.total_failed_request.lock().unwrap();
+            return *total;
+        }
+    }
+
     #[allow(dead_code)]
     pub fn get_current_hour_total(&self) -> u64 {
         return Stats::get_request_total();
@@ -211,6 +242,14 @@ impl DataStats {
         self.data.add_total_blocked_request(total);
     }
 
+    pub fn get_total_failed_request(&self) -> u64 {
+        return self.data.get_total_failed_request();
+    }
+
+    pub fn add_total_failed_request(&self, total: u64) {
+        self.data.add_total_failed_request(total);
+    }
+
     pub fn get_total_request(&self) -> u64 {
         return self.data.get_total_request();
     }
@@ -291,11 +330,24 @@ impl DataStats {
         if total_blocked_count == 0 {
             let mut parm = DomainListGetParam::new();
             parm.is_blocked = Some(true);
-
+            
             let count = self.db.get_domain_list_count(Some(&parm));
             total_blocked_count = count;
         }
         self.data.add_total_blocked_request(total_blocked_count);
+
+        // load total failed request
+        let mut total_failed_count = 0 as u64;
+        let status_data_total_failed_count = status_data.get("total_failed_request");
+        if status_data_total_failed_count.is_some() {
+            let count = status_data_total_failed_count.unwrap().parse::<u64>();
+            if let Ok(count) = count {
+                total_failed_count = count;
+            } else {
+                total_failed_count = 0;
+            }
+        }
+        self.data.add_total_failed_request(total_failed_count);
         Ok(())
     }
 
@@ -308,6 +360,10 @@ impl DataStats {
             "total_blocked_request",
             self.get_total_blocked_request().to_string().as_str(),
         )?;
+        self.db.set_status_data(
+            "total_failed_request",
+            self.get_total_failed_request().to_string().as_str(),
+        )?;
 
         Ok(())
     }
@@ -331,7 +387,7 @@ impl DataStats {
             .delete_domain_before_timestamp(now - self.conf.read().unwrap().max_log_age_ms as u64);
         if let Err(e) = ret {
             if e.to_string() == "Query returned no rows" {
-                return 
+                return;
             }
 
             dns_log!(

plugin/smartdns-ui/src/data_upstream_server.rs

@@ -30,6 +30,7 @@ pub struct UpstreamServerInfo {
     pub query_success_rate: f64,
     pub avg_time: f64,
     pub status: String,
+    pub security: String,
 }
 
 impl UpstreamServerInfo {
@@ -48,6 +49,8 @@ impl UpstreamServerInfo {
                     "Abnormal"
                 };
 
+                let security_status = server.get_server_security_status();
+
                 servers.push(UpstreamServerInfo {
                     host: server.get_host(),
                     ip: server.get_ip(),
@@ -59,6 +62,7 @@ impl UpstreamServerInfo {
                     query_success_rate: stats.get_success_rate(),
                     avg_time: stats.get_query_avg_time(),
                     status: status.to_string(),
+                    security: security_status.to_string(),
                 });
             });
         Ok(servers)

plugin/smartdns-ui/src/http_api_msg.rs

@@ -440,6 +440,7 @@ pub fn api_msg_gen_upstream_server_list(upstream_server_list: &Vec<UpstreamServe
                         "query_success_rate": x.query_success_rate,
                         "avg_time": x.avg_time,
                         "status": x.status,
+                        "security": x.security,
                     });
                     s
                 })
@@ -510,6 +511,11 @@ pub fn api_msg_parse_upstream_server_list(
             return Err("status not found".into());
         }
 
+        let security = item["security"].as_str();
+        if security.is_none() {
+            return Err("security not found".into());
+        }
+
         upstream_server_list.push(UpstreamServerInfo {
             host: host.unwrap().to_string(),
             ip: ip.unwrap().to_string(),
@@ -521,6 +527,7 @@ pub fn api_msg_parse_upstream_server_list(
             query_success_rate: query_success_rate.unwrap(),
             avg_time: avg_time.unwrap(),
             status: status.unwrap().to_string(),
+            security: security.unwrap().to_string(),
         });
     }
 
@@ -690,6 +697,7 @@ pub fn api_msg_gen_metrics_data(data: &MetricsData) -> String {
     let json_str = json!({
         "total_query_count": data.total_query_count,
         "block_query_count": data.block_query_count,
+        "fail_query_count": data.fail_query_count,
         "avg_query_time": data.avg_query_time,
         "cache_hit_rate": data.cache_hit_rate,
         "cache_number": data.cache_number,
@@ -714,6 +722,11 @@ pub fn api_msg_parse_metrics_data(data: &str) -> Result<MetricsData, Box<dyn Err
         return Err("block_query_count not found".into());
     }
 
+    let fail_query_count = v["fail_query_count"].as_u64();
+    if fail_query_count.is_none() {
+        return Err("fail_query_count not found".into());
+    }
+
     let avg_query_time = v["avg_query_time"].as_f64();
     if avg_query_time.is_none() {
         return Err("avg_query_time not found".into());
@@ -749,6 +762,7 @@ pub fn api_msg_parse_metrics_data(data: &str) -> Result<MetricsData, Box<dyn Err
     Ok(MetricsData {
         total_query_count: total_query_count.unwrap() as u64,
         block_query_count: block_query_count.unwrap() as u64,
+        fail_query_count: fail_query_count.unwrap() as u64,
         avg_query_time: avg_query_time.unwrap(),
         cache_hit_rate: cache_hit_rate.unwrap(),
         cache_number: cache_number.unwrap() as u64,

plugin/smartdns-ui/src/http_server.rs

@@ -123,7 +123,7 @@ impl HttpServerConfig {
             }
         }
 
-        if let Some(username) = data_server.get_server_config("smartdns-ui.username") {
+        if let Some(username) = data_server.get_server_config("smartdns-ui.user") {
             self.username = username;
         }
 
@@ -187,8 +187,6 @@ impl HttpServerControl {
     }
 
     pub fn start_http_server(&self, conf: &HttpServerConfig) -> Result<(), Box<dyn Error>> {
-        dns_log!(LogLevel::INFO, "start smartdns-ui server.");
-
         let inner_clone = Arc::clone(&self.http_server);
         let ret = inner_clone.set_conf(conf);
         if let Err(e) = ret {
@@ -207,7 +205,7 @@ impl HttpServerControl {
                 dns_log!(LogLevel::ERROR, "http server error: {}", e);
                 Plugin::smartdns_exit(1);
             }
-            dns_log!(LogLevel::INFO, "http server exit.");
+            dns_log!(LogLevel::DEBUG, "http server exit.");
         });
 
         tokio::task::block_in_place(|| {
@@ -225,8 +223,6 @@ impl HttpServerControl {
             return;
         }
 
-        dns_log!(LogLevel::INFO, "stop smartdns-ui server.");
-
         self.http_server.stop_http_server();
 
         if let Some(server_thread) = server_thread.take() {
@@ -881,7 +877,7 @@ impl HttpServer {
         let addr = listner.local_addr()?;
 
         *this.local_addr.lock().unwrap() = Some(addr);
-        dns_log!(LogLevel::INFO, "http server listen at {}", url);
+        dns_log!(LogLevel::INFO, "http server listen at {}", addr);
 
         let _ = kickoff_tx.send(0);
         loop {

plugin/smartdns-ui/src/http_server_stream.rs

@@ -18,6 +18,8 @@
 
 use futures::sink::SinkExt;
 use futures::stream::StreamExt;
+use hyper_tungstenite::tungstenite::protocol::frame::coding::CloseCode;
+use hyper_tungstenite::tungstenite::protocol::CloseFrame;
 use std::os::fd::AsRawFd;
 use std::sync::Arc;
 use std::time::Duration;
@@ -182,6 +184,18 @@ pub async fn serve_audit_log_stream(
     let data_server = http_server.get_data_server();
     let mut log_stream = data_server.get_audit_log_stream().await;
 
+    if dns_audit_log_enabled() == false {
+        let reason =
+            "Audit log is not enabled, please set `audit-enable` to `yes` in smartdns config file.";
+
+        let close_msg = CloseFrame {
+            code: CloseCode::Bad(4003),
+            reason: reason.into(),
+        };
+        websocket.send(Message::Close(Some(close_msg))).await?;
+        return Ok(());
+    }
+
     loop {
         tokio::select! {
             msg = log_stream.recv() => {