update errors and variable names

src/config.rs

@@ -103,12 +103,12 @@ impl Context {
             .send()
             .await;
         let req = match resp {
-            Ok(re) => re,
-            Err(err) => return Err(err),
+            Ok(o) => o,
+            Err(e) => return Err(e),
         };
         let data: Discovery = match req.json().await {
-            Ok(res) => res,
-            Err(err) => return Err(err),
+            Ok(o) => o,
+            Err(e) => return Err(e),
         };
         Ok(data)
     }
@@ -127,8 +127,8 @@ impl Context {
                     }
                     break;
                 }
-                Err(err) => {
-                    println!("error loading config: {err}, retrying in {CONFIG_RETRY_INTERVAL}s");
+                Err(e) => {
+                    println!("error loading config: {e}, retrying in {CONFIG_RETRY_INTERVAL}s");
                     last_in_err = true;
                     sleep_s(CONFIG_RETRY_INTERVAL).await;
                 }
@@ -365,12 +365,12 @@ impl Config {
             .send()
             .await;
         let req = match resp {
-            Ok(re) => re,
-            Err(err) => return Err(err),
+            Ok(o) => o,
+            Err(e) => return Err(e),
         };
         let data: GlobalConfigV2 = match req.json::<GlobalConfigV2>().await {
-            Ok(res) => res,
-            Err(err) => return Err(err),
+            Ok(o) => o,
+            Err(e) => return Err(e),
         };
 
         for d in data.sets {
@@ -400,13 +400,13 @@ impl Config {
             .await;
 
         let req = match resp {
-            Ok(re) => re,
-            Err(err) => return Err(err),
+            Ok(o) => o,
+            Err(e) => return Err(e),
         };
 
         let data: Vec<IpData> = match req.json::<Vec<IpData>>().await {
-            Ok(res) => res,
-            Err(err) => return Err(err),
+            Ok(o) => o,
+            Err(e) => return Err(e),
         };
 
         Ok(data)
@@ -417,8 +417,8 @@ impl Config {
         for trustnet in &self.trustnets {
             match trustnet.parse() {
                 Ok(net) => trustnets.push(net),
-                Err(err) => {
-                    println!("error parsing {trustnet}, error: {err}");
+                Err(e) => {
+                    println!("error parsing {trustnet}, error: {e}");
                 }
             };
         }

src/ipblc.rs

@@ -189,8 +189,8 @@ async fn handle_fwblock(ctxclone: Arc<RwLock<Context>>, ret: &mut Vec<String>, f
     // apply firewall blocking
     match fwblock(&toblock, ret, fwlen) {
         Ok(_) => {}
-        Err(err) => {
-            println!("Err: {err}, unable to push firewall rules, use super user")
+        Err(e) => {
+            println!("err: {e}, unable to push firewall rules, use super user")
         }
     };
 }

src/monitoring.rs

@@ -11,9 +11,9 @@ pub async fn apiserver(ctxarc: &Arc<RwLock<Context>>) -> io::Result<()> {
     let ctxarc = ctxarc.clone();
     let addr: String = { ctxarc.read().await.cfg.api.parse().unwrap() };
     let listener = match TcpListener::bind(addr).await {
-        Ok(l) => l,
-        Err(err) => {
-            println!("Error: {err}");
+        Ok(o) => o,
+        Err(e) => {
+            println!("error: {e}");
             std::process::exit(1);
         }
     };
@@ -29,13 +29,13 @@ pub async fn apiserver(ctxarc: &Arc<RwLock<Context>>) -> io::Result<()> {
                             match socket.try_read(&mut buf) {
                                 Ok(_) => {}
                                 Err(e) => {
-                                    println!("{e}");
+                                    println!("error: {e}");
                                     continue;
                                 }
                             };
                         }
                         Err(e) => {
-                            println!("{e}");
+                            println!("error: {e}");
                             continue;
                         }
                     }
@@ -49,8 +49,8 @@ pub async fn apiserver(ctxarc: &Arc<RwLock<Context>>) -> io::Result<()> {
 
                     match socket.write_all(res.as_bytes()).await {
                         Ok(_) => {}
-                        Err(err) => {
-                            println!("ee {err}");
+                        Err(e) => {
+                            println!("error: {e}");
                         }
                     }
                 }

src/utils.rs

@@ -6,9 +6,9 @@ use tokio::time::{sleep, Duration};
 
 pub fn read_lines(filename: &String, offset: u64) -> Option<Box<dyn Read>> {
     let mut file = match File::open(filename) {
-        Ok(f) => f,
-        Err(err) => {
-            println!("{err}");
+        Ok(o) => o,
+        Err(e) => {
+            println!("error: {e}");
             return None;
         }
     };

src/webservice.rs

@@ -15,8 +15,8 @@ pub async fn send_to_ipbl_api(server: &str, ip: &IpEvent) {
             Ok(_) => {
                 break;
             }
-            Err(err) => {
-                println!("{err}");
+            Err(e) => {
+                println!("error: {e}");
                 sleep_s(1).await;
                 if try_req == MAX_FAILED_API_RATE {
                     break;