api: use if-let pattern for error-only handling

It is more readable than using match. We also inline variables in
eprintln!.

Signed-off-by: Maximiliano Sandoval <m.sandoval@proxmox.com>
Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>

pbs-client/src/pxar/dir_stack.rs

@@ -40,18 +40,15 @@ impl PxarDir {
         parent: RawFd,
         allow_existing_dirs: bool,
     ) -> Result<BorrowedFd, Error> {
-        match mkdirat(
+        if let Err(err) = mkdirat(
             parent,
             self.file_name.as_os_str(),
             perms_from_metadata(&self.metadata)?,
         ) {
-            Ok(()) => (),
-            Err(err) => {
             if !(allow_existing_dirs && err.already_exists()) {
                 return Err(err.into());
             }
         }
-        }
 
         self.open_dir(parent)
     }

src/api2/access/user.rs

@@ -385,28 +385,16 @@ pub fn delete_user(userid: Userid, digest: Option<String>) -> Result<(), Error>
     pbs_config::user::save_config(&config)?;
 
     let authenticator = crate::auth::lookup_authenticator(userid.realm())?;
-    match authenticator.remove_password(userid.name()) {
-        Ok(()) => {}
-        Err(err) => {
-            eprintln!(
-                "error removing password after deleting user {:?}: {}",
-                userid, err
-            );
-        }
+    if let Err(err) = authenticator.remove_password(userid.name()) {
+        eprintln!("error removing password after deleting user {userid:?}: {err}",);
     }
 
-    match crate::config::tfa::read().and_then(|mut cfg| {
+    if let Err(err) = crate::config::tfa::read().and_then(|mut cfg| {
         let _: proxmox_tfa::api::NeedsSaving =
             cfg.remove_user(&crate::config::tfa::UserAccess, userid.as_str())?;
         crate::config::tfa::write(&cfg)
     }) {
-        Ok(()) => (),
-        Err(err) => {
-            eprintln!(
-                "error updating TFA config after deleting user {:?}: {}",
-                userid, err
-            );
-        }
+        eprintln!("error updating TFA config after deleting user {userid:?} {err}",);
     }
 
     Ok(())

src/bin/proxmox-daily-update.rs

@@ -55,12 +55,9 @@ async fn do_update(rpcenv: &mut dyn RpcEnvironment) -> Result<(), Error> {
         _ => unreachable!(),
     };
 
-    match check_acme_certificates(rpcenv).await {
-        Ok(()) => (),
-        Err(err) => {
+    if let Err(err) = check_acme_certificates(rpcenv).await {
         log::error!("error checking certificates: {err}");
     }
-    }
 
     // TODO: cleanup tasks like in PVE?
 

src/tape/pool_writer/new_chunks_iterator.rs

@@ -57,13 +57,10 @@ impl NewChunksIterator {
 
                     let blob = datastore.load_chunk(&digest)?;
                     //println!("LOAD CHUNK {}", hex::encode(&digest));
-                    match tx.send(Ok(Some((digest, blob)))) {
-                        Ok(()) => {}
-                        Err(err) => {
-                            eprintln!("could not send chunk to reader thread: {}", err);
+                    if let Err(err) = tx.send(Ok(Some((digest, blob)))) {
+                        eprintln!("could not send chunk to reader thread: {err}");
                         break;
                     }
-                    }
 
                     chunk_index.insert(digest);
                 }

src/tools/parallel_handler.rs

@@ -80,15 +80,12 @@ impl<I: Send + 'static> ParallelHandler<I> {
                             Ok(data) => data,
                             Err(_) => return,
                         };
-                        match (handler_fn)(data) {
-                            Ok(()) => (),
-                            Err(err) => {
+                        if let Err(err) = (handler_fn)(data) {
                             let mut guard = abort.lock().unwrap();
                             if guard.is_none() {
                                 *guard = Some(err.to_string());
                             }
                         }
-                        }
                     })
                     .unwrap(),
             );

src/traffic_control_cache.rs

@@ -164,11 +164,8 @@ impl TrafficControlCache {
         self.last_traffic_control_generation = traffic_control_generation;
         self.last_update = now;
 
-        match self.reload_impl() {
-            Ok(()) => (),
-            Err(err) => {
-                log::error!("TrafficControlCache::reload failed -> {}", err);
-            }
+        if let Err(err) = self.reload_impl() {
+            log::error!("TrafficControlCache::reload failed -> {err}");
         }
     }