done, leaving recovery struct for pattern matching

Author: cameron1024

catalyst-toolbox/src/bin/cli/rewards/voters.rs

@@ -65,8 +65,6 @@ impl VotersRewards {
             votes_count_path,
             vote_threshold,
         } = self;
-        std::fs::read("doesnt_exist")?;
-
         let block = common.input.load_block()?;
         let block0 = Block0Configuration::from_block(&block)?;
 

catalyst-toolbox/src/bin/cli/stats/archive.rs

@@ -87,6 +87,6 @@ pub struct BatchSizeByCaster {
 
 impl BatchSizeByCaster {
     pub fn exec(&self, archiver: ArchiveStats) -> Result<BTreeMap<String, usize>, Report> {
-        Ok(archiver.max_batch_size_per_caster(self.slots_in_epoch)?)
+        archiver.max_batch_size_per_caster(self.slots_in_epoch)
     }
 }

catalyst-toolbox/src/kedqr/img.rs

@@ -10,23 +10,11 @@ use std::fmt;
 use std::fs::File;
 use std::io::prelude::*;
 use std::path::Path;
-use thiserror::Error;
 
 pub struct KeyQrCode {
     inner: QrCode,
 }
 
-
-#[derive(Error, Debug)]
-pub enum QrDecodeError {
-    #[error("couldn't decode QR code")]
-    DecodeError(#[from] quircs::DecodeError),
-    #[error("couldn't extract QR code")]
-    ExtractError(#[from] quircs::ExtractError),
-    #[error("QR code payload is not valid uf8")]
-    NonUtf8Payload,
-}
-
 impl KeyQrCode {
     pub fn generate(key: SecretKey<Ed25519Extended>, password: &[u8]) -> Self {
         let enc_hex = payload::generate(key, password);
@@ -67,14 +55,11 @@ impl KeyQrCode {
 
         codes
             .map(|code| -> Result<_, Report> {
-                let decoded = code
-                    .map_err(QrDecodeError::ExtractError)
-                    .and_then(|c| c.decode().map_err(QrDecodeError::DecodeError))?;
+                let decoded = code?.decode()?;
 
                 // TODO: I actually don't know if this can fail
-                let h = std::str::from_utf8(&decoded.payload)
-                    .map_err(|_| QrDecodeError::NonUtf8Payload)?;
-                payload::decode(h, password).map_err(Into::into)
+                let h = std::str::from_utf8(&decoded.payload)?;
+                payload::decode(h, password)
             })
             .collect()
     }

catalyst-toolbox/src/logs/compare.rs

@@ -1,9 +1,11 @@
-use crate::logs::sentry::{Error, SentryFragmentLog};
+use crate::logs::sentry::SentryFragmentLog;
 use crate::recovery::tally::{deconstruct_account_transaction, ValidationError};
 
 use chain_core::property::Fragment as _;
 use chain_impl_mockchain::fragment::Fragment;
 use chain_impl_mockchain::vote::Payload;
+use color_eyre::eyre::bail;
+use color_eyre::Report;
 use jormungandr_lib::interfaces::PersistentFragmentLog;
 
 use std::collections::HashSet;
@@ -19,7 +21,7 @@ pub struct LogCmpFields {
 
 pub fn persistent_fragment_log_to_log_cmp_fields(
     fragment: &PersistentFragmentLog,
-) -> Result<LogCmpFields, Error> {
+) -> Result<LogCmpFields, Report> {
     if let Fragment::VoteCast(ref transaction) = fragment.fragment.clone() {
         let (vote_cast, identifier, choice) = deconstruct_account_transaction(
             &transaction.as_slice(),
@@ -39,9 +41,7 @@ pub fn persistent_fragment_log_to_log_cmp_fields(
             voteplan_id: vote_cast.vote_plan().to_string(),
         })
     } else {
-        Err(Error::NotVoteCastTransaction {
-            fragment_id: fragment.fragment.id().to_string(),
-        })
+        bail!("not vote cast transaction: {}", fragment.fragment.id())
     }
 }
 
@@ -51,7 +51,7 @@ pub struct LogCmpStats {
     pub duplicated_sentry_logs: usize,
     pub duplicated_fragment_logs: usize,
     pub fragment_ids_differ: HashSet<String>,
-    pub unhandled_fragment_logs: Vec<(Fragment, Error)>,
+    pub unhandled_fragment_logs: Vec<(Fragment, Report)>,
 }
 
 pub fn compare_logs(
@@ -62,7 +62,7 @@ pub fn compare_logs(
     let fragment_logs_size = fragment_logs.len();
     let sentry_cmp: Vec<LogCmpFields> = sentry_logs.iter().cloned().map(Into::into).collect();
 
-    let (fragments_cmp, unhandled_fragment_logs): (Vec<LogCmpFields>, Vec<(Fragment, Error)>) =
+    let (fragments_cmp, unhandled_fragment_logs): (Vec<LogCmpFields>, Vec<(Fragment, Report)>) =
         fragment_logs.iter().fold(
             (Vec::new(), Vec::new()),
             |(mut success, mut errored), log| {

catalyst-toolbox/src/logs/sentry.rs

@@ -1,6 +1,6 @@
 use crate::logs::compare::LogCmpFields;
-use crate::recovery::tally::ValidationError;
 
+use color_eyre::Report;
 use regex::Regex;
 use reqwest::{blocking::Client, Method, Url};
 
@@ -12,24 +12,6 @@ const MALFORMED_QR_MESSAGE: &str = "malformed encryption or decryption payload";
 
 pub type RawLog = serde_json::Value;
 
-#[derive(Debug, thiserror::Error)]
-pub enum Error {
-    #[error(transparent)]
-    RequestError(#[from] reqwest::Error),
-
-    #[error("Unable to parse log from: '{0}'")]
-    LogParseError(String),
-
-    #[error("Not a vote cast transaction: {fragment_id}")]
-    NotVoteCastTransaction { fragment_id: String },
-
-    #[error(transparent)]
-    UrlParseError(#[from] url::ParseError),
-
-    #[error(transparent)]
-    ValidationError(#[from] ValidationError),
-}
-
 pub struct SentryLogClient {
     client: Client,
     api_url: Url,
@@ -46,33 +28,33 @@ impl SentryLogClient {
         }
     }
 
-    pub fn get_raw_logs(&self) -> Result<String, Error> {
-        self.client
+    pub fn get_raw_logs(&self) -> Result<String, Report> {
+        Ok(self
+            .client
             .request(Method::GET, self.api_url.clone())
             .bearer_auth(&self.auth_token)
             .send()?
             .bytes()
-            .map(|b| std::str::from_utf8(&b).unwrap().to_string())
-            .map_err(Error::RequestError)
+            .map(|b| std::str::from_utf8(&b).unwrap().to_string())?)
     }
 
-    pub fn get_json_logs(&self) -> Result<Vec<RawLog>, Error> {
-        self.client
+    pub fn get_json_logs(&self) -> Result<Vec<RawLog>, Report> {
+        Ok(self
+            .client
             .request(Method::GET, self.api_url.clone())
             .bearer_auth(&self.auth_token)
             .send()?
-            .json()
-            .map_err(Error::RequestError)
+            .json()?)
     }
 
-    pub fn get_json_logs_chunks(&self, chunk: usize) -> Result<Vec<RawLog>, Error> {
+    pub fn get_json_logs_chunks(&self, chunk: usize) -> Result<Vec<RawLog>, Report> {
         let api_url = self.api_url.join(&format!("?&cursor=0:{}:0", chunk))?;
-        self.client
+        Ok(self
+            .client
             .request(Method::GET, api_url)
             .bearer_auth(&self.auth_token)
             .send()?
-            .json()
-            .map_err(Error::RequestError)
+            .json()?)
     }
 }
 
@@ -286,7 +268,7 @@ impl From<SentryFragmentLog> for LogCmpFields {
 }
 
 impl FromStr for SentryFragmentLog {
-    type Err = Error;
+    type Err = Report;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let parsed = sscanf::scanf!(
@@ -320,7 +302,7 @@ impl FromStr for SentryFragmentLog {
                     fragment_id,
                 },
             )
-            .ok_or_else(|| Error::LogParseError(s.to_string()))
+            .ok_or_else(|| color_eyre::eyre::eyre!("log parse error: {s}"))
     }
 }
 

catalyst-toolbox/src/stats/archive/calculator.rs

@@ -1,11 +1,10 @@
 use super::loader::ArchiverRecord;
-use chain_impl_mockchain::block::BlockDateParseError;
 use chain_time::TimeEra;
+use color_eyre::Report;
 use itertools::Itertools;
 use jormungandr_lib::interfaces::BlockDate;
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
-use thiserror::Error;
 
 pub struct ArchiveStats {
     records: Vec<ArchiverRecord>,
@@ -59,7 +58,7 @@ impl ArchiveStats {
     pub fn max_batch_size_per_caster(
         &self,
         slots_in_epoch: u32,
-    ) -> Result<BTreeMap<String, usize>, ArchiveCalculatorError> {
+    ) -> Result<BTreeMap<String, usize>, Report> {
         let time_era = self.records[0].time.time_era(slots_in_epoch);
 
         Ok(self
@@ -96,14 +95,3 @@ fn are_equal_or_adjacent(left: &BlockDate, right: &BlockDate, time_era: &TimeEra
     left == right || left.clone().shift_slot(1, time_era) == *right
 }
 
-#[derive(Debug, Error)]
-pub enum ArchiveCalculatorError {
-    #[error("general error")]
-    General(#[from] std::io::Error),
-    #[error("cannot calculate distribution: cannot calculate max element result is empty")]
-    EmptyResult,
-    #[error("csv error")]
-    Csv(#[from] csv::Error),
-    #[error("block date error")]
-    BlockDateParse(#[from] BlockDateParseError),
-}

catalyst-toolbox/src/stats/archive/loader.rs

@@ -1,8 +1,9 @@
+use color_eyre::eyre::bail;
+use color_eyre::Report;
 use csv;
 use jormungandr_lib::interfaces::BlockDate;
 use serde::Deserialize;
 use std::{ffi::OsStr, fmt, path::Path};
-use thiserror::Error;
 
 #[derive(Debug, Deserialize)]
 pub struct ArchiverRecord {
@@ -42,9 +43,7 @@ where
     deserializer.deserialize_f64(VoteOptionsDeserializer())
 }
 
-pub fn load_from_csv<P: AsRef<Path>>(
-    csv_path: P,
-) -> Result<Vec<ArchiverRecord>, ArchiveReaderError> {
+pub fn load_from_csv<P: AsRef<Path>>(csv_path: P) -> Result<Vec<ArchiverRecord>, Report> {
     let csv_path = csv_path.as_ref();
 
     let mut reader = csv::ReaderBuilder::new()
@@ -61,15 +60,13 @@ pub fn load_from_csv<P: AsRef<Path>>(
             Ok(data) => {
                 results.push(data);
             }
-            Err(e) => return Err(ArchiveReaderError::Csv(e)),
+            Err(e) => bail!("bad csv: {e}"),
         }
     }
     Ok(results)
 }
 
-pub fn load_from_folder<P: AsRef<Path>>(
-    folder_path: P,
-) -> Result<Vec<ArchiverRecord>, ArchiveReaderError> {
+pub fn load_from_folder<P: AsRef<Path>>(folder_path: P) -> Result<Vec<ArchiverRecord>, Report> {
     let mut records = Vec::new();
 
     for entry in std::fs::read_dir(folder_path)? {
@@ -83,11 +80,3 @@ pub fn load_from_folder<P: AsRef<Path>>(
     }
     Ok(records)
 }
-
-#[derive(Debug, Error)]
-pub enum ArchiveReaderError {
-    #[error("general error")]
-    General(#[from] std::io::Error),
-    #[error("csv error")]
-    Csv(#[from] csv::Error),
-}

catalyst-toolbox/src/stats/archive/mod.rs

@@ -1,5 +1,5 @@
 mod calculator;
 mod loader;
 
-pub use calculator::{ArchiveCalculatorError, ArchiveStats};
-pub use loader::{load_from_csv, load_from_folder, ArchiveReaderError};
+pub use calculator::ArchiveStats;
+pub use loader::{load_from_csv, load_from_folder};

catalyst-toolbox/src/stats/live/harvester.rs

@@ -1,3 +1,4 @@
+use color_eyre::Report;
 use jormungandr_automation::jormungandr::JormungandrRest;
 use jormungandr_lib::interfaces::FragmentLog;
 use serde_json;
@@ -20,7 +21,7 @@ impl Harvester {
         }
     }
 
-    pub fn harvest(&self) -> Result<Snapshot, super::Error> {
+    pub fn harvest(&self) -> Result<Snapshot, Report> {
         let mut votes_count: usize = 0;
 
         for vote_status in self.rest.vote_plan_statuses()? {
@@ -41,7 +42,7 @@ impl Harvester {
         })
     }
 
-    pub fn fragment_logs(&self) -> Result<Vec<FragmentLog>, super::Error> {
+    pub fn fragment_logs(&self) -> Result<Vec<FragmentLog>, Report> {
         let client = reqwest::blocking::Client::builder()
             .timeout(self.timeout)
             .build()?;

catalyst-toolbox/src/stats/live/mod.rs

@@ -6,16 +6,3 @@ pub use harvester::Harvester;
 pub use monitor::start;
 pub use settings::Settings;
 
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum Error {
-    #[error(transparent)]
-    Rest(#[from] jormungandr_automation::jormungandr::RestError),
-    #[error(transparent)]
-    Reqwest(#[from] reqwest::Error),
-    #[error(transparent)]
-    Serde(#[from] serde_json::Error),
-    #[error(transparent)]
-    Io(#[from] std::io::Error),
-}