Merge pull request #8 from jjs-dev/thiserrror

Use thiserror

Author: MikailBag

Cargo.lock

@@ -13,9 +13,8 @@ serde_json = "1.0.51"
 tiny-nix-ipc = { git = "https://github.com/myfreeweb/tiny-nix-ipc", features = ["ser_json", "zero_copy"] }
 procfs = "0.7.8"
 nix = {git = "https://github.com/nix-rust/nix"}
-snafu = "0.6.6"
 backtrace = "0.3.46"
-thiserror = "1.0.15"
+thiserror = "1.0.19"
 
 [workspace]
-members = ["minion-ffi", ".", "minion-tests", "minion-cli"]
+members = ["minion-ffi", ".", "minion-tests", "minion-cli"]

Cargo.toml

@@ -287,8 +287,6 @@ pub struct ChildProcessOptions {
 }
 
 mod errors {
-    use snafu::Snafu;
-
     #[derive(Eq, PartialEq)]
     pub enum ErrorKind {
         /// This error typically means that isolated process tried to break its sandbox
@@ -297,26 +295,29 @@ mod errors {
         System,
     }
 
-    #[derive(Debug, Snafu)]
-    #[snafu(visibility(pub))]
+    #[derive(Debug, thiserror::Error)]
+    #[non_exhaustive]
     pub enum Error {
-        #[snafu(display("requested operation is not supported by backend"))]
+        #[error("requested operation is not supported by backend")]
         NotSupported,
-        #[snafu(display("system call failed in undesired fashion (error code {})", code))]
-        System { code: i32 },
-        #[snafu(display("io error"))]
-        Io { source: std::io::Error },
-        #[snafu(display("sandbox interaction failed"))]
+        #[error("system call failed in undesired fashion (error code {})", code)]
+        Syscall { code: i32 },
+        #[error("io error")]
+        Io {
+            #[from]
+            source: std::io::Error,
+        },
+        #[error("sandbox interaction failed")]
         Sandbox,
-        #[snafu(display("unknown error"))]
+        #[error("unknown error")]
         Unknown,
     }
 
     impl Error {
         pub fn kind(&self) -> ErrorKind {
             match self {
                 Error::NotSupported => ErrorKind::System,
-                Error::System { .. } => ErrorKind::System,
+                Error::Syscall { .. } => ErrorKind::System,
                 Error::Io { .. } => ErrorKind::System,
                 Error::Sandbox => ErrorKind::Sandbox,
                 Error::Unknown => ErrorKind::System,
@@ -335,7 +336,7 @@ mod errors {
     impl From<nix::Error> for Error {
         fn from(err: nix::Error) -> Self {
             if let Some(errno) = err.as_errno() {
-                Error::System { code: errno as i32 }
+                Error::Syscall { code: errno as i32 }
             } else {
                 Error::Unknown
             }

src/lib.rs

@@ -16,7 +16,6 @@ use crate::{
     InputSpecificationData, OutputSpecification, OutputSpecificationData, WaitOutcome,
 };
 use nix::sys::memfd;
-use snafu::ResultExt;
 use std::{
     ffi::CString,
     fs,
@@ -115,7 +114,7 @@ fn handle_input_io(spec: InputSpecification) -> crate::Result<(Option<Handle>, H
             Ok((None, h))
         }
         InputSpecificationData::Empty => {
-            let file = fs::File::create("/dev/null").context(crate::errors::Io)?;
+            let file = fs::File::create("/dev/null")?;
             let file = file.into_raw_fd();
             Ok((None, file))
         }
@@ -136,7 +135,7 @@ fn handle_output_io(spec: OutputSpecification) -> crate::Result<(Option<Handle>,
             Ok((Some(h_read), f))
         }
         OutputSpecificationData::Ignore => {
-            let file = fs::File::open("/dev/null").context(crate::errors::Io)?;
+            let file = fs::File::open("/dev/null")?;
             let file = file.into_raw_fd();
             let fd = unsafe { libc::dup(file) };
             Ok((None, fd))
@@ -151,10 +150,9 @@ fn handle_output_io(spec: OutputSpecification) -> crate::Result<(Option<Handle>,
             let mfd = memfd::memfd_create(&memfd_name, flags).unwrap();
             if let Some(sz) = sz {
                 if unsafe { libc::ftruncate(mfd, sz as i64) } == -1 {
-                    crate::errors::System {
+                    return Err(crate::Error::Syscall {
                         code: get_last_error(),
-                    }
-                    .fail()?
+                    });
                 }
             }
             let child_fd = unsafe { libc::dup(mfd) };

src/linux.rs

@@ -344,7 +344,7 @@ fn timed_wait(pid: Pid, timeout: Option<time::Duration>) -> crate::Result<Option
                 if sys_err == libc::EINTR {
                     continue;
                 }
-                crate::errors::System { code: sys_err }.fail()?
+                return Err(crate::Error::Syscall { code: sys_err });
             }
             Ok(0) => None,
             Ok(1) => {