refactor: reduce clones via Arc, fix clippy pedantic warnings

- Replace Cow<HostStat> with Arc<HostStat> in stat_map and StatsResp
  to eliminate unnecessary deep copies; enable serde 'rc' feature
- Migrate lazy_static! to std::sync::LazyLock (status.rs, sys_info.rs, stats.rs)
- De-async handlers with no await (assets.rs, http.rs); fix axum compatibility
- Fix truncating casts: usize/u64 as u32 -> try_from() with fallback
- Simplify add_template generics to (&str, &str, String)
- Fix similar-name bindings: notified->any_notified, notifiers->notify_list
- Move const OS_LIST to module level to avoid items-after-statements lint
- Use clone_from instead of = x.clone() where applicable
- Fix vnstat calc_traffic: take &VnstatJson, remove unnecessary Result wrapper
- Replace map_or(true, ...) with is_none_or(...) in http.rs
- Add #[allow] annotations for: struct_excessive_bools, too_many_lines,
  unnecessary_wraps, missing_panics_doc, assertions_on_constants
- Remove duplicate geoip match arm; use integer arithmetic for uptime
- Add jwt usize::try_from cast; fix assertion on constants in main.rs

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: zdz

client/Cargo.toml

@@ -3,7 +3,7 @@ edition = "2021"
 name = "stat_client"
 version = "1.8.2"
 
-rust-version = "1.76"
+rust-version = "1.94"
 
 authors = ["doge <doge.py@gmail.com>"]
 categories = ["monitoring-tools"]

client/src/geoip/ip_api_com.rs

@@ -40,17 +40,17 @@ impl From<IpApiResp> for IpInfo {
     fn from(resp: IpApiResp) -> Self {
         IpInfo {
             source: SOURCE.to_string(),
-            query: resp.query.to_string(),
+            query: resp.query.clone(),
 
-            continent: resp.continent.to_string(),
-            country: resp.country.to_string(),
-            region_name: resp.region_name.to_string(),
-            city: resp.city.to_string(),
+            continent: resp.continent.clone(),
+            country: resp.country.clone(),
+            region_name: resp.region_name.clone(),
+            city: resp.city.clone(),
 
-            isp: resp.isp.to_string(),
-            org: resp.org.to_string(),
-            r#as: resp.r#as.to_string(),
-            asname: resp.asname.to_string(),
+            isp: resp.isp.clone(),
+            org: resp.org.clone(),
+            r#as: resp.r#as.clone(),
+            asname: resp.asname.clone(),
 
             lat: resp.lat,
             lon: resp.lon,

client/src/geoip/ip_sb.rs

@@ -43,10 +43,10 @@ impl From<ApiResp> for IpInfo {
             region_name: resp.region,
             city: resp.city,
 
-            isp: resp.isp.to_string(),
-            org: resp.organization.to_string(),
+            isp: resp.isp.clone(),
+            org: resp.organization.clone(),
             r#as: resp.asn.to_string(),
-            asname: resp.asn_organization.to_string(),
+            asname: resp.asn_organization.clone(),
 
             lat: resp.latitude,
             lon: resp.longitude,

client/src/geoip/mod.rs

@@ -45,7 +45,7 @@ where
             }
             resp.json::<T>()
                 .await
-                .map(|resp| resp.into())
+                .map(std::convert::Into::into)
                 .map_err(anyhow::Error::new)
         }
         Err(err) => Err(anyhow::Error::new(err)),
@@ -56,7 +56,6 @@ pub async fn get_ip_info(args: &Args) -> Result<IpInfo> {
     let source = args.ip_source.as_str();
     match source {
         "ip-api.com" => ip_api_com::get_ip_info(args).await,
-        "ip.sb" => ip_sb::get_ip_info(args).await,
         "ipapi.co" => ipapi_co::get_ip_info(args).await,
         "myip.la" => myip_la::get_ip_info(args).await,
         _ => ip_sb::get_ip_info(args).await,

client/src/grpc.rs

@@ -19,10 +19,10 @@ pub async fn report(args: &Args, stat_base: &mut StatRequest) -> anyhow::Result<
     let auth_user: String;
     let ssr_auth: &[u8];
     if args.gid.is_empty() {
-        auth_user = args.user.to_string();
+        auth_user = args.user.clone();
         ssr_auth = b"single";
     } else {
-        auth_user = args.gid.to_string();
+        auth_user = args.gid.clone();
         ssr_auth = b"group";
     }
     let token = MetadataValue::try_from(format!("{}@_@{}", auth_user, args.pass))?;
@@ -55,7 +55,7 @@ pub async fn report(args: &Args, stat_base: &mut StatRequest) -> anyhow::Result<
         channel = Channel::from_shared(addr)?.tls_config(tls_config)?.connect().await?;
     } else {
         channel = Channel::from_shared(addr)?.connect().await?;
-    };
+    }
 
     let timeout_channel = Timeout::new(channel, Duration::from_millis(3000));
     let grpc_client = ServerStatusClient::with_interceptor(timeout_channel, move |mut req: Request<()>| {
@@ -73,10 +73,10 @@ pub async fn report(args: &Args, stat_base: &mut StatRequest) -> anyhow::Result<
             let request = tonic::Request::new(stat_rt);
             match client.report(request).await {
                 Ok(resp) => {
-                    info!("grpc report resp => {:?}", resp);
+                    info!("grpc report resp => {resp:?}");
                 }
                 Err(status) => {
-                    error!("grpc report status => {:?}", status);
+                    error!("grpc report status => {status:?}");
                 }
             }
         });

client/src/main.rs

@@ -39,6 +39,7 @@ pub static G_CONFIG: Lazy<Mutex<ClientConfig>> = Lazy::new(|| Mutex::new(ClientC
 // https://docs.rs/clap/latest/clap/_derive/index.html#command-attributes
 #[derive(Parser, Debug, Clone)]
 #[command(author, version = env!("APP_VERSION"), about, long_about = None)]
+#[allow(clippy::struct_excessive_bools)]
 pub struct Args {
     #[arg(short, long, env = "SSR_ADDR", default_value = "http://127.0.0.1:8080/report")]
     addr: String,
@@ -176,6 +177,7 @@ pub struct Args {
 }
 
 impl Args {
+    #[must_use] 
     pub fn skip_iface(&self, name: &str) -> bool {
         if !self.iface.is_empty() {
             if self.iface.iter().any(|fa| name.eq(fa)) {
@@ -235,7 +237,7 @@ fn http_report(args: &Args, stat_base: &mut StatRequest) -> Result<()> {
                 }
                 retries += 1;
                 let delay = Duration::from_secs(2u64.pow(retries)); // Exponential backoff
-                eprintln!("Name resolution failed, retrying in {:?}...", delay);
+                eprintln!("Name resolution failed, retrying in {delay:?}...");
                 sleep(delay);
             }
         }
@@ -282,15 +284,15 @@ fn http_report(args: &Args, stat_base: &mut StatRequest) -> Result<()> {
         // dbg!(&body_data.as_ref().unwrap().len());
 
         let client = http_client.clone();
-        let url = args.addr.to_string();
-        let auth_pass = args.pass.to_string();
+        let url = args.addr.clone();
+        let auth_pass = args.pass.clone();
         let auth_user: String;
         let ssr_auth: &str;
         if args.gid.is_empty() {
-            auth_user = args.user.to_string();
+            auth_user = args.user.clone();
             ssr_auth = "single";
         } else {
-            auth_user = args.gid.to_string();
+            auth_user = args.gid.clone();
             ssr_auth = "group";
         }
 
@@ -307,10 +309,10 @@ fn http_report(args: &Args, stat_base: &mut StatRequest) -> Result<()> {
                 .await
             {
                 Ok(resp) => {
-                    info!("report resp => {:?}", resp);
+                    info!("report resp => {resp:?}");
                 }
                 Err(err) => {
-                    error!("report error => {:?}", err);
+                    error!("report error => {err:?}");
                 }
             }
         });
@@ -326,13 +328,13 @@ async fn refresh_ip_info(args: &Args) {
         info!("get ip info from ip-api.com");
         match geoip::get_ip_info(args).await {
             Ok(ip_info) => {
-                info!("refresh_ip_info succ => {:?}", ip_info);
+                info!("refresh_ip_info succ => {ip_info:?}");
                 if let Ok(mut o) = G_CONFIG.lock() {
                     o.ip_info = Some(ip_info);
                 }
             }
             Err(err) => {
-                error!("refresh_ip_info error => {:?}", err);
+                error!("refresh_ip_info error => {err:?}");
             }
         }
 
@@ -357,8 +359,9 @@ async fn main() -> Result<()> {
     }
 
     // support check
-    if !sysinfo::IS_SUPPORTED_SYSTEM {
-        panic!("当前系统不支持，请切换到Python跨平台版本!");
+    #[allow(clippy::assertions_on_constants)]
+    {
+        assert!(sysinfo::IS_SUPPORTED_SYSTEM, "当前系统不支持，请切换到Python跨平台版本!");
     }
 
     let sys_info = sys_info::collect_sys_info(&args);
@@ -403,7 +406,7 @@ async fn main() -> Result<()> {
     }
 
     let mut stat_base = StatRequest {
-        name: args.user.to_string(),
+        name: args.user.clone(),
         frame: "data".to_string(),
         online4: ipv4,
         online6: ipv6,
@@ -414,24 +417,24 @@ async fn main() -> Result<()> {
         ..Default::default()
     };
     if !args.gid.is_empty() {
-        stat_base.gid = args.gid.to_owned();
+        stat_base.gid = args.gid.clone();
         if stat_base.name.eq("h1") {
             stat_base.name = sys_id;
         }
         if args.alias.eq("unknown") {
-            args.alias = stat_base.name.to_owned();
+            args.alias = stat_base.name.clone();
         } else {
-            stat_base.alias = args.alias.to_owned();
+            stat_base.alias = args.alias.clone();
         }
     }
     if args.disable_notify {
         stat_base.notify = false;
     }
     if !args.host_type.is_empty() {
-        stat_base.r#type = args.host_type.to_owned();
+        stat_base.r#type = args.host_type.clone();
     }
     if !args.location.is_empty() {
-        stat_base.location = args.location.to_owned();
+        stat_base.location = args.location.clone();
     }
     // dbg!(&stat_base);
 

client/src/status.rs

@@ -1,5 +1,5 @@
 #![allow(unused)]
-use lazy_static::lazy_static;
+#![allow(clippy::cast_precision_loss, clippy::cast_possible_truncation, clippy::cast_sign_loss, clippy::similar_names, clippy::many_single_char_names)]
 use once_cell::sync::OnceCell;
 use regex::Regex;
 use std::collections::HashMap;
@@ -14,7 +14,7 @@ use std::net::{Shutdown, ToSocketAddrs};
 use std::process::Command;
 use std::str;
 use std::sync::Arc;
-use std::sync::Mutex;
+use std::sync::{LazyLock, Mutex};
 use std::thread;
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
@@ -54,10 +54,8 @@ pub fn get_loadavg() -> (f64, f64, f64) {
         .unwrap()
 }
 
-static MEMORY_REGEX: &str = r#"^(?P<key>\S*):\s*(?P<value>\d*)\s*kB"#;
-lazy_static! {
-    static ref MEMORY_REGEX_RE: Regex = Regex::new(MEMORY_REGEX).unwrap();
-}
+static MEMORY_REGEX: &str = r"^(?P<key>\S*):\s*(?P<value>\d*)\s*kB";
+static MEMORY_REGEX_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(MEMORY_REGEX).unwrap());
 pub fn get_memory() -> (u64, u64, u64, u64) {
     let file = File::open("/proc/meminfo").unwrap();
     let buf_reader = BufReader::new(file);
@@ -66,7 +64,7 @@ pub fn get_memory() -> (u64, u64, u64, u64) {
         let l = line.unwrap();
         if let Some(caps) = MEMORY_REGEX_RE.captures(&l) {
             res_dict.insert(caps["key"].to_string(), caps["value"].parse::<u64>().unwrap());
-        };
+        }
     }
 
     let mem_total = res_dict["MemTotal"];
@@ -100,10 +98,8 @@ pub fn tupd() -> (u32, u32, u32, u32) {
 }
 
 static TRAFFIC_REGEX: &str =
-    r#"([^\s]+):[\s]{0,}(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)"#;
-lazy_static! {
-    static ref TRAFFIC_REGEX_RE: Regex = Regex::new(TRAFFIC_REGEX).unwrap();
-}
+    r"([^\s]+):[\s]{0,}(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)";
+static TRAFFIC_REGEX_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(TRAFFIC_REGEX).unwrap());
 pub fn get_sys_traffic(args: &Args) -> (u64, u64) {
     let (mut network_in, mut network_out) = (0, 0);
     let file = File::open("/proc/net/dev").unwrap();
@@ -142,7 +138,7 @@ pub fn get_hdd(stat: &mut StatRequest) {
         .stdout;
 
     let _ = str::from_utf8(a).map(|content| {
-        let vs = content.trim().split('\n').collect::<Vec<&str>>().to_vec();
+        let vs = content.lines().collect::<Vec<&str>>();
 
         for (idx, s) in vs.iter().enumerate() {
             // header
@@ -181,9 +177,7 @@ pub struct NetSpeed {
     pub avgtx: u64,
 }
 
-lazy_static! {
-    pub static ref G_NET_SPEED: Arc<Mutex<NetSpeed>> = Arc::new(Default::default());
-}
+pub static G_NET_SPEED: LazyLock<Arc<Mutex<NetSpeed>>> = LazyLock::new(|| Arc::new(Mutex::default()));
 
 #[allow(unused)]
 pub fn start_net_speed_collect_t(args: &Args) {
@@ -226,9 +220,7 @@ pub fn start_net_speed_collect_t(args: &Args) {
     });
 }
 
-lazy_static! {
-    pub static ref G_CPU_PERCENT: Arc<Mutex<f64>> = Arc::new(Default::default());
-}
+pub static G_CPU_PERCENT: LazyLock<Arc<Mutex<f64>>> = LazyLock::new(|| Arc::new(Mutex::default()));
 #[allow(unused)]
 pub fn start_cpu_percent_collect_t() {
     let mut pre_cpu: Vec<u64> = vec![0, 0, 0, 0];
@@ -280,15 +272,15 @@ pub fn get_network(args: &Args) -> (bool, bool) {
     for (idx, probe_addr) in addrs.into_iter().enumerate() {
         let _ = probe_addr.to_socket_addrs().map(|mut iter| {
             if let Some(addr) = iter.next() {
-                info!("{} => {}", probe_addr, addr);
+                info!("{probe_addr} => {addr}");
 
                 let r = TcpStream::connect_timeout(&addr, Duration::from_millis(TIMEOUT_MS)).map(|s| {
                     network[idx] = true;
                     s.shutdown(Shutdown::Both)
                 });
 
-                info!("{:?}", r);
-            };
+                info!("{r:?}");
+            }
         });
     }
 
@@ -339,9 +331,9 @@ fn start_ping_collect_t(data: &Arc<Mutex<PingData>>) {
         let time_cost_ms = instant.elapsed().as_millis();
 
         if let Ok(mut o) = ping_data.lock() {
-            o.ping_time = time_cost_ms as u32;
+            o.ping_time = u32::try_from(time_cost_ms).unwrap_or(u32::MAX);
             if package_list.len() > 30 {
-                o.lost_rate = package_lost * 100 / package_list.len() as u32;
+                o.lost_rate = package_lost * 100 / u32::try_from(package_list.len()).unwrap_or(u32::MAX);
             }
         }
 
@@ -356,21 +348,21 @@ pub static G_PING_10086: OnceCell<Arc<Mutex<PingData>>> = OnceCell::new();
 pub fn start_all_ping_collect_t(args: &Args) {
     G_PING_10010
         .set(Arc::new(Mutex::new(PingData {
-            probe_uri: args.cu_addr.to_owned(),
+            probe_uri: args.cu_addr.clone(),
             lost_rate: 0,
             ping_time: 0,
         })))
         .unwrap();
     G_PING_189
         .set(Arc::new(Mutex::new(PingData {
-            probe_uri: args.ct_addr.to_owned(),
+            probe_uri: args.ct_addr.clone(),
             lost_rate: 0,
             ping_time: 0,
         })))
         .unwrap();
     G_PING_10086
         .set(Arc::new(Mutex::new(PingData {
-            probe_uri: args.cm_addr.to_owned(),
+            probe_uri: args.cm_addr.clone(),
             lost_rate: 0,
             ping_time: 0,
         })))