appmgr 0.3.0 rewrite pt 1

appmgr: split bins

update cargo.toml and .gitignore

context

appmgr: refactor error module

appmgr: context

begin new s9pk format

appmgr: add fields to manifest

appmgr: start action abstraction

appmgr: volume abstraction

appmgr: improved volumes

appmgr: install wip

appmgr: health daemon

appmgr: health checks

appmgr: wip

config get

appmgr: secret store

wip

appmgr: config rewritten

appmgr: delete non-reusable code

appmgr: wip

appmgr: please the borrow-checker

appmgr: technically runs now

appmgr: cli

appmgr: clean up cli

appmgr: rpc-toolkit in action

appmgr: wrap up config

appmgr: account for updates during install

appmgr: fix: #308

appmgr: impl Display for Version

appmgr: cleanup

appmgr: set dependents on install

appmgr: dependency health checks

appmgr/src/error.rs

@@ -1,107 +1,245 @@
 use std::fmt::Display;
 
-pub const GENERAL_ERROR: i32 = 1;
-pub const FILESYSTEM_ERROR: i32 = 2;
-pub const DOCKER_ERROR: i32 = 3;
-pub const CFG_SPEC_VIOLATION: i32 = 4;
-pub const CFG_RULES_VIOLATION: i32 = 5;
-pub const NOT_FOUND: i32 = 6;
-pub const INVALID_BACKUP_PASSWORD: i32 = 7;
-pub const VERSION_INCOMPATIBLE: i32 = 8;
-pub const NETWORK_ERROR: i32 = 9;
-pub const REGISTRY_ERROR: i32 = 10;
-pub const SERDE_ERROR: i32 = 11;
+use anyhow::anyhow;
+use patch_db::Revision;
+use rpc_toolkit::yajrc::RpcError;
 
-#[derive(Debug, Fail)]
-#[fail(display = "{}", _0)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ErrorKind {
+    Unknown = 1,
+    Filesystem = 2,
+    Docker = 3,
+    ConfigSpecViolation = 4,
+    ConfigRulesViolation = 5,
+    NotFound = 6,
+    InvalidPassword = 7,
+    VersionIncompatible = 8,
+    Network = 9,
+    Registry = 10,
+    Serialization = 11,
+    Deserialization = 12,
+    Utf8 = 13,
+    ParseVersion = 14,
+    Duplicity = 15,
+    Nginx = 16,
+    Dependency = 17,
+    ParseS9pk = 18,
+    ParseUrl = 19,
+    GParted = 20,
+    Blkid = 21,
+    InvalidOnionAddress = 22,
+    Pack = 23,
+    ValidateS9pk = 24,
+    OpenSSL = 25,
+    Tor = 26,
+    ConfigGen = 27,
+    ParseNumber = 28,
+    Database = 29,
+    InvalidPackageId = 30,
+    InvalidSignature = 31,
+    Backup = 32,
+    Restore = 33,
+    Authorization = 34,
+    AutoConfigure = 35,
+    Action = 36,
+    RateLimited = 37,
+    InvalidRequest = 38,
+    MigrationFailed = 39,
+}
+impl ErrorKind {
+    pub fn as_str(&self) -> &'static str {
+        use ErrorKind::*;
+        match self {
+            Unknown => "Unknown Error",
+            Filesystem => "Filesystem I/O Error",
+            Docker => "Docker Error",
+            ConfigSpecViolation => "Config Spec Violation",
+            ConfigRulesViolation => "Config Rules Violation",
+            NotFound => "Not Found",
+            InvalidPassword => "Invalid Password",
+            VersionIncompatible => "Version Incompatible",
+            Network => "Network Error",
+            Registry => "Registry Error",
+            Serialization => "Serialization Error",
+            Deserialization => "Deserialization Error",
+            Utf8 => "UTF-8 Parse Error",
+            ParseVersion => "Version Parsing Error",
+            Duplicity => "Duplicity Error",
+            Nginx => "Nginx Error",
+            Dependency => "Dependency Error",
+            ParseS9pk => "S9PK Parsing Error",
+            ParseUrl => "URL Parsing Error",
+            GParted => "GNU Parted Error",
+            Blkid => "BLKID Error",
+            InvalidOnionAddress => "Invalid Onion Address",
+            Pack => "Pack Error",
+            ValidateS9pk => "S9PK Validation Error",
+            OpenSSL => "OpenSSL Error",
+            Tor => "Tor Daemon Error",
+            ConfigGen => "Config Generation Error",
+            ParseNumber => "Number Parsing Error",
+            Database => "Database Error",
+            InvalidPackageId => "Invalid Package ID",
+            InvalidSignature => "Invalid Signature",
+            Backup => "Backup Error",
+            Restore => "Restore Error",
+            Authorization => "Unauthorized",
+            AutoConfigure => "Auto-Configure Error",
+            Action => "Action Failed",
+            RateLimited => "Rate Limited",
+            InvalidRequest => "Invalid Request",
+            MigrationFailed => "Migration Failed",
+        }
+    }
+}
+impl Display for ErrorKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+#[derive(Debug)]
 pub struct Error {
-    pub failure: failure::Error,
-    pub code: Option<i32>,
+    pub source: anyhow::Error,
+    pub kind: ErrorKind,
+    pub revision: Option<Revision>,
+}
+impl Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}: {}", self.kind.as_str(), self.source)
+    }
 }
 impl Error {
-    pub fn new<E: Into<failure::Error>>(e: E, code: Option<i32>) -> Self {
+    pub fn new<E: Into<anyhow::Error>>(source: E, kind: ErrorKind) -> Self {
         Error {
-            failure: e.into(),
-            code,
-        }
-    }
-    pub fn from<E: Into<failure::Error>>(e: E) -> Self {
-        Error {
-            failure: e.into(),
-            code: None,
-        }
-    }
-}
-impl From<failure::Error> for Error {
-    fn from(e: failure::Error) -> Self {
-        Error {
-            failure: e,
-            code: None,
+            source: source.into(),
+            kind,
+            revision: None,
         }
     }
 }
 impl From<std::io::Error> for Error {
     fn from(e: std::io::Error) -> Self {
-        Error {
-            failure: e.into(),
-            code: Some(2),
+        Error::new(e, ErrorKind::Filesystem)
+    }
+}
+impl From<std::str::Utf8Error> for Error {
+    fn from(e: std::str::Utf8Error) -> Self {
+        Error::new(e, ErrorKind::Utf8)
+    }
+}
+impl From<std::string::FromUtf8Error> for Error {
+    fn from(e: std::string::FromUtf8Error) -> Self {
+        Error::new(e, ErrorKind::Utf8)
+    }
+}
+impl From<emver::ParseError> for Error {
+    fn from(e: emver::ParseError) -> Self {
+        Error::new(e, ErrorKind::ParseVersion)
+    }
+}
+impl From<rpc_toolkit::url::ParseError> for Error {
+    fn from(e: rpc_toolkit::url::ParseError) -> Self {
+        Error::new(e, ErrorKind::ParseUrl)
+    }
+}
+impl From<std::num::ParseIntError> for Error {
+    fn from(e: std::num::ParseIntError) -> Self {
+        Error::new(e, ErrorKind::ParseNumber)
+    }
+}
+impl From<std::num::ParseFloatError> for Error {
+    fn from(e: std::num::ParseFloatError) -> Self {
+        Error::new(e, ErrorKind::ParseNumber)
+    }
+}
+impl From<patch_db::Error> for Error {
+    fn from(e: patch_db::Error) -> Self {
+        Error::new(e, ErrorKind::Database)
+    }
+}
+impl From<sqlx::Error> for Error {
+    fn from(e: sqlx::Error) -> Self {
+        Error::new(e, ErrorKind::Database)
+    }
+}
+impl From<ed25519_dalek::SignatureError> for Error {
+    fn from(e: ed25519_dalek::SignatureError) -> Self {
+        Error::new(e, ErrorKind::InvalidSignature)
+    }
+}
+impl From<bollard::errors::Error> for Error {
+    fn from(e: bollard::errors::Error) -> Self {
+        Error::new(e, ErrorKind::Docker)
+    }
+}
+impl From<Error> for RpcError {
+    fn from(e: Error) -> Self {
+        let mut data_object = serde_json::Map::with_capacity(2);
+        data_object.insert("message".to_owned(), format!("{}", e).into());
+        data_object.insert(
+            "revision".to_owned(),
+            match serde_json::to_value(&e.revision) {
+                Ok(a) => a,
+                Err(e) => {
+                    log::warn!("Error serializing revision for Error object: {}", e);
+                    serde_json::Value::Null
+                }
+            },
+        );
+        RpcError {
+            code: e.kind as i32,
+            message: e.kind.as_str().into(),
+            data: Some(data_object.into()),
         }
     }
 }
+
 pub trait ResultExt<T, E>
 where
     Self: Sized,
 {
-    fn with_code(self, code: i32) -> Result<T, Error>;
-    fn with_ctx<F: FnOnce(&E) -> (Option<i32>, D), D: Display + Send + Sync + 'static>(
+    fn with_kind(self, kind: ErrorKind) -> Result<T, Error>;
+    fn with_ctx<F: FnOnce(&E) -> (ErrorKind, D), D: Display + Send + Sync + 'static>(
         self,
         f: F,
     ) -> Result<T, Error>;
-    fn no_code(self) -> Result<T, Error>;
 }
 impl<T, E> ResultExt<T, E> for Result<T, E>
 where
-    failure::Error: From<E>,
+    anyhow::Error: From<E>,
 {
-    fn with_code(self, code: i32) -> Result<T, Error> {
-        #[cfg(not(feature = "production"))]
-        assert!(code != 0);
+    fn with_kind(self, kind: ErrorKind) -> Result<T, Error> {
         self.map_err(|e| Error {
-            failure: e.into(),
-            code: Some(code),
+            source: e.into(),
+            kind,
+            revision: None,
         })
     }
 
-    fn with_ctx<F: FnOnce(&E) -> (Option<i32>, D), D: Display + Send + Sync + 'static>(
+    fn with_ctx<F: FnOnce(&E) -> (ErrorKind, D), D: Display + Send + Sync + 'static>(
         self,
         f: F,
     ) -> Result<T, Error> {
         self.map_err(|e| {
-            let (code, ctx) = f(&e);
-            let failure = failure::Error::from(e).context(ctx);
+            let (kind, ctx) = f(&e);
+            let source = anyhow::Error::from(e);
+            let ctx = format!("{}: {}", ctx, source);
+            let source = source.context(ctx);
             Error {
-                code,
-                failure: failure.into(),
+                kind,
+                source: source.into(),
+                revision: None,
             }
         })
     }
-
-    fn no_code(self) -> Result<T, Error> {
-        self.map_err(|e| Error {
-            failure: e.into(),
-            code: None,
-        })
-    }
 }
 
 #[macro_export]
 macro_rules! ensure_code {
     ($x:expr, $c:expr, $fmt:expr $(, $arg:expr)*) => {
         if !($x) {
-            return Err(crate::Error {
-                failure: format_err!($fmt, $($arg, )*),
-                code: Some($c),
-            });
+            return Err(crate::Error::new(anyhow!($fmt, $($arg, )*), $c));
         }
     };
 }