fmt

Author: zdz

.rustfmt.toml

@@ -0,0 +1 @@
+max_width = 120

client/src/grpc.rs

@@ -16,10 +16,7 @@ use crate::INTERVAL_MS;
 // TODO TLS
 
 pub async fn report(args: &Args, stat_base: &mut StatRequest) -> anyhow::Result<()> {
-    if !vec![stat_base.online4, stat_base.online6]
-        .iter()
-        .any(|&x| x)
-    {
+    if !vec![stat_base.online4, stat_base.online6].iter().any(|&x| x) {
         eprintln!("try get target network...");
         let addr = args.addr.replace("grpc://", "");
         let sock_addr = addr.to_socket_addrs()?.next().unwrap();
@@ -44,19 +41,16 @@ pub async fn report(args: &Args, stat_base: &mut StatRequest) -> anyhow::Result<
     }
     let token = MetadataValue::try_from(format!("{}@_@{}", auth_user, args.pass))?;
 
-    let channel = Channel::from_shared(args.addr.to_string())?
-        .connect()
-        .await?;
+    let channel = Channel::from_shared(args.addr.to_string())?.connect().await?;
     let timeout_channel = Timeout::new(channel, Duration::from_millis(3000));
 
-    let grpc_client =
-        ServerStatusClient::with_interceptor(timeout_channel, move |mut req: Request<()>| {
-            req.metadata_mut().insert("authorization", token.clone());
-            req.metadata_mut()
-                .insert("ssr-auth", MetadataValue::try_from(ssr_auth).unwrap());
+    let grpc_client = ServerStatusClient::with_interceptor(timeout_channel, move |mut req: Request<()>| {
+        req.metadata_mut().insert("authorization", token.clone());
+        req.metadata_mut()
+            .insert("ssr-auth", MetadataValue::try_from(ssr_auth).unwrap());
 
-            Ok(req)
-        });
+        Ok(req)
+    });
 
     loop {
         let stat_rt = sample_all(args, stat_base);

client/src/main.rs

@@ -39,30 +39,17 @@ pub static G_CONFIG: Lazy<Mutex<ClientConfig>> = Lazy::new(|| Mutex::new(ClientC
 #[derive(Parser, Debug, Clone)]
 #[clap(author, version = env!("APP_VERSION"), about, long_about = None)]
 pub struct Args {
-    #[clap(
-        short,
-        long,
-        value_parser,
-        default_value = "http://127.0.0.1:8080/report"
-    )]
+    #[clap(short, long, value_parser, default_value = "http://127.0.0.1:8080/report")]
     addr: String,
     #[clap(short, long, value_parser, default_value = "h1", help = "username")]
     user: String,
     #[clap(short, long, value_parser, default_value = "p1", help = "password")]
     pass: String,
     #[clap(short = 'n', long, value_parser, help = "enable vnstat, default:false")]
     vnstat: bool,
-    #[clap(
-        long = "disable-tupd",
-        value_parser,
-        help = "disable t/u/p/d, default:false"
-    )]
+    #[clap(long = "disable-tupd", value_parser, help = "disable t/u/p/d, default:false")]
     disable_tupd: bool,
-    #[clap(
-        long = "disable-ping",
-        value_parser,
-        help = "disable ping, default:false"
-    )]
+    #[clap(long = "disable-ping", value_parser, help = "disable ping, default:false")]
     disable_ping: bool,
     #[clap(
         long = "disable-extra",
@@ -80,44 +67,18 @@ pub struct Args {
     ip_info: bool,
     #[clap(long = "json", value_parser, help = "use json protocol, default:false")]
     json: bool,
-    #[clap(
-        short = '6',
-        value_parser,
-        long = "ipv6",
-        help = "ipv6 only, default:false"
-    )]
+    #[clap(short = '6', value_parser, long = "ipv6", help = "ipv6 only, default:false")]
     ipv6: bool,
     // for group
     #[clap(short, long, value_parser, default_value = "", help = "group id")]
     gid: String,
-    #[clap(
-        long = "alias",
-        value_parser,
-        default_value = "unknown",
-        help = "alias for host"
-    )]
+    #[clap(long = "alias", value_parser, default_value = "unknown", help = "alias for host")]
     alias: String,
-    #[clap(
-        short,
-        long,
-        value_parser,
-        default_value = "0",
-        help = "weight for rank"
-    )]
+    #[clap(short, long, value_parser, default_value = "0", help = "weight for rank")]
     weight: u64,
-    #[clap(
-        long = "disable-notify",
-        value_parser,
-        help = "disable notify, default:false"
-    )]
+    #[clap(long = "disable-notify", value_parser, help = "disable notify, default:false")]
     disable_notify: bool,
-    #[clap(
-        short = 't',
-        long = "type",
-        value_parser,
-        default_value = "",
-        help = "host type"
-    )]
+    #[clap(short = 't', long = "type", value_parser, default_value = "", help = "host type")]
     host_type: String,
     #[clap(long, value_parser, default_value = "", help = "location")]
     location: String,
@@ -134,10 +95,7 @@ fn sample_all(args: &Args, stat_base: &StatRequest) -> StatRequest {
     #[cfg(all(feature = "sysinfo", not(feature = "native")))]
     sys_info::sample(args, &mut stat_rt);
 
-    stat_rt.latest_ts = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap()
-        .as_secs();
+    stat_rt.latest_ts = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
 
     if !args.disable_extra {
         if let Ok(o) = G_CONFIG.lock() {
@@ -174,11 +132,7 @@ fn http_report(args: &Args, stat_base: &mut StatRequest) -> Result<()> {
     let http_client = reqwest::Client::builder()
         .pool_max_idle_per_host(1)
         .connect_timeout(Duration::from_secs(5))
-        .user_agent(format!(
-            "{}/{}",
-            env!("CARGO_BIN_NAME"),
-            env!("CARGO_PKG_VERSION")
-        ))
+        .user_agent(format!("{}/{}", env!("CARGO_BIN_NAME"), env!("CARGO_PKG_VERSION")))
         .build()?;
     loop {
         let stat_rt = sample_all(args, stat_base);

client/src/status.rs

@@ -67,22 +67,16 @@ pub fn get_memory() -> (u64, u64, u64, u64) {
     for line in buf_reader.lines() {
         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(),
-            );
+            res_dict.insert(caps["key"].to_string(), caps["value"].parse::<u64>().unwrap());
         };
     }
 
     let mem_total = res_dict["MemTotal"];
     let swap_total = res_dict["SwapTotal"];
     let swap_free = res_dict["SwapFree"];
 
-    let mem_used = mem_total
-        - res_dict["MemFree"]
-        - res_dict["Buffers"]
-        - res_dict["Cached"]
-        - res_dict["SReclaimable"];
+    let mem_used =
+        mem_total - res_dict["MemFree"] - res_dict["Buffers"] - res_dict["Cached"] - res_dict["SReclaimable"];
 
     (mem_total, mem_used, swap_total, swap_free)
 }
@@ -143,7 +137,8 @@ pub fn get_vnstat_traffic() -> (u64, u64, u64, u64) {
     (network_in, network_out, m_network_in, m_network_out)
 }
 
-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+)"#;
+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();
 }
@@ -228,10 +223,7 @@ pub fn start_net_speed_collect_t() {
                 avgtx += v1[8].parse::<u64>().unwrap();
             }
 
-            let now = SystemTime::now()
-                .duration_since(UNIX_EPOCH)
-                .unwrap()
-                .as_secs() as f64;
+            let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs() as f64;
 
             if let Ok(mut t) = G_NET_SPEED.lock() {
                 t.diff = now - t.clock;
@@ -299,11 +291,10 @@ pub fn get_network() -> (bool, bool) {
             if let Some(addr) = iter.next() {
                 info!("{} => {}", probe_addr, addr);
 
-                let r =
-                    TcpStream::connect_timeout(&addr, Duration::from_millis(TIMEOUT_MS)).map(|s| {
-                        network[idx] = true;
-                        s.shutdown(Shutdown::Both)
-                    });
+                let r = TcpStream::connect_timeout(&addr, Duration::from_millis(TIMEOUT_MS)).map(|s| {
+                    network[idx] = true;
+                    s.shutdown(Shutdown::Both)
+                });
 
                 info!("{:?}", r);
             };
@@ -422,11 +413,7 @@ pub fn sample(args: &Args, stat: &mut StatRequest) {
     stat.hdd_total = hdd_total;
     stat.hdd_used = hdd_used;
 
-    let (t, u, p, d) = if args.disable_tupd {
-        (0, 0, 0, 0)
-    } else {
-        tupd()
-    };
+    let (t, u, p, d) = if args.disable_tupd { (0, 0, 0, 0) } else { tupd() };
     stat.tcp = t;
     stat.udp = u;
     stat.process = p;

server/src/config.rs

@@ -171,8 +171,7 @@ pub fn from_str(content: &str) -> Option<Config> {
     for (idx, group) in o.hosts_group.iter_mut().enumerate() {
         group.pos = idx;
         group.weight = (10000 - (1 + idx) * 100) as u64;
-        o.hosts_group_map
-            .insert(group.gid.to_owned(), group.clone());
+        o.hosts_group_map.insert(group.gid.to_owned(), group.clone());
     }
 
     if o.offline_threshold < 30 {

server/src/grpc.rs

@@ -13,10 +13,7 @@ pub struct ServerStatusSrv {}
 
 #[tonic::async_trait]
 impl ServerStatus for ServerStatusSrv {
-    async fn report(
-        &self,
-        request: Request<StatRequest>,
-    ) -> Result<Response<server_status::Response>, Status> {
+    async fn report(&self, request: Request<StatRequest>) -> Result<Response<server_status::Response>, Status> {
         if let Some(mgr) = G_STATS_MGR.get() {
             match serde_json::to_value(request.get_ref()) {
                 Ok(v) => {
@@ -45,11 +42,7 @@ fn check_auth(req: Request<()>) -> Result<Request<()>, Status> {
 
     match req.metadata().get("authorization") {
         Some(token) => {
-            let tuple = token
-                .to_str()
-                .unwrap_or("")
-                .split("@_@")
-                .collect::<Vec<_>>();
+            let tuple = token.to_str().unwrap_or("").split("@_@").collect::<Vec<_>>();
 
             if tuple.len() == 2 {
                 if let Some(cfg) = G_CONFIG.get() {

server/src/http.rs

@@ -35,11 +35,7 @@ pub async fn init_client(req: Request<Body>) -> Result<Response<Body>> {
     let params: HashMap<String, String> = req
         .uri()
         .query()
-        .map(|v| {
-            url::form_urlencoded::parse(v.as_bytes())
-                .into_owned()
-                .collect()
-        })
+        .map(|v| url::form_urlencoded::parse(v.as_bytes()).into_owned().collect())
         .unwrap_or_else(HashMap::new);
 
     // query args
@@ -49,8 +45,7 @@ pub async fn init_client(req: Request<Body>) -> Result<Response<Body>> {
     let gid = params.get("gid").unwrap_or(&invalid);
     let alias = params.get("alias").unwrap_or(&invalid);
 
-    if pass.is_empty() || (uid.is_empty() && gid.is_empty()) || (uid.is_empty() && alias.is_empty())
-    {
+    if pass.is_empty() || (uid.is_empty() && gid.is_empty()) || (uid.is_empty() && alias.is_empty()) {
         return Ok(Response::builder()
             .status(StatusCode::BAD_REQUEST)
             .body(StatusCode::BAD_REQUEST.canonical_reason().unwrap().into())?);
@@ -196,13 +191,11 @@ pub fn init_jinja_tpl() -> Result<()> {
     let map_html: String = String::from_utf8(map_data.data.try_into()?).unwrap();
     jinja::add_template(KIND, "map", map_html);
 
-    let detail_ht_data =
-        Asset::get("/jinja/detail_ht.jinja.html").expect("detail_ht.jinja.html not found");
+    let detail_ht_data = Asset::get("/jinja/detail_ht.jinja.html").expect("detail_ht.jinja.html not found");
     let detail_ht_html: String = String::from_utf8(detail_ht_data.data.try_into()?).unwrap();
     jinja::add_template(KIND, "detail_ht", detail_ht_html);
 
-    let client_init_sh =
-        Asset::get("/jinja/client-init.jinja.sh").expect("client-init.jinja.sh not found");
+    let client_init_sh = Asset::get("/jinja/client-init.jinja.sh").expect("client-init.jinja.sh not found");
     let client_init_sh_s: String = String::from_utf8(client_init_sh.data.try_into()?).unwrap();
     jinja::add_template(KIND, "client-init", client_init_sh_s);
     Ok(())
@@ -336,20 +329,17 @@ pub async fn get_detail(req: Request<Body>) -> Result<Response<Body>> {
     }
     // table.printstd();
 
-    Ok(jinja::render_template(
-        KIND,
-        "detail",
-        context!(pretty_content => table.to_string()),
-        true,
+    Ok(
+        jinja::render_template(KIND, "detail", context!(pretty_content => table.to_string()), true)
+            .map(|contents| {
+                Response::builder()
+                    .header(header::CONTENT_TYPE, "text/html; charset=utf-8")
+                    .body(Body::from(contents))
+            })?
+            .unwrap_or(
+                Response::builder()
+                    .status(StatusCode::INTERNAL_SERVER_ERROR)
+                    .body(INTERNAL_SERVER_ERROR.into())?,
+            ),
     )
-    .map(|contents| {
-        Response::builder()
-            .header(header::CONTENT_TYPE, "text/html; charset=utf-8")
-            .body(Body::from(contents))
-    })?
-    .unwrap_or(
-        Response::builder()
-            .status(StatusCode::INTERNAL_SERVER_ERROR)
-            .body(INTERNAL_SERVER_ERROR.into())?,
-    ))
 }

server/src/jinja.rs

@@ -23,12 +23,7 @@ where
         .unwrap();
 }
 
-pub fn render_template(
-    kind: &'static str,
-    tag: &'static str,
-    ctx: Value,
-    trim: bool,
-) -> Result<String> {
+pub fn render_template(kind: &'static str, tag: &'static str, ctx: Value, trim: bool) -> Result<String> {
     let name = format!("{}.{}", kind, tag);
     Ok(JINJA_ENV
         .lock()