Apply clippy suggestions for Error::other and format string interpolation

SudoDios · SudoDios · commit 7ad0ca0ccd1d · 2025-10-17T22:50:58.000+03:30
diff --git a/src/config/mod.rs b/src/config/mod.rs
@@ -1,5 +1,5 @@
 use std::collections::HashMap;
-use std::io::{Error, ErrorKind};
+use std::io::Error;
 use std::path::Path;
 use std::sync::OnceLock;
 
@@ -124,7 +124,7 @@ pub fn init_configs (cmd : Cmd) -> std::io::Result<()> {
                     Ok(())
                 }
                 Err(e) => {
-                    Err(Error::new(ErrorKind::Other,e))
+                    Err(Error::other(e))
                 }
             }
         }
@@ -160,12 +160,12 @@ fn open_config_file(path : &str) -> std::io::Result<ServerConfig> {
                     Ok(config)
                 }
                 Err(e) => {
-                    Err(Error::new(ErrorKind::Other,e))
+                    Err(Error::other(e))
                 }
             }
         }
         Err(e) => {
-            Err(Error::new(ErrorKind::Other,e))
+            Err(Error::other(e))
         }
     }
 }
diff --git a/src/database/mod.rs b/src/database/mod.rs
@@ -1,4 +1,4 @@
-use std::io::{Error, ErrorKind};
+use std::io::Error;
 use std::sync::Arc;
 use log::info;
 use tokio::sync::Mutex;
@@ -59,7 +59,7 @@ pub fn init () -> std::io::Result<Arc<Mutex<dyn Database + Send>>> {
             Ok(Arc::new(Mutex::new(NoneDB)))
         }
         _ => {
-            Err(Error::new(ErrorKind::Other,"Invalid database type."))
+            Err(Error::other("Invalid database type."))
         }
     }
 }
diff --git a/src/database/mysql.rs b/src/database/mysql.rs
@@ -1,4 +1,4 @@
-use std::io::{Error, ErrorKind};
+use std::io::Error;
 use mysql::{Conn, Row};
 use mysql::prelude::Queryable;
 use crate::database::{Database, DBRawToStruct};
@@ -10,7 +10,7 @@ pub struct MySql {
 
 pub fn init (username : &Option<String>,password : &Option<String>,host_name : &Option<String>,db_name : &Option<String>) -> std::io::Result<String> {
     if username.is_none() || password.is_none() || host_name.is_none() || db_name.is_none() {
-        Err(Error::new(ErrorKind::Other,"Error mysql initialize parameters."))
+        Err(Error::other("Error mysql initialize parameters."))
     } else {
         let conn_url = format!("mysql://{}:{}@{}/{}",username.clone().unwrap(),password.clone().unwrap(),host_name.clone().unwrap(),db_name.clone().unwrap());
         let connection = Conn::new(conn_url.as_str());
@@ -37,12 +37,12 @@ pub fn init (username : &Option<String>,password : &Option<String>,host_name : &
                         Ok(conn_url)
                     }
                     Err(e) => {
-                        Err(Error::new(ErrorKind::Other,format!("Error setup mysql {:?}",e)))
+                        Err(Error::other(format!("Error setup mysql {:?}",e)))
                     }
                 }
             }
             Err(e) => {
-                Err(Error::new(ErrorKind::Other,format!("Error setup mysql {:?}",e)))
+                Err(Error::other(format!("Error setup mysql {:?}",e)))
             }
         }
     }
@@ -83,7 +83,7 @@ impl Database for MySql {
                 Ok(())
             }
             Err(e) => {
-                Err(Error::new(ErrorKind::Other, format!("Error insert mysql {:?}", e)))
+                Err(Error::other( format!("Error insert mysql {:?}", e)))
             }
         }
     }
@@ -104,7 +104,7 @@ impl Database for MySql {
                 }
             }
             Err(e) => {
-                Err(Error::new(ErrorKind::Other, format!("Error select mysql {:?}",e)))
+                Err(Error::other(format!("Error select mysql {:?}",e)))
             }
         }
     }
@@ -119,7 +119,7 @@ impl Database for MySql {
                 Ok(result)
             }
             Err(e) => {
-                Err(Error::new(ErrorKind::Other, format!("Error select mysql {:?}", e)))
+                Err(Error::other(format!("Error select mysql {:?}", e)))
             }
         }
     }
diff --git a/src/database/none.rs b/src/database/none.rs
@@ -1,4 +1,4 @@
-use std::io::{Error, ErrorKind};
+use std::io::Error;
 use crate::database::Database;
 use crate::results::TelemetryData;
 
@@ -7,12 +7,12 @@ pub struct NoneDB;
 impl Database for NoneDB {
     fn insert(&mut self,data : TelemetryData) -> std::io::Result<()> {
         drop(data);
-        Err(Error::new(ErrorKind::Other,"Database disabled"))
+        Err(Error::other("Database disabled"))
     }
     fn fetch_by_uuid(&mut self,_uuid : &str) -> std::io::Result<Option<TelemetryData>> {
-        Err(Error::new(ErrorKind::Other,"Database disabled"))
+        Err(Error::other("Database disabled"))
     }
     fn fetch_last_100(&mut self) -> std::io::Result<Vec<TelemetryData>> {
-        Err(Error::new(ErrorKind::Other,"Database disabled"))
+        Err(Error::other("Database disabled"))
     }
 }
diff --git a/src/database/postgres.rs b/src/database/postgres.rs
@@ -1,4 +1,4 @@
-use std::io::{Error, ErrorKind};
+use std::io::Error;
 use postgres::{Client, NoTls, Row};
 use tokio::task::block_in_place;
 use crate::database::{Database, DBRawToStruct};
@@ -10,7 +10,7 @@ pub struct Postgres {
 
 pub fn init (username : &Option<String>,password : &Option<String>,host_name : &Option<String>,db_name : &Option<String>) -> std::io::Result<Client> {
     if username.is_none() || password.is_none() || host_name.is_none() || db_name.is_none() {
-        Err(Error::new(ErrorKind::Other,"Error postgres initialize parameters."))
+        Err(Error::other("Error postgres initialize parameters."))
     } else {
         let conn_url = format!("postgresql://{}:{}@{}/{}",username.clone().unwrap(),password.clone().unwrap(),host_name.clone().unwrap(),db_name.clone().unwrap());
         block_in_place(|| {
@@ -40,12 +40,12 @@ pub fn init (username : &Option<String>,password : &Option<String>,host_name : &
                             Ok(client)
                         }
                         Err(e) => {
-                            Err(Error::new(ErrorKind::Other,format!("Error setup postgres {:?}",e)))
+                            Err(Error::other(format!("Error setup postgres {:?}",e)))
                         }
                     }
                 }
                 Err(e) => {
-                    Err(Error::new(ErrorKind::Other,format!("Error setup postgres {:?}",e)))
+                    Err(Error::other(format!("Error setup postgres {:?}",e)))
                 }
             }
         })
@@ -86,7 +86,7 @@ impl Database for Postgres {
                 Ok(())
             }
             Err(e) => {
-                Err(Error::new(ErrorKind::Other, format!("Error insert postgres {:?}", e)))
+                Err(Error::other(format!("Error insert postgres {:?}", e)))
             }
         }
     }
@@ -99,7 +99,7 @@ impl Database for Postgres {
                 Ok(Some(row.to_telemetry_struct().unwrap()))
             }
             Err(e) => {
-                Err(Error::new(ErrorKind::Other, format!("Error select postgres {:?}", e)))
+                Err(Error::other(format!("Error select postgres {:?}", e)))
             }
         }
     }
@@ -113,7 +113,7 @@ impl Database for Postgres {
                 Ok(result)
             }
             Err(e) => {
-                Err(Error::new(ErrorKind::Other, format!("Error select postgres {:?}", e)))
+                Err(Error::other(format!("Error select postgres {:?}", e)))
             }
         }
     }
diff --git a/src/database/sqlite.rs b/src/database/sqlite.rs
@@ -1,4 +1,4 @@
-use std::io::{Error, ErrorKind};
+use std::io::Error;
 use rusqlite::{Connection, Row};
 use crate::database::{Database, DBRawToStruct};
 use crate::results::TelemetryData;
@@ -10,7 +10,7 @@ pub struct SQLite {
 pub fn init (database_file : &Option<String>) -> std::io::Result<Connection> {
     match database_file {
         None => {
-            Err(Error::new(ErrorKind::Other,"Error setup sqlite invalid database file."))
+            Err(Error::other("Error setup sqlite invalid database file."))
         }
         Some(database_file) => {
             let connection = Connection::open(database_file);
@@ -39,12 +39,12 @@ pub fn init (database_file : &Option<String>) -> std::io::Result<Connection> {
                             Ok(connection)
                         }
                         Err(e) => {
-                            Err(Error::new(ErrorKind::Other,format!("Error setup sqlite {:?}",e)))
+                            Err(Error::other(format!("Error setup sqlite {:?}",e)))
                         }
                     }
                 }
                 Err(e) => {
-                    Err(Error::new(ErrorKind::Other,format!("Error setup sqlite {:?}",e)))
+                    Err(Error::other(format!("Error setup sqlite {:?}",e)))
                 }
             }
         }
@@ -83,7 +83,7 @@ impl Database for SQLite {
                 Ok(())
             }
             Err(e) => {
-                Err(Error::new(ErrorKind::Other, format!("Error insert sqlite {:?}", e)))
+                Err(Error::other(format!("Error insert sqlite {:?}", e)))
             }
         }
     }
@@ -103,7 +103,7 @@ impl Database for SQLite {
                 }
             }
             Err(e) => {
-                Err(Error::new(ErrorKind::Other, format!("Error select sqlite {:?}", e)))
+                Err(Error::other(format!("Error select sqlite {:?}", e)))
             }
         }
     }
@@ -124,7 +124,7 @@ impl Database for SQLite {
                 }
             }
             Err(e) => {
-                Err(Error::new(ErrorKind::Other, format!("Error select sqlite {:?}", e)))
+                Err(Error::other(format!("Error select sqlite {:?}", e)))
             }
         }
     }
diff --git a/src/http/http_client.rs b/src/http/http_client.rs
@@ -1,5 +1,5 @@
 use std::fs::File;
-use std::io::{Error, ErrorKind};
+use std::io::{Error};
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use serde_json::Value;
@@ -118,8 +118,8 @@ impl HttpClient {
                 let parsed_headers = header_parser(buf_reader).await;
                 //read body
                 let body_len = parsed_headers.get("Content-Length");
-                if body_len.is_some() {
-                    let body_len = body_len.unwrap().parse::<usize>().unwrap();
+                if let Some(body_len) = body_len {
+                    let body_len = body_len.parse::<usize>().unwrap();
                     let pb = ProgressBar::new(body_len as u64);
                     pb.set_style(ProgressStyle::with_template("{spinner:.green} [{elapsed_precise}] [{wide_bar:.cyan/blue}] {bytes}/{total_bytes} ({eta})")
                         .unwrap()
@@ -152,7 +152,7 @@ impl HttpClient {
             let port = if scheme == "https" { 443 } else { 80 };
             Ok((scheme.to_string(),host.to_string(),port,path.to_string()))
         } else {
-            Err(Error::new(ErrorKind::Other,"Error parsing input url"))
+            Err(Error::other("Error parsing input url"))
         }
     }
 
diff --git a/src/http/http_server.rs b/src/http/http_server.rs
@@ -25,7 +25,7 @@ impl HttpServer {
     pub async fn init () -> std::io::Result<Self> {
         let config = SERVER_CONFIG.get().unwrap();
         let tcp_socket = TcpSocket::make_listener(config)?;
-        info!("Server started on {}",tcp_socket.to_string());
+        info!("Server started on {}",tcp_socket);
         info!("Server base url : {}/",config.base_url);
         let mut tls_acceptor = None;
         if config.enable_tls {
@@ -51,17 +51,9 @@ impl HttpServer {
 
                         let remote_addr = find_remote_ip_addr(&mut socket).await;
 
-                        if tls_acceptor.is_none() {
+                        if let Some(tls_acceptor) = tls_acceptor {
 
-                            let (socket_r,socket_w) = socket.split();
-                            let mut buff_reader = BufReader::with_capacity(8 * 1024,socket_r);
-                            let mut buff_writer = BufWriter::with_capacity(8 * 1024,socket_w);
-                            Self::handle_connection(&remote_addr,&mut buff_reader,&mut buff_writer,&mut database).await;
-
-
-                        } else {
-
-                            let stream = tls_acceptor.unwrap().accept(socket).await;
+                            let stream = tls_acceptor.accept(socket).await;
                             match stream {
                                 Ok(stream) => {
 
@@ -72,17 +64,24 @@ impl HttpServer {
 
                                 }
                                 Err(e) => {
-                                    trace!("Error tcp connection : {}",e.to_string())
+                                    trace!("Error tcp connection : {e}")
                                 }
                             }
 
+                        } else {
+
+                            let (socket_r,socket_w) = socket.split();
+                            let mut buff_reader = BufReader::with_capacity(8 * 1024,socket_r);
+                            let mut buff_writer = BufWriter::with_capacity(8 * 1024,socket_w);
+                            Self::handle_connection(&remote_addr,&mut buff_reader,&mut buff_writer,&mut database).await;
+
                         }
 
                     });
 
                 }
                 Err(e) => {
-                    trace!("Error tcp connection : {}",e.to_string())
+                    trace!("Error tcp connection : {e}")
                 }
             }
 
diff --git a/src/http/request.rs b/src/http/request.rs
@@ -159,20 +159,20 @@ F: Send + Sync + Fn(Request) -> Pin<Box<dyn Future<Output = Response> + Send>>
             form_data : body_form_data.clone().unwrap_or(HashMap::new())
         }).await;
         if let Err(e) = buf_writer.write_all(&response.data).await {
-            trace!("Error socket write : {}",e.to_string())
+            trace!("Error socket write : {e}")
         }
         if response.chunk_count > 0 {
             for _ in 0..response.chunk_count {
                 if let Err(e) = buf_writer.write_all(GARBAGE_DATA.get().unwrap()).await {
-                    trace!("Error socket write chunk : {}",e.to_string())
+                    trace!("Error socket write chunk : {e}")
                 }
             }
             if let Err(e) = buf_writer.write_all(b"0\r\n\r\n").await {
-                trace!("Error socket write eof : {}",e.to_string())
+                trace!("Error socket write eof : {e}")
             }
         }
         if let Err(e) = buf_writer.flush().await {
-            trace!("Error socket flush : {}",e.to_string())
+            trace!("Error socket flush : {e}")
         }
     }
 }
@@ -184,10 +184,7 @@ fn check_is_status_line (line : String) -> bool {
 
 #[allow(dead_code)]
 fn hex_string_to_int(hex_string: &str) -> Option<u64> {
-    match u64::from_str_radix(hex_string, 16) {
-        Ok(parsed_int) => Some(parsed_int),
-        Err(_) => None,
-    }
+    u64::from_str_radix(hex_string, 16).ok()
 }
 
 pub async fn header_parser<R>(buf_reader: &mut BufReader<R>) -> CIHashMap<String>
diff --git a/src/http/tcp_socket.rs b/src/http/tcp_socket.rs
@@ -138,7 +138,7 @@ impl IpParser for &str {
                 IpAddr::V4(_) => Ok((ip, Domain::IPV4)),
                 IpAddr::V6(_) => Ok((ip, Domain::IPV6)),
             },
-            Err(e) => Err(Error::new(ErrorKind::Other, e)),
+            Err(e) => Err(Error::other(e)),
         }
     }
 }
diff --git a/src/http/tls.rs b/src/http/tls.rs
@@ -36,7 +36,7 @@ fn open_file_buf(path : &str,err_msg : &str) -> std::io::Result<File> {
     if let Ok(file) = File::open(path) {
         Ok(file)
     } else {
-        Err(Error::new(ErrorKind::Other,err_msg))
+        Err(Error::other(err_msg))
     }
 }
 
@@ -46,5 +46,5 @@ fn load_certs(path: &str) -> std::io::Result<Vec<CertificateDer<'static>>> {
 
 fn load_key(path: &str) -> std::io::Result<PrivateKeyDer<'static>> {
     private_key(&mut BufReader::new(open_file_buf(path,"Failed to load tls key file")?)).unwrap()
-        .ok_or(Error::new(ErrorKind::Other, "Failed to load tls key file".to_string()))
+        .ok_or(Error::other("Failed to load tls key file".to_string()))
 }
diff --git a/src/main.rs b/src/main.rs
diff --git a/src/results/telemetry.rs b/src/results/telemetry.rs

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`use std::collections::HashMap;`
`2`		`-use std::io::{Error, ErrorKind};`
	`2`	`+use std::io::Error;`
`3`	`3`	`use std::path::Path;`
`4`	`4`	`use std::sync::OnceLock;`
`5`	`5`
`@@ -124,7 +124,7 @@ pub fn init_configs (cmd : Cmd) -> std::io::Result<()> {`
`124`	`124`	`Ok(())`
`125`	`125`	`}`
`126`	`126`	`Err(e) => {`
`127`		`- Err(Error::new(ErrorKind::Other,e))`
	`127`	`+ Err(Error::other(e))`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`	`}`
`@@ -160,12 +160,12 @@ fn open_config_file(path : &str) -> std::io::Result<ServerConfig> {`
`160`	`160`	`Ok(config)`
`161`	`161`	`}`
`162`	`162`	`Err(e) => {`
`163`		`- Err(Error::new(ErrorKind::Other,e))`
	`163`	`+ Err(Error::other(e))`
`164`	`164`	`}`
`165`	`165`	`}`
`166`	`166`	`}`
`167`	`167`	`Err(e) => {`
`168`		`- Err(Error::new(ErrorKind::Other,e))`
	`168`	`+ Err(Error::other(e))`
`169`	`169`	`}`
`170`	`170`	`}`
`171`	`171`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use std::io::{Error, ErrorKind};`
	`1`	`+use std::io::Error;`
`2`	`2`	`use std::sync::Arc;`
`3`	`3`	`use log::info;`
`4`	`4`	`use tokio::sync::Mutex;`
`@@ -59,7 +59,7 @@ pub fn init () -> std::io::Result<Arc<Mutex<dyn Database + Send>>> {`
`59`	`59`	`Ok(Arc::new(Mutex::new(NoneDB)))`
`60`	`60`	`}`
`61`	`61`	`_ => {`
`62`		`- Err(Error::new(ErrorKind::Other,"Invalid database type."))`
	`62`	`+ Err(Error::other("Invalid database type."))`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -159,20 +159,20 @@ F: Send + Sync + Fn(Request) -> Pin<Box<dyn Future<Output = Response> + Send>>`
`159`	`159`	`form_data : body_form_data.clone().unwrap_or(HashMap::new())`
`160`	`160`	`}).await;`
`161`	`161`	`if let Err(e) = buf_writer.write_all(&response.data).await {`
`162`		`- trace!("Error socket write : {}",e.to_string())`
	`162`	`+ trace!("Error socket write : {e}")`
`163`	`163`	`}`
`164`	`164`	`if response.chunk_count > 0 {`
`165`	`165`	`for _ in 0..response.chunk_count {`
`166`	`166`	`if let Err(e) = buf_writer.write_all(GARBAGE_DATA.get().unwrap()).await {`
`167`		`- trace!("Error socket write chunk : {}",e.to_string())`
	`167`	`+ trace!("Error socket write chunk : {e}")`
`168`	`168`	`}`
`169`	`169`	`}`
`170`	`170`	`if let Err(e) = buf_writer.write_all(b"0\r\n\r\n").await {`
`171`		`- trace!("Error socket write eof : {}",e.to_string())`
	`171`	`+ trace!("Error socket write eof : {e}")`
`172`	`172`	`}`
`173`	`173`	`}`
`174`	`174`	`if let Err(e) = buf_writer.flush().await {`
`175`		`- trace!("Error socket flush : {}",e.to_string())`
	`175`	`+ trace!("Error socket flush : {e}")`
`176`	`176`	`}`
`177`	`177`	`}`
`178`	`178`	`}`
`@@ -184,10 +184,7 @@ fn check_is_status_line (line : String) -> bool {`
`184`	`184`
`185`	`185`	`#[allow(dead_code)]`
`186`	`186`	`fn hex_string_to_int(hex_string: &str) -> Option<u64> {`
`187`		`- match u64::from_str_radix(hex_string, 16) {`
`188`		`- Ok(parsed_int) => Some(parsed_int),`
`189`		`- Err(_) => None,`
`190`		`- }`
	`187`	`+ u64::from_str_radix(hex_string, 16).ok()`
`191`	`188`	`}`
`192`	`189`
`193`	`190`	`pub async fn header_parser<R>(buf_reader: &mut BufReader<R>) -> CIHashMap<String>`
Original file line number	Diff line number	Diff line change
`@@ -138,7 +138,7 @@ impl IpParser for &str {`
`138`	`138`	`IpAddr::V4(_) => Ok((ip, Domain::IPV4)),`
`139`	`139`	`IpAddr::V6(_) => Ok((ip, Domain::IPV6)),`
`140`	`140`	`},`
`141`		`- Err(e) => Err(Error::new(ErrorKind::Other, e)),`
	`141`	`+ Err(e) => Err(Error::other(e)),`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`	`}`