bubble async up to avoid nested tokio runtime panics

Signed-off-by: Robert Detjens <github@detjens.dev>

Author: detjensrobert

src/builder/docker.rs

@@ -28,7 +28,6 @@ pub struct ContainerInfo {
     id: String,
 }
 
-#[tokio::main(flavor = "current_thread")] // make this a sync function
 pub async fn build_image(context: &Path, options: &BuildObject, tag: &str) -> Result<String> {
     trace!("building image in directory {context:?} to tag {tag:?}");
     let client = docker().await?;
@@ -84,7 +83,7 @@ pub async fn build_image(context: &Path, options: &BuildObject, tag: &str) -> Re
     Ok(tag.to_string())
 }
 
-#[tokio::main(flavor = "current_thread")] // make this a sync function
+// #[tokio::main(flavor = "current_thread")] // make this a sync function
 pub async fn push_image(image_tag: &str, creds: &UserPass) -> Result<String> {
     info!("pushing image {image_tag:?} to registry");
     let client = docker().await?;

src/builder/mod.rs

@@ -47,19 +47,25 @@ pub enum TagWithSource {
 }
 
 /// Build all enabled challenges for the given profile. Returns tags built
-pub fn build_challenges(
+pub async fn build_challenges(
     profile_name: &str,
     push: bool,
     extract_artifacts: bool,
 ) -> Result<Vec<(&ChallengeConfig, BuildResult)>> {
-    enabled_challenges(profile_name)?
-        .into_iter()
-        .map(|chal| build_challenge(profile_name, chal, push, extract_artifacts).map(|r| (chal, r)))
-        .collect::<Result<_>>()
+    try_join_all(
+        enabled_challenges(profile_name)?
+            .into_iter()
+            .map(|chal| async move {
+                build_challenge(profile_name, chal, push, extract_artifacts)
+                    .await
+                    .map(|r| (chal, r))
+            }),
+    )
+    .await
 }
 
 /// Build all images from given challenge, optionally pushing image or extracting artifacts
-fn build_challenge(
+async fn build_challenge(
     profile_name: &str,
     chal: &ChallengeConfig,
     push: bool,
@@ -73,27 +79,28 @@ fn build_challenge(
         assets: vec![],
     };
 
-    built.tags = chal
-        .pods
-        .iter()
-        .map(|p| match &p.image_source {
+    built.tags = try_join_all(chal.pods.iter().map(|p| async {
+        match &p.image_source {
             Image(tag) => Ok(TagWithSource::Upstream(tag.to_string())),
             // build any pods that need building
             Build(build) => {
                 let tag = chal.container_tag_for_pod(profile_name, &p.name)?;
 
-                let res = docker::build_image(&chal.directory, build, &tag).with_context(|| {
-                    format!(
-                        "error building image {} for chal {}",
-                        p.name,
-                        chal.directory.to_string_lossy()
-                    )
-                });
+                let res = docker::build_image(&chal.directory, build, &tag)
+                    .await
+                    .with_context(|| {
+                        format!(
+                            "error building image {} for chal {}",
+                            p.name,
+                            chal.directory.to_string_lossy()
+                        )
+                    });
                 // map result tag string into enum
                 res.map(TagWithSource::Built)
             }
-        })
-        .collect::<Result<_>>()?;
+        }
+    }))
+    .await?;
 
     if push {
         // only need to push tags we actually built
@@ -112,13 +119,12 @@ fn build_challenge(
             chal.directory
         );
 
-        tags_to_push
-            .iter()
-            .map(|tag| {
-                docker::push_image(tag, &config.registry.build)
-                    .with_context(|| format!("error pushing image {tag}"))
-            })
-            .collect::<Result<Vec<_>>>()?;
+        try_join_all(tags_to_push.iter().map(|tag| async move {
+            docker::push_image(tag, &config.registry.build)
+                .await
+                .with_context(|| format!("error pushing image {tag}"))
+        }))
+        .await?;
     }
 
     if extract_artifacts {

src/commands/build.rs

@@ -5,10 +5,11 @@ use std::process::exit;
 use crate::builder::build_challenges;
 use crate::configparser::{get_config, get_profile_config};
 
-pub fn run(profile_name: &str, push: &bool, extract: &bool) {
+#[tokio::main(flavor = "current_thread")] // make this a sync function
+pub async fn run(profile_name: &str, push: &bool, extract: &bool) {
     info!("building images...");
 
-    let results = match build_challenges(profile_name, *push, *extract) {
+    let results = match build_challenges(profile_name, *push, *extract).await {
         Ok(results) => results,
         Err(e) => {
             error!("{e:?}");

src/commands/deploy.rs

@@ -23,7 +23,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) {
+    let build_results = match build_challenges(profile_name, true, true).await {
         Ok(result) => result,
         Err(e) => {
             error!("{e:?}");