Handle displaying all errors in cli main instead of in command run funcs

This consolidates (almost) all of the error display handling into the cli
main(), which is idiomatic since the library side of this shouldn't need to
worry about how its errors are presented.

There are a couple spots where the Error case is a Vec of things, which can't
be handled by the single error handler in main. These have been changed to
do their custom error printing, then return a new error to main(). I added
TODO comments to these.

Signed-off-by: Robert Detjens <[email protected]>

Author: detjensrobert

src/commands/build.rs

@@ -1,3 +1,4 @@
+use anyhow::Result;
 use itertools::Itertools;
 use std::process::exit;
 use tracing::{debug, error, info, trace, warn};
@@ -6,15 +7,12 @@ use crate::builder::build_challenges;
 use crate::configparser::{get_config, get_profile_config};
 
 #[tokio::main(flavor = "current_thread")] // make this a sync function
-pub async fn run(profile_name: &str, push: &bool, extract: &bool) {
+pub async fn run(profile_name: &str, push: &bool, extract: &bool) -> Result<()> {
     info!("building images...");
 
-    let results = match build_challenges(profile_name, *push, *extract).await {
-        Ok(results) => results,
-        Err(e) => {
-            error!("{e:?}");
-            exit(1)
-        }
-    };
+    let results = build_challenges(profile_name, *push, *extract).await?;
+
     info!("images built successfully!");
+
+    Ok(())
 }

src/commands/check_access.rs

@@ -1,12 +1,18 @@
-use anyhow::{Context, Error, Result};
+use anyhow::{bail, Context, Error, Result};
 use itertools::Itertools;
 use std::process::exit;
 use tracing::{debug, error, info, trace, warn};
 
 use crate::access_handlers as access;
 use crate::configparser::{get_config, get_profile_config};
 
-pub fn run(profile: &str, kubernetes: &bool, frontend: &bool, registry: &bool, bucket: &bool) {
+pub fn run(
+    profile: &str,
+    kubernetes: &bool,
+    frontend: &bool,
+    registry: &bool,
+    bucket: &bool,
+) -> Result<()> {
     // if user did not give a specific check, check all of them
     let check_all = !kubernetes && !frontend && !registry && !bucket;
 
@@ -36,6 +42,7 @@ pub fn run(profile: &str, kubernetes: &bool, frontend: &bool, registry: &bool, b
     debug!("access results: {results:?}");
 
     // die if there were any errors
+    // TODO: figure out how to return this error directly
     let mut should_exit = false;
     for (profile, result) in results.iter() {
         match result {
@@ -48,8 +55,10 @@ pub fn run(profile: &str, kubernetes: &bool, frontend: &bool, registry: &bool, b
         }
     }
     if should_exit {
-        exit(1);
+        bail!("config validation failed");
     }
+
+    Ok(())
 }
 
 /// checks a single profile (`profile`) for the given accesses

src/commands/cluster_setup.rs

@@ -7,22 +7,15 @@ use crate::cluster_setup as setup;
 use crate::configparser::{get_config, get_profile_config};
 
 #[tokio::main(flavor = "current_thread")] // make this a sync function
-pub async fn run(profile_name: &str) {
+pub async fn run(profile_name: &str) -> Result<()> {
     info!("setting up cluster...");
     let config = get_profile_config(profile_name).unwrap();
 
-    if let Err(e) = setup::install_ingress(config).await {
-        error!("{e:?}");
-        exit(1);
-    }
-    if let Err(e) = setup::install_certmanager(config).await {
-        error!("{e:?}");
-        exit(1);
-    }
-    if let Err(e) = setup::install_extdns(config).await {
-        error!("{e:?}");
-        exit(1);
-    }
+    setup::install_ingress(config).await?;
+    setup::install_certmanager(config).await?;
+    setup::install_extdns(config).await?;
 
-    info!("charts deployed!")
+    info!("charts deployed!");
+
+    Ok(())
 }

src/commands/deploy.rs

@@ -1,3 +1,4 @@
+use anyhow::Result;
 use itertools::Itertools;
 use std::process::exit;
 use tracing::{debug, error, info, trace, warn};
@@ -7,14 +8,11 @@ use crate::configparser::{get_config, get_profile_config};
 use crate::deploy;
 
 #[tokio::main(flavor = "current_thread")] // make this a sync function
-pub async fn run(profile_name: &str, no_build: &bool, _dry_run: &bool) {
+pub async fn run(profile_name: &str, no_build: &bool, _dry_run: &bool) -> Result<()> {
     let profile = get_profile_config(profile_name).unwrap();
 
     // has the cluster been setup?
-    if let Err(e) = deploy::check_setup(profile).await {
-        error!("{e:?}");
-        exit(1);
-    }
+    deploy::check_setup(profile).await?;
 
     // build before deploying
     if *no_build {
@@ -24,13 +22,7 @@ pub async fn run(profile_name: &str, no_build: &bool, _dry_run: &bool) {
     }
 
     info!("building challenges...");
-    let build_results = match build_challenges(profile_name, true, true).await {
-        Ok(result) => result,
-        Err(e) => {
-            error!("{e:?}");
-            exit(1);
-        }
-    };
+    let build_results = build_challenges(profile_name, true, true).await?;
 
     trace!(
         "got built results: {:#?}",
@@ -47,20 +39,13 @@ pub async fn run(profile_name: &str, no_build: &bool, _dry_run: &bool) {
     // C) update frontend with new state of challenges
 
     // A)
-    if let Err(e) = deploy::kubernetes::deploy_challenges(profile_name, &build_results).await {
-        error!("{e:?}");
-        exit(1);
-    }
+    deploy::kubernetes::deploy_challenges(profile_name, &build_results).await?;
 
     // B)
-    if let Err(e) = deploy::s3::upload_assets(profile_name, &build_results).await {
-        error!("{e:?}");
-        exit(1);
-    }
+    deploy::s3::upload_assets(profile_name, &build_results).await?;
 
     // C)
-    if let Err(e) = deploy::frontend::update_frontend(profile_name, &build_results).await {
-        error!("{e:?}");
-        exit(1);
-    }
+    deploy::frontend::update_frontend(profile_name, &build_results).await?;
+
+    Ok(())
 }

src/commands/validate.rs

@@ -1,28 +1,26 @@
+use anyhow::{bail, Result};
 use std::path::Path;
 use std::process::exit;
 use tracing::{debug, error, info, trace, warn};
 
 use crate::configparser::{get_challenges, get_config, get_profile_deploy};
 
-pub fn run() {
+pub fn run() -> Result<()> {
     info!("validating config...");
-    let config = match get_config() {
-        Ok(c) => c,
-        Err(err) => {
-            error!("{err:#}");
-            exit(1);
-        }
-    };
+
+    let config = get_config()?;
     info!("  config ok!");
 
     info!("validating challenges...");
+    // print these errors here instead of returning, since its a vec of them
+    // TODO: figure out how to return this error directly
     let chals = match get_challenges() {
         Ok(c) => c,
         Err(errors) => {
             for e in errors.iter() {
                 error!("{e:#}");
             }
-            exit(1);
+            bail!("failed to validate challenges");
         }
     };
     info!("  challenges ok!");
@@ -31,29 +29,28 @@ pub fn run() {
     info!("validating deploy config...");
     for (profile_name, _pconfig) in config.profiles.iter() {
         // fetch from config
-        let deploy_challenges = match get_profile_deploy(profile_name) {
-            Ok(d) => &d.challenges,
-            Err(err) => {
-                error!("{err:#}");
-                exit(1);
-            }
-        };
+        let deploy_challenges = get_profile_deploy(profile_name)?;
 
         // check for missing
         let missing: Vec<_> = deploy_challenges
+            .challenges
             .keys()
             .filter(
                 // try to find any challenge paths in deploy config that do not exist
                 |path| !chals.iter().any(|c| c.directory == Path::new(path)),
             )
             .collect();
+
+        // TODO: figure out how to return this error directly
         if !missing.is_empty() {
             error!(
                 "Deploy settings for profile '{profile_name}' has challenges that do not exist:"
             );
             missing.iter().for_each(|path| error!("  - {path}"));
-            exit(1)
+            bail!("failed to validate deploy config");
         }
     }
-    info!("  deploy ok!")
+    info!("  deploy ok!");
+
+    Ok(())
 }

src/main.rs

@@ -38,7 +38,19 @@ fn main() {
         .init();
 
     trace!("args: {:?}", cli);
+
     // dispatch commands
+    match dispatch(cli) {
+        Ok(_) => (),
+        Err(e) => {
+            error!("{e:?}");
+            std::process::exit(1)
+        }
+    };
+}
+
+/// dispatch commands
+fn dispatch(cli: cli::Cli) -> anyhow::Result<()> {
     match &cli.command {
         cli::Commands::Validate => commands::validate::run(),
 
@@ -49,7 +61,7 @@ fn main() {
             registry,
             bucket,
         } => {
-            commands::validate::run();
+            commands::validate::run()?;
             commands::check_access::run(profile, kubernetes, frontend, registry, bucket)
         }
 
@@ -60,7 +72,7 @@ fn main() {
             no_push,
             extract_assets,
         } => {
-            commands::validate::run();
+            commands::validate::run()?;
             commands::build::run(profile, &!no_push, extract_assets)
         }
 
@@ -69,12 +81,13 @@ fn main() {
             no_build,
             dry_run,
         } => {
-            commands::validate::run();
+            commands::validate::run()?;
             commands::deploy::run(profile, no_build, dry_run)
         }
 
         cli::Commands::ClusterSetup { profile } => {
-            commands::cluster_setup::run(profile);
+            commands::validate::run()?;
+            commands::cluster_setup::run(profile)
         }
     }
 }