refactor runtime errors

Author: ghubertpalo

mithril-aggregator/src/runtime/error.rs

@@ -1,74 +1,117 @@
-use crate::certificate_creator::CertificateCreationError;
-use crate::snapshot_stores::SnapshotStoreError;
-use crate::{ProtocolError, SignerRegistrationError, SnapshotError};
+use crate::ProtocolError;
 
 use mithril_common::certificate_chain::CertificateVerifierError;
 use mithril_common::chain_observer::ChainObserverError;
-use mithril_common::digesters::{ImmutableDigesterError, ImmutableFileListingError};
+use mithril_common::digesters::ImmutableDigesterError;
 use mithril_common::entities::BeaconComparisonError;
-use mithril_common::entities::Epoch;
 use mithril_common::store::StoreError;
 use mithril_common::BeaconProviderError;
 use std::error::Error as StdError;
-use std::io;
 use thiserror::Error;
 
+/// Error encountered or produced by the Runtime.
+/// This enum represents the faith of the errors produced during the state
+/// transitions.
 #[derive(Error, Debug)]
 pub enum RuntimeError {
-    /// MultiSigner error
-    #[error("multi signer error: {0}")]
-    MultiSigner(#[from] ProtocolError),
-
-    #[error("snapshotter error: {0}")]
-    Snapshotter(#[from] SnapshotError),
-
-    #[error("digester error: {0}")]
-    Digester(#[from] ImmutableDigesterError),
-
-    #[error("store error: {0}")]
-    StoreError(#[from] StoreError),
-
-    #[error("snapshot uploader error: {0}")]
-    SnapshotUploader(String),
-
-    #[error("snapshot build error: {0}")]
-    SnapshotBuild(#[from] io::Error),
-
-    #[error("immutable file scanning error: {0}")]
-    ImmutableFile(#[from] ImmutableFileListingError),
+    /// Errors that need the runtime to try again without changing its state.
+    #[error("An error occured: {message}. This runtime cycle will be skipped. Nested error: {nested_error:#?}.")]
+    KeepState {
+        /// error message
+        message: String,
 
-    #[error("chain observer error: {0}")]
-    ChainObserver(#[from] ChainObserverError),
+        /// Eventual caught error
+        nested_error: Option<Box<dyn StdError + Sync + Send>>,
+    },
+    /// A Critical error means the Runtime stops and the software exits with an
+    /// error code.
+    #[error("Critical error:'{message}'. Nested error: {nested_error:#?}.")]
+    Critical {
+        /// error message
+        message: String,
 
-    #[error("beacon provider error: {0}")]
-    BeaconProvider(#[from] BeaconProviderError),
+        /// Eventual caught error
+        nested_error: Option<Box<dyn StdError + Sync + Send>>,
+    },
+}
 
-    #[error("certificate verifier error: {0}")]
-    CertificateVerifier(#[from] CertificateVerifierError),
+impl RuntimeError {
+    /// Create a new KeepState error
+    pub fn keep_state(message: &str, error: Option<Box<dyn StdError + Sync + Send>>) -> Self {
+        Self::KeepState {
+            message: message.to_string(),
+            nested_error: error,
+        }
+    }
+
+    /// Create a new Critical error
+    pub fn critical(message: &str, error: Option<Box<dyn StdError + Sync + Send>>) -> Self {
+        Self::Critical {
+            message: message.to_string(),
+            nested_error: error,
+        }
+    }
+}
 
-    #[error("certificate chain gap error: {0} vs {1}")]
-    CertificateChainEpochGap(Epoch, Epoch),
+impl From<BeaconComparisonError> for RuntimeError {
+    fn from(value: BeaconComparisonError) -> Self {
+        Self::KeepState {
+            message: "Beacon comparison error".to_string(),
+            nested_error: Some(value.into()),
+        }
+    }
+}
 
-    #[error("snapshot store error: {0}")]
-    SnapshotStore(#[from] SnapshotStoreError),
+impl From<ImmutableDigesterError> for RuntimeError {
+    fn from(value: ImmutableDigesterError) -> Self {
+        Self::KeepState {
+            message: "Error while reading immutable files".to_string(),
+            nested_error: Some(value.into()),
+        }
+    }
+}
 
-    #[error("certificate creation error: {0}")]
-    CertificateCreation(#[from] CertificateCreationError),
+impl From<ProtocolError> for RuntimeError {
+    fn from(value: ProtocolError) -> Self {
+        Self::KeepState {
+            message: "Mithril Protocol Error".to_string(),
+            nested_error: Some(value.into()),
+        }
+    }
+}
 
-    #[error("beacon comparison error: {0}")]
-    BeaconComparisonError(#[from] BeaconComparisonError),
+impl From<ChainObserverError> for RuntimeError {
+    fn from(value: ChainObserverError) -> Self {
+        Self::KeepState {
+            message: "Chain observer error".to_string(),
+            nested_error: Some(value.into()),
+        }
+    }
+}
 
-    #[error("signer registration error: {0}")]
-    SignerRegistration(#[from] SignerRegistrationError),
+impl From<StoreError> for RuntimeError {
+    fn from(value: StoreError) -> Self {
+        Self::KeepState {
+            message: "Store Error".to_string(),
+            nested_error: Some(value.into()),
+        }
+    }
+}
 
-    #[error("general error: {0}")]
-    General(Box<dyn StdError + Sync + Send>),
+impl From<BeaconProviderError> for RuntimeError {
+    fn from(value: BeaconProviderError) -> Self {
+        Self::KeepState {
+            message: "Could not read beacon from chain".to_string(),
+            nested_error: Some(value.into()),
+        }
+    }
+}
 
-    /// A Critical error means the Runtime stops and the software exits with an
-    /// error code.
-    #[error("Critical error '{message}'. Nested error: {nested_error:#?}")]
-    Critical {
-        message: String,
-        nested_error: Option<Box<dyn StdError + Sync + Send>>,
-    },
+impl From<CertificateVerifierError> for RuntimeError {
+    fn from(value: CertificateVerifierError) -> Self {
+        Self::KeepState {
+            message: "Could not verify given certificate".to_string(),
+            nested_error: Some(value.into()),
+        }
+    }
 }