Merge pull request #16 from jjs-dev/errors

Refactor errors

Author: MikailBag

Cargo.lock

@@ -15,6 +15,7 @@ procfs = "0.7.8"
 nix = {git = "https://github.com/nix-rust/nix"}
 backtrace = "0.3.46"
 thiserror = "1.0.19"
+anyhow = "1.0.32"
 
 [workspace]
 members = ["minion-ffi", ".", "minion-tests", "minion-cli"]

Cargo.toml

@@ -49,7 +49,7 @@ impl Command {
     pub fn spawn(
         &self,
         backend: &dyn erased::Backend,
-    ) -> crate::Result<Box<dyn erased::ChildProcess>> {
+    ) -> anyhow::Result<Box<dyn erased::ChildProcess>> {
         let options = self
             .build()
             .expect("spawn() was requested, but required fields were not set");

src/command.rs

@@ -7,10 +7,10 @@
 /// Type-erased `Sandbox`
 pub trait Sandbox: std::fmt::Debug {
     fn id(&self) -> String;
-    fn check_cpu_tle(&self) -> crate::Result<bool>;
-    fn check_real_tle(&self) -> crate::Result<bool>;
-    fn kill(&self) -> crate::Result<()>;
-    fn resource_usage(&self) -> crate::Result<crate::ResourceUsageData>;
+    fn check_cpu_tle(&self) -> anyhow::Result<bool>;
+    fn check_real_tle(&self) -> anyhow::Result<bool>;
+    fn kill(&self) -> anyhow::Result<()>;
+    fn resource_usage(&self) -> anyhow::Result<crate::ResourceUsageData>;
     #[doc(hidden)]
     fn clone_to_box(&self) -> Box<dyn Sandbox>;
     #[doc(hidden)]
@@ -27,17 +27,17 @@ impl<S: crate::Sandbox> Sandbox for S {
     fn id(&self) -> String {
         self.id()
     }
-    fn check_cpu_tle(&self) -> crate::Result<bool> {
-        self.check_cpu_tle()
+    fn check_cpu_tle(&self) -> anyhow::Result<bool> {
+        self.check_cpu_tle().map_err(Into::into)
     }
-    fn check_real_tle(&self) -> crate::Result<bool> {
-        self.check_real_tle()
+    fn check_real_tle(&self) -> anyhow::Result<bool> {
+        self.check_real_tle().map_err(Into::into)
     }
-    fn kill(&self) -> crate::Result<()> {
-        self.kill()
+    fn kill(&self) -> anyhow::Result<()> {
+        self.kill().map_err(Into::into)
     }
-    fn resource_usage(&self) -> crate::Result<crate::ResourceUsageData> {
-        self.resource_usage()
+    fn resource_usage(&self) -> anyhow::Result<crate::ResourceUsageData> {
+        self.resource_usage().map_err(Into::into)
     }
     fn clone_to_box(&self) -> Box<dyn Sandbox> {
         Box::new(self.clone())
@@ -50,21 +50,21 @@ impl<S: crate::Sandbox> Sandbox for S {
 
 /// Type-erased `ChildProcess`
 pub trait ChildProcess {
-    fn get_exit_code(&self) -> crate::Result<Option<i64>>;
+    fn get_exit_code(&self) -> anyhow::Result<Option<i64>>;
     fn stdin(&mut self) -> Option<Box<dyn std::io::Write + Send + Sync + 'static>>;
     fn stdout(&mut self) -> Option<Box<dyn std::io::Read + Send + Sync + 'static>>;
     fn stderr(&mut self) -> Option<Box<dyn std::io::Read + Send + Sync + 'static>>;
     fn wait_for_exit(
         &self,
         timeout: Option<std::time::Duration>,
-    ) -> crate::Result<crate::WaitOutcome>;
-    fn poll(&self) -> crate::Result<()>;
-    fn is_finished(&self) -> crate::Result<bool>;
+    ) -> anyhow::Result<crate::WaitOutcome>;
+    fn poll(&self) -> anyhow::Result<()>;
+    fn is_finished(&self) -> anyhow::Result<bool>;
 }
 
 impl<C: crate::ChildProcess> ChildProcess for C {
-    fn get_exit_code(&self) -> crate::Result<Option<i64>> {
-        self.get_exit_code()
+    fn get_exit_code(&self) -> anyhow::Result<Option<i64>> {
+        self.get_exit_code().map_err(Into::into)
     }
     fn stdin(&mut self) -> Option<Box<dyn std::io::Write + Send + Sync + 'static>> {
         match self.stdin() {
@@ -87,30 +87,30 @@ impl<C: crate::ChildProcess> ChildProcess for C {
     fn wait_for_exit(
         &self,
         timeout: Option<std::time::Duration>,
-    ) -> crate::Result<crate::WaitOutcome> {
-        self.wait_for_exit(timeout)
+    ) -> anyhow::Result<crate::WaitOutcome> {
+        self.wait_for_exit(timeout).map_err(Into::into)
     }
-    fn poll(&self) -> crate::Result<()> {
-        self.poll()
+    fn poll(&self) -> anyhow::Result<()> {
+        self.poll().map_err(Into::into)
     }
-    fn is_finished(&self) -> crate::Result<bool> {
-        self.is_finished()
+    fn is_finished(&self) -> anyhow::Result<bool> {
+        self.is_finished().map_err(Into::into)
     }
 }
 
 /// Type-erased `Backend`
 pub trait Backend {
-    fn new_sandbox(&self, options: crate::SandboxOptions) -> crate::Result<Box<dyn Sandbox>>;
-    fn spawn(&self, options: ChildProcessOptions) -> crate::Result<Box<dyn ChildProcess>>;
+    fn new_sandbox(&self, options: crate::SandboxOptions) -> anyhow::Result<Box<dyn Sandbox>>;
+    fn spawn(&self, options: ChildProcessOptions) -> anyhow::Result<Box<dyn ChildProcess>>;
 }
 
 impl<B: crate::Backend> Backend for B {
-    fn new_sandbox(&self, options: crate::SandboxOptions) -> crate::Result<Box<dyn Sandbox>> {
+    fn new_sandbox(&self, options: crate::SandboxOptions) -> anyhow::Result<Box<dyn Sandbox>> {
         let sb = <Self as crate::Backend>::new_sandbox(&self, options)?;
         Ok(Box::new(sb))
     }
 
-    fn spawn(&self, options: ChildProcessOptions) -> crate::Result<Box<dyn ChildProcess>> {
+    fn spawn(&self, options: ChildProcessOptions) -> anyhow::Result<Box<dyn ChildProcess>> {
         let down_sandbox = options
             .sandbox
             .clone_into_box_any()
@@ -132,7 +132,7 @@ impl<B: crate::Backend> Backend for B {
 pub type ChildProcessOptions = crate::ChildProcessOptions<Box<dyn Sandbox>>;
 
 /// Returns backend instance
-pub fn setup() -> crate::Result<Box<dyn Backend>> {
+pub fn setup() -> anyhow::Result<Box<dyn Backend>> {
     Ok(Box::new(crate::linux::LinuxBackend::new(
         crate::linux::Settings::new(),
     )?))

src/erased.rs

@@ -20,6 +20,7 @@ use serde::{Deserialize, Serialize};
 pub use crate::linux::{LinuxBackend, LinuxChildProcess, LinuxSandbox};
 
 use std::{
+    error::Error as StdError,
     fmt::Debug,
     io::{Read, Write},
     time::Duration,
@@ -42,10 +43,14 @@ pub fn check() -> Option<String> {
 
 /// Represents way of isolation
 pub trait Backend: Debug + Send + Sync {
-    type Sandbox: Sandbox;
-    type ChildProcess: ChildProcess;
-    fn new_sandbox(&self, options: SandboxOptions) -> Result<Self::Sandbox>;
-    fn spawn(&self, options: ChildProcessOptions<Self::Sandbox>) -> Result<Self::ChildProcess>;
+    type Error: StdError + Send + Sync + 'static;
+    type Sandbox: Sandbox<Error = Self::Error>;
+    type ChildProcess: ChildProcess<Error = Self::Error>;
+    fn new_sandbox(&self, options: SandboxOptions) -> Result<Self::Sandbox, Self::Error>;
+    fn spawn(
+        &self,
+        options: ChildProcessOptions<Self::Sandbox>,
+    ) -> Result<Self::ChildProcess, Self::Error>;
 }
 
 pub use command::Command;
@@ -116,20 +121,21 @@ impl SandboxOptions {
 
 /// Represents highly-isolated sandbox
 pub trait Sandbox: Clone + Debug + 'static {
+    type Error: StdError + Send + Sync + 'static;
     fn id(&self) -> String;
 
     /// Returns true if sandbox exceeded CPU time limit
-    fn check_cpu_tle(&self) -> Result<bool>;
+    fn check_cpu_tle(&self) -> Result<bool, Self::Error>;
 
     /// Returns true if sandbox exceeded wall-clock time limit
-    fn check_real_tle(&self) -> Result<bool>;
+    fn check_real_tle(&self) -> Result<bool, Self::Error>;
 
     /// Kills all processes in sandbox.
     /// Probably, subsequent `spawn` requests will fail.
-    fn kill(&self) -> Result<()>;
+    fn kill(&self) -> Result<(), Self::Error>;
 
     /// Returns information about resource usage by total sandbox
-    fn resource_usage(&self) -> Result<ResourceUsageData>;
+    fn resource_usage(&self) -> Result<ResourceUsageData, Self::Error>;
 }
 
 /// Configures stdin for child
@@ -240,72 +246,11 @@ pub struct ChildProcessOptions<Sandbox> {
     pub pwd: PathBuf,
 }
 
-mod errors {
-    #[derive(Eq, PartialEq)]
-    pub enum ErrorKind {
-        /// This error typically means that isolated process tried to break its sandbox
-        Sandbox,
-        /// Bug in code, using minion, or in minion itself
-        System,
-    }
-
-    #[derive(Debug, thiserror::Error)]
-    #[non_exhaustive]
-    pub enum Error {
-        #[error("requested operation is not supported by backend")]
-        NotSupported,
-        #[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,
-        #[error("unknown error")]
-        Unknown,
-    }
-
-    impl Error {
-        pub fn kind(&self) -> ErrorKind {
-            match self {
-                Error::NotSupported => ErrorKind::System,
-                Error::Syscall { .. } => ErrorKind::System,
-                Error::Io { .. } => ErrorKind::System,
-                Error::Sandbox => ErrorKind::Sandbox,
-                Error::Unknown => ErrorKind::System,
-            }
-        }
-
-        pub fn is_system(&self) -> bool {
-            self.kind() == ErrorKind::System
-        }
-
-        pub fn is_sandbox(&self) -> bool {
-            self.kind() == ErrorKind::Sandbox
-        }
-    }
-
-    impl From<nix::Error> for Error {
-        fn from(err: nix::Error) -> Self {
-            if let Some(errno) = err.as_errno() {
-                Error::Syscall { code: errno as i32 }
-            } else {
-                Error::Unknown
-            }
-        }
-    }
-}
-
-pub use errors::Error;
 use std::{
     ffi::OsString,
     path::{Path, PathBuf},
 };
 
-pub type Result<T> = std::result::Result<T, Error>;
-
 /// May be returned when process was killed
 pub const EXIT_CODE_KILLED: i64 = 0x7eaddeadbeeff00d;
 
@@ -324,12 +269,13 @@ pub enum WaitOutcome {
 
 /// Represents child process.
 pub trait ChildProcess: Debug + 'static {
+    type Error: StdError + Send + Sync + 'static;
     /// Represents pipe from current process to isolated
     type PipeIn: Write + Send + Sync + 'static;
     /// Represents pipe from isolated process to current
     type PipeOut: Read + Send + Sync + 'static;
     /// Returns exit code, if process had exited by the moment of call, or None otherwise.
-    fn get_exit_code(&self) -> Result<Option<i64>>;
+    fn get_exit_code(&self) -> Result<Option<i64>, Self::Error>;
 
     /// Returns writeable stream, connected to child stdin
     ///
@@ -358,12 +304,12 @@ pub trait ChildProcess: Debug + 'static {
 
     /// Waits for child process exit with timeout.
     /// If timeout is None, `wait_for_exit` will block until child has exited
-    fn wait_for_exit(&self, timeout: Option<Duration>) -> Result<WaitOutcome>;
+    fn wait_for_exit(&self, timeout: Option<Duration>) -> Result<WaitOutcome, Self::Error>;
 
     /// Refreshes information about process
-    fn poll(&self) -> Result<()>;
+    fn poll(&self) -> Result<(), Self::Error>;
 
     /// Returns whether child process has exited by the moment of call
     /// This function doesn't blocks on waiting (see `wait_for_exit`).
-    fn is_finished(&self) -> Result<bool>;
+    fn is_finished(&self) -> Result<bool, Self::Error>;
 }