agent: replace unnecessary match Result with map_err

Replace `match Result` whose Ok hand is useless.

Signed-off-by: Tim Zhang <tim@hyper.sh>

src/agent/rustjail/src/container.rs

@@ -320,14 +320,11 @@ impl Container for LinuxContainer {
 pub fn init_child() {
     let cwfd = std::env::var(CWFD_FD).unwrap().parse::<i32>().unwrap();
     let cfd_log = std::env::var(CLOG_FD).unwrap().parse::<i32>().unwrap();
-    match do_init_child(cwfd) {
-        Ok(_) => (),
-        Err(e) => {
+
+    let _ = do_init_child(cwfd).map_err(|e| {
         log_child!(cfd_log, "child exit: {:?}", e);
         let _ = write_sync(cwfd, SYNC_FAILED, format!("{:?}", e).as_str());
-            return;
-        }
-    }
+    });
 }
 
 fn do_init_child(cwfd: RawFd) -> Result<()> {
@@ -392,9 +389,8 @@ fn do_init_child(cwfd: RawFd) -> Result<()> {
                 to_new.set(*s, true);
             }
         } else {
-            let fd = match fcntl::open(ns.path.as_str(), OFlag::O_CLOEXEC, Mode::empty()) {
-                Ok(v) => v,
-                Err(e) => {
+            let fd =
+                fcntl::open(ns.path.as_str(), OFlag::O_CLOEXEC, Mode::empty()).map_err(|e| {
                     log_child!(
                         cfd_log,
                         "cannot open type: {} path: {}",
@@ -402,9 +398,8 @@ fn do_init_child(cwfd: RawFd) -> Result<()> {
                         ns.path.clone()
                     );
                     log_child!(cfd_log, "error is : {}", e.as_errno().unwrap().desc());
-                    return Err(e.into());
-                }
-            };
+                    e
+                })?;
 
             if *s != CloneFlags::CLONE_NEWPID {
                 to_join.push((*s, fd));
@@ -834,16 +829,14 @@ impl BaseContainer for LinuxContainer {
             child_stderr = unsafe { std::process::Stdio::from_raw_fd(stderr) };
         }
 
-        let old_pid_ns = match fcntl::open(PID_NS_PATH, OFlag::O_CLOEXEC, Mode::empty()) {
-            Ok(v) => v,
-            Err(e) => {
+        let old_pid_ns =
+            fcntl::open(PID_NS_PATH, OFlag::O_CLOEXEC, Mode::empty()).map_err(|e| {
                 error!(
                     logger,
                     "cannot open pid ns path: {} with error: {:?}", PID_NS_PATH, e
                 );
-                return Err(e.into());
-            }
-        };
+                e
+            })?;
 
         //restore the parent's process's pid namespace.
         defer!({
@@ -897,7 +890,7 @@ impl BaseContainer for LinuxContainer {
 
         info!(logger, "child pid: {}", p.pid);
 
-        match join_namespaces(
+        join_namespaces(
             &logger,
             &spec,
             &p,
@@ -905,16 +898,15 @@ impl BaseContainer for LinuxContainer {
             &st,
             pwfd,
             prfd,
-        ) {
-            Ok(_) => (),
-            Err(e) => {
+        )
+        .map_err(|e| {
             error!(logger, "create container process error {:?}", e);
             // kill the child process.
             let _ = signal::kill(Pid::from_raw(p.pid), Some(Signal::SIGKILL))
                 .map_err(|e| warn!(logger, "signal::kill joining namespaces {:?}", e));
-                return Err(e);
-            }
-        };
+
+            e
+        })?;
 
         info!(logger, "entered namespaces!");
 
@@ -1085,9 +1077,8 @@ fn get_pid_namespace(logger: &Logger, linux: &Linux) -> Result<Option<RawFd>> {
                 return Ok(None);
             }
 
-            let fd = match fcntl::open(ns.path.as_str(), OFlag::O_CLOEXEC, Mode::empty()) {
-                Ok(v) => v,
-                Err(e) => {
+            let fd =
+                fcntl::open(ns.path.as_str(), OFlag::O_CLOEXEC, Mode::empty()).map_err(|e| {
                     error!(
                         logger,
                         "cannot open type: {} path: {}",
@@ -1095,9 +1086,9 @@ fn get_pid_namespace(logger: &Logger, linux: &Linux) -> Result<Option<RawFd>> {
                         ns.path.clone()
                     );
                     error!(logger, "error is : {}", e.as_errno().unwrap().desc());
-                    return Err(e.into());
-                }
-            };
+
+                    e
+                })?;
 
             return Ok(Some(fd));
         }
@@ -1245,13 +1236,10 @@ fn write_mappings(logger: &Logger, path: &str, maps: &[LinuxIDMapping]) -> Resul
     if !data.is_empty() {
         let fd = fcntl::open(path, OFlag::O_WRONLY, Mode::empty())?;
         defer!(unistd::close(fd).unwrap());
-        match unistd::write(fd, data.as_bytes()) {
-            Ok(_) => {}
-            Err(e) => {
+        unistd::write(fd, data.as_bytes()).map_err(|e| {
             info!(logger, "cannot write mapping");
-                return Err(e.into());
-            }
-        }
+            e
+        })?;
     }
     Ok(())
 }

src/agent/rustjail/src/mount.rs

@@ -407,8 +407,7 @@ fn mount_cgroups(
 
         if key != base {
             let src = format!("{}/{}", m.destination.as_str(), key);
-            match unix::fs::symlink(destination.as_str(), &src[1..]) {
-                Err(e) => {
+            unix::fs::symlink(destination.as_str(), &src[1..]).map_err(|e| {
                 log_child!(
                     cfd_log,
                     "symlink: {} {} err: {}",
@@ -417,10 +416,8 @@ fn mount_cgroups(
                     e.to_string()
                 );
 
-                    return Err(e.into());
-                }
-                Ok(_) => {}
-            }
+                e
+            })?;
         }
     }
 
@@ -689,18 +686,14 @@ fn mount_from(
             Path::new(&dest)
         };
 
-        // let _ = fs::create_dir_all(&dir);
-        match fs::create_dir_all(&dir) {
-            Ok(_) => {}
-            Err(e) => {
+        let _ = fs::create_dir_all(&dir).map_err(|e| {
             log_child!(
                 cfd_log,
                 "creat dir {}: {}",
                 dir.to_str().unwrap(),
                 e.to_string()
-                );
-            }
-        }
+            )
+        });
 
         // make sure file exists so we can bind over it
         if src.is_file() {
@@ -717,31 +710,26 @@ fn mount_from(
         }
     };
 
-    match stat::stat(dest.as_str()) {
-        Ok(_) => {}
-        Err(e) => {
+    let _ = stat::stat(dest.as_str()).map_err(|e| {
         log_child!(
             cfd_log,
             "dest stat error. {}: {}",
             dest.as_str(),
             e.as_errno().unwrap().desc()
-            );
-        }
-    }
+        )
+    });
 
-    match mount(
+    mount(
         Some(src.as_str()),
         dest.as_str(),
         Some(m.r#type.as_str()),
         flags,
         Some(d.as_str()),
-    ) {
-        Ok(_) => {}
-        Err(e) => {
+    )
+    .map_err(|e| {
         log_child!(cfd_log, "mount error: {}", e.as_errno().unwrap().desc());
-            return Err(e.into());
-        }
-    }
+        e
+    })?;
 
     if flags.contains(MsFlags::MS_BIND)
         && flags.intersects(
@@ -753,24 +741,22 @@ fn mount_from(
                 | MsFlags::MS_SLAVE),
         )
     {
-        match mount(
+        mount(
             Some(dest.as_str()),
             dest.as_str(),
             None::<&str>,
             flags | MsFlags::MS_REMOUNT,
             None::<&str>,
-        ) {
-            Err(e) => {
+        )
+        .map_err(|e| {
             log_child!(
                 cfd_log,
                 "remout {}: {}",
                 dest.as_str(),
                 e.as_errno().unwrap().desc()
             );
-                return Err(e.into());
-            }
-            Ok(_) => {}
-        }
+            e
+        })?;
     }
     Ok(())
 }

src/agent/src/device.rs

@@ -130,17 +130,14 @@ fn get_device_name(sandbox: &Arc<Mutex<Sandbox>>, dev_addr: &str) -> Result<Stri
 
     info!(sl!(), "Waiting on channel for device notification\n");
     let hotplug_timeout = AGENT_CONFIG.read().unwrap().hotplug_timeout;
-    let dev_name = match rx.recv_timeout(hotplug_timeout) {
-        Ok(name) => name,
-        Err(_) => {
+    let dev_name = rx.recv_timeout(hotplug_timeout).map_err(|_| {
         GLOBAL_DEVICE_WATCHER.lock().unwrap().remove_entry(dev_addr);
-            return Err(anyhow!(
+        anyhow!(
             "Timeout reached after {:?} waiting for device {}",
             hotplug_timeout,
             dev_addr
-            ));
-        }
-    };
+        )
+    })?;
 
     Ok(format!("{}/{}", SYSTEM_DEV_PATH, &dev_name))
 }

src/agent/src/rpc.rs

@@ -588,13 +588,9 @@ impl protocols::agent_ttrpc::AgentService for agentService {
         _ctx: &ttrpc::TtrpcContext,
         req: protocols::agent::WaitProcessRequest,
     ) -> ttrpc::Result<WaitProcessResponse> {
-        match self.do_wait_process(req) {
-            Err(e) => Err(ttrpc::Error::RpcStatus(ttrpc::get_status(
-                ttrpc::Code::INTERNAL,
-                e.to_string(),
-            ))),
-            Ok(resp) => Ok(resp),
-        }
+        self.do_wait_process(req).map_err(|e| {
+            ttrpc::Error::RpcStatus(ttrpc::get_status(ttrpc::Code::INTERNAL, e.to_string()))
+        })
     }
 
     fn list_processes(
@@ -734,13 +730,9 @@ impl protocols::agent_ttrpc::AgentService for agentService {
                 "invalid container id".to_string(),
             )))?;
 
-        match ctr.stats() {
-            Err(e) => Err(ttrpc::Error::RpcStatus(ttrpc::get_status(
-                ttrpc::Code::INTERNAL,
-                e.to_string(),
-            ))),
-            Ok(resp) => Ok(resp),
-        }
+        ctr.stats().map_err(|e| {
+            ttrpc::Error::RpcStatus(ttrpc::get_status(ttrpc::Code::INTERNAL, e.to_string()))
+        })
     }
 
     fn pause_container(
@@ -794,13 +786,9 @@ impl protocols::agent_ttrpc::AgentService for agentService {
         _ctx: &ttrpc::TtrpcContext,
         req: protocols::agent::WriteStreamRequest,
     ) -> ttrpc::Result<WriteStreamResponse> {
-        match self.do_write_stream(req) {
-            Err(e) => Err(ttrpc::Error::RpcStatus(ttrpc::get_status(
-                ttrpc::Code::INTERNAL,
-                e.to_string(),
-            ))),
-            Ok(resp) => Ok(resp),
-        }
+        self.do_write_stream(req).map_err(|e| {
+            ttrpc::Error::RpcStatus(ttrpc::get_status(ttrpc::Code::INTERNAL, e.to_string()))
+        })
     }
 
     fn read_stdout(
@@ -808,13 +796,9 @@ impl protocols::agent_ttrpc::AgentService for agentService {
         _ctx: &ttrpc::TtrpcContext,
         req: protocols::agent::ReadStreamRequest,
     ) -> ttrpc::Result<ReadStreamResponse> {
-        match self.do_read_stream(req, true) {
-            Err(e) => Err(ttrpc::Error::RpcStatus(ttrpc::get_status(
-                ttrpc::Code::INTERNAL,
-                e.to_string(),
-            ))),
-            Ok(resp) => Ok(resp),
-        }
+        self.do_read_stream(req, true).map_err(|e| {
+            ttrpc::Error::RpcStatus(ttrpc::get_status(ttrpc::Code::INTERNAL, e.to_string()))
+        })
     }
 
     fn read_stderr(
@@ -822,13 +806,9 @@ impl protocols::agent_ttrpc::AgentService for agentService {
         _ctx: &ttrpc::TtrpcContext,
         req: protocols::agent::ReadStreamRequest,
     ) -> ttrpc::Result<ReadStreamResponse> {
-        match self.do_read_stream(req, false) {
-            Err(e) => Err(ttrpc::Error::RpcStatus(ttrpc::get_status(
-                ttrpc::Code::INTERNAL,
-                e.to_string(),
-            ))),
-            Ok(resp) => Ok(resp),
-        }
+        self.do_read_stream(req, false).map_err(|e| {
+            ttrpc::Error::RpcStatus(ttrpc::get_status(ttrpc::Code::INTERNAL, e.to_string()))
+        })
     }
 
     fn close_stdin(
@@ -841,15 +821,12 @@ impl protocols::agent_ttrpc::AgentService for agentService {
         let s = Arc::clone(&self.sandbox);
         let mut sandbox = s.lock().unwrap();
 
-        let p = match find_process(&mut sandbox, cid.as_str(), eid.as_str(), false) {
-            Ok(v) => v,
-            Err(e) => {
-                return Err(ttrpc::Error::RpcStatus(ttrpc::get_status(
+        let p = find_process(&mut sandbox, cid.as_str(), eid.as_str(), false).map_err(|e| {
+            ttrpc::Error::RpcStatus(ttrpc::get_status(
                 ttrpc::Code::INVALID_ARGUMENT,
                 format!("invalid argument: {:?}", e),
-                )));
-            }
-        };
+            ))
+        })?;
 
         if p.term_master.is_some() {
             let _ = unistd::close(p.term_master.unwrap());
@@ -873,15 +850,12 @@ impl protocols::agent_ttrpc::AgentService for agentService {
         let eid = req.exec_id.clone();
         let s = Arc::clone(&self.sandbox);
         let mut sandbox = s.lock().unwrap();
-        let p = match find_process(&mut sandbox, cid.as_str(), eid.as_str(), false) {
-            Ok(v) => v,
-            Err(e) => {
-                return Err(ttrpc::Error::RpcStatus(ttrpc::get_status(
+        let p = find_process(&mut sandbox, cid.as_str(), eid.as_str(), false).map_err(|e| {
+            ttrpc::Error::RpcStatus(ttrpc::get_status(
                 ttrpc::Code::UNAVAILABLE,
                 format!("invalid argument: {:?}", e),
-                )));
-            }
-        };
+            ))
+        })?;
 
         if p.term_master.is_none() {
             return Err(ttrpc::Error::RpcStatus(ttrpc::get_status(
@@ -1335,13 +1309,10 @@ fn get_memory_info(block_size: bool, hotplug: bool) -> Result<(u64, bool)> {
                     return Err(anyhow!("Invalid block size"));
                 }
 
-                size = match u64::from_str_radix(v.trim(), 16) {
-                    Ok(h) => h,
-                    Err(_) => {
+                size = u64::from_str_radix(v.trim(), 16).map_err(|_| {
                     warn!(sl!(), "failed to parse the str {} to hex", size);
-                        return Err(anyhow!("Invalid block size"));
-                    }
-                };
+                    anyhow!("Invalid block size")
+                })?;
             }
             Err(e) => {
                 info!(sl!(), "memory block size error: {:?}", e.kind());

src/agent/src/sandbox.rs

@@ -316,10 +316,9 @@ impl Sandbox {
         thread::spawn(move || {
             for event in rx {
                 info!(logger, "got an OOM event {:?}", event);
-                match tx.send(container_id.clone()) {
-                    Err(err) => error!(logger, "failed to send message: {:?}", err),
-                    Ok(_) => {}
-                }
+                let _ = tx
+                    .send(container_id.clone())
+                    .map_err(|e| error!(logger, "failed to send message: {:?}", e));
             }
         });
     }