split deploy components into separate files

detjensrobert · detjensrobert · commit a22b9e227678 · 2025-02-02T22:08:06.000-08:00
Signed-off-by: Robert Detjens &lt;github@detjens.dev&gt;
diff --git a/src/builder/mod.rs b/src/builder/mod.rs
@@ -33,10 +33,10 @@ pub(super) use image_tag_str;
 pub struct BuildResult {
     /// Container image tags of all containers in the challenge, if the challenge has container images.
     /// Will be empty if challenge has no images built from source.
-    tags: Vec<TagWithSource>,
+    pub tags: Vec<TagWithSource>,
     /// Path on disk to local assets (both built and static).
     /// Will be empty if challenge has no file assets
-    assets: Vec<PathBuf>,
+    pub assets: Vec<PathBuf>,
 }
 
 /// Tag string with added context of where it came from (built locally or an upstream image)
diff --git a/src/commands/deploy.rs b/src/commands/deploy.rs
@@ -1,25 +1,16 @@
-use anyhow::{anyhow, bail, Context, Error, Result};
-use itertools::Itertools;
-use k8s_openapi::api::core::v1::Secret;
-use kube::api::ListParams;
 use simplelog::*;
-use std::env::current_exe;
 use std::process::exit;
 
-use crate::clients::kube_client;
-use crate::cluster_setup;
-use crate::configparser::config::ProfileConfig;
-use crate::configparser::{get_config, get_profile_config};
-
 use crate::builder::build_challenges;
-use crate::deploy::{deploy_challenges, update_frontend, upload_assets};
+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) {
     let profile = get_profile_config(profile_name).unwrap();
 
     // has the cluster been setup?
-    if let Err(e) = check_setup(profile).await {
+    if let Err(e) = deploy::check_setup(profile).await {
         error!("{e:?}");
         exit(1);
     }
@@ -51,116 +42,22 @@ pub async fn run(profile_name: &str, no_build: &bool, _dry_run: &bool) {
 
     // A)
     info!("deploying challenges...");
-    if let Err(e) = deploy_challenges(profile_name, &build_results).await {
+    if let Err(e) = deploy::kubernetes::deploy_challenges(profile_name, &build_results).await {
         error!("{e:?}");
         exit(1);
     }
 
     // B)
     info!("deploying challenges...");
-    if let Err(e) = upload_assets(profile_name, &build_results).await {
+    if let Err(e) = deploy::s3::upload_assets(profile_name, &build_results).await {
         error!("{e:?}");
         exit(1);
     }
 
     // A)
     info!("deploying challenges...");
-    if let Err(e) = update_frontend(profile_name, &build_results).await {
+    if let Err(e) = deploy::frontend::update_frontend(profile_name, &build_results).await {
         error!("{e:?}");
         exit(1);
     }
 }
-
-/// check to make sure that the needed ingress charts are deployed and running
-async fn check_setup(profile: &ProfileConfig) -> Result<()> {
-    let kube = kube_client(profile).await?;
-    let secrets: kube::Api<Secret> = kube::Api::namespaced(kube, cluster_setup::INGRESS_NAMESPACE);
-
-    let all_releases = secrets
-        .list_metadata(&ListParams::default().labels("owner=helm"))
-        .await?;
-
-    // pull helm release version from secret label
-    macro_rules! helm_version {
-        ($s:ident) => {
-            $s.get("version")
-                .unwrap_or(&"".to_string())
-                .parse::<usize>()
-                .unwrap_or(0)
-        };
-    }
-    let expected_charts = ["ingress-nginx", "cert-manager", "external-dns"];
-    let latest_releases = expected_charts
-        .iter()
-        .map(|chart| {
-            // pick latest release
-            all_releases
-                .iter()
-                .map(|r| r.metadata.labels.as_ref().unwrap())
-                .filter(|rl| rl.get("name") == Some(&chart.to_string()))
-                .max_by(|a, b| helm_version!(a).cmp(&helm_version!(b)))
-        })
-        .collect_vec();
-
-    enum ChartFailure {
-        Missing(String),
-        DeploymentFailed(String),
-    }
-
-    // make sure all releases are present and deployed successfully
-    let missing = latest_releases
-        .iter()
-        .zip(expected_charts)
-        .filter_map(|(r, c)| {
-            // is label status=deployed ?
-            if r.is_none() {
-                return Some(ChartFailure::Missing(c.to_string()));
-            }
-
-            if r.unwrap().get("status") == Some(&"deployed".to_string()) {
-                // all is good
-                None
-            } else {
-                Some(ChartFailure::DeploymentFailed(c.to_string()))
-            }
-        })
-        .collect_vec();
-
-    if !missing.is_empty() {
-        // if any errors are present, collect/reduce them all into one error via
-        // anyhow context() calls.
-        //
-        // TODO: this should probably be returning Vec<Error> instead of a
-        // single Error chain. should this be in run() to present errors there
-        // instead of chaining and returning one combined Error here?
-        #[allow(clippy::manual_try_fold)] // need to build the Result ourselves
-        missing
-            .iter()
-            .fold(Err(anyhow!("")), |e, reason| match reason {
-                ChartFailure::Missing(c) => e.with_context(|| {
-                    format!(
-                        "chart {}/{c} is not deployed",
-                        cluster_setup::INGRESS_NAMESPACE
-                    )
-                }),
-                ChartFailure::DeploymentFailed(c) => e.with_context(|| {
-                    format!(
-                        "chart {}/{c} is in a failed state",
-                        cluster_setup::INGRESS_NAMESPACE
-                    )
-                }),
-            })
-            .with_context(|| {
-                format!(
-                    "cluster has not been set up with needed charts (run `{} cluster-setup`)",
-                    current_exe()
-                        .unwrap()
-                        .file_name()
-                        .unwrap_or_default()
-                        .to_string_lossy()
-                )
-            })
-    } else {
-        Ok(())
-    }
-}
diff --git a/src/deploy/frontend.rs b/src/deploy/frontend.rs
@@ -0,0 +1,20 @@
+use std::path::PathBuf;
+
+use anyhow::{anyhow, bail, Context, Error, Ok, Result};
+use itertools::Itertools;
+use simplelog::*;
+
+use crate::builder::BuildResult;
+use crate::configparser::config::ProfileConfig;
+use crate::configparser::{enabled_challenges, get_config, get_profile_config, ChallengeConfig};
+
+/// Sync deployed challenges with rCTF frontend
+pub async fn update_frontend(
+    profile_name: &str,
+    build_results: &[(&ChallengeConfig, BuildResult)],
+) -> Result<()> {
+    let profile = get_profile_config(profile_name)?;
+    let enabled_challenges = enabled_challenges(profile_name)?;
+
+    todo!()
+}
diff --git a/src/deploy/kubernetes.rs b/src/deploy/kubernetes.rs
@@ -0,0 +1,21 @@
+use std::path::PathBuf;
+
+use anyhow::{anyhow, bail, Context, Error, Ok, Result};
+use itertools::Itertools;
+use simplelog::*;
+
+use crate::builder::BuildResult;
+use crate::clients::kube_client;
+use crate::configparser::config::ProfileConfig;
+use crate::configparser::{enabled_challenges, get_config, get_profile_config, ChallengeConfig};
+
+/// Render challenge manifest templates and apply to cluster
+pub async fn deploy_challenges(
+    profile_name: &str,
+    build_results: &[(&ChallengeConfig, BuildResult)],
+) -> Result<()> {
+    let profile = get_profile_config(profile_name)?;
+    let enabled_challenges = enabled_challenges(profile_name)?;
+
+    todo!()
+}
diff --git a/src/deploy/mod.rs b/src/deploy/mod.rs
@@ -1,50 +1,108 @@
-use std::path::PathBuf;
+pub mod frontend;
+pub mod kubernetes;
+pub mod s3;
 
 use anyhow::{anyhow, bail, Context, Error, Result};
 use itertools::Itertools;
+use k8s_openapi::api::core::v1::Secret;
+use kube::api::ListParams;
 use simplelog::*;
+use std::env::current_exe;
 
-use crate::builder::BuildResult;
-use crate::clients::{bucket_client, kube_client};
-use crate::cluster_setup as setup;
+use crate::clients::kube_client;
+use crate::cluster_setup;
 use crate::configparser::config::ProfileConfig;
-use crate::configparser::{enabled_challenges, get_config, get_profile_config, ChallengeConfig};
 
-/// Render challenge manifest templates and apply to cluster
-pub async fn deploy_challenges(
-    profile_name: &str,
-    build_results: &[(&ChallengeConfig, BuildResult)],
-) -> Result<()> {
-    let profile = get_profile_config(profile_name)?;
-    let enabled_challenges = enabled_challenges(profile_name)?;
+/// check to make sure that the needed ingress charts are deployed and running
+pub async fn check_setup(profile: &ProfileConfig) -> Result<()> {
+    let kube = kube_client(profile).await?;
+    let secrets: kube::Api<Secret> = kube::Api::namespaced(kube, cluster_setup::INGRESS_NAMESPACE);
 
-    todo!()
-}
-
-/// Upload files to frontend asset bucket
-/// Returns urls of upload files.
-pub async fn upload_assets(
-    profile_name: &str,
-    build_results: &[(&ChallengeConfig, BuildResult)],
-) -> Result<Vec<String>> {
-    let profile = get_profile_config(profile_name)?;
-    let enabled_challenges = enabled_challenges(profile_name)?;
+    let all_releases = secrets
+        .list_metadata(&ListParams::default().labels("owner=helm"))
+        .await?;
 
-    let bucket = bucket_client(&profile.s3)?;
+    // pull helm release version from secret label
+    macro_rules! helm_version {
+        ($s:ident) => {
+            $s.get("version")
+                .unwrap_or(&"".to_string())
+                .parse::<usize>()
+                .unwrap_or(0)
+        };
+    }
+    let expected_charts = ["ingress-nginx", "cert-manager", "external-dns"];
+    let latest_releases = expected_charts
+        .iter()
+        .map(|chart| {
+            // pick latest release
+            all_releases
+                .iter()
+                .map(|r| r.metadata.labels.as_ref().unwrap())
+                .filter(|rl| rl.get("name") == Some(&chart.to_string()))
+                .max_by(|a, b| helm_version!(a).cmp(&helm_version!(b)))
+        })
+        .collect_vec();
 
-    todo!()
+    enum ChartFailure {
+        Missing(String),
+        DeploymentFailed(String),
+    }
 
-    // TODO: should uploaded URLs be a (generated) part of the challenge config
-    // struct?
-}
+    // make sure all releases are present and deployed successfully
+    let missing = latest_releases
+        .iter()
+        .zip(expected_charts)
+        .filter_map(|(r, c)| {
+            // is label status=deployed ?
+            if r.is_none() {
+                return Some(ChartFailure::Missing(c.to_string()));
+            }
 
-/// Sync deployed challenges with rCTF frontend
-pub async fn update_frontend(
-    profile_name: &str,
-    build_results: &[(&ChallengeConfig, BuildResult)],
-) -> Result<()> {
-    let profile = get_profile_config(profile_name)?;
-    let enabled_challenges = enabled_challenges(profile_name)?;
+            if r.unwrap().get("status") == Some(&"deployed".to_string()) {
+                // all is good
+                None
+            } else {
+                Some(ChartFailure::DeploymentFailed(c.to_string()))
+            }
+        })
+        .collect_vec();
 
-    todo!()
+    if !missing.is_empty() {
+        // if any errors are present, collect/reduce them all into one error via
+        // anyhow context() calls.
+        //
+        // TODO: this should probably be returning Vec<Error> instead of a
+        // single Error chain. should this be in run() to present errors there
+        // instead of chaining and returning one combined Error here?
+        #[allow(clippy::manual_try_fold)] // need to build the Result ourselves
+        missing
+            .iter()
+            .fold(Err(anyhow!("")), |e, reason| match reason {
+                ChartFailure::Missing(c) => e.with_context(|| {
+                    format!(
+                        "chart {}/{c} is not deployed",
+                        cluster_setup::INGRESS_NAMESPACE
+                    )
+                }),
+                ChartFailure::DeploymentFailed(c) => e.with_context(|| {
+                    format!(
+                        "chart {}/{c} is in a failed state",
+                        cluster_setup::INGRESS_NAMESPACE
+                    )
+                }),
+            })
+            .with_context(|| {
+                format!(
+                    "cluster has not been set up with needed charts (run `{} cluster-setup`)",
+                    current_exe()
+                        .unwrap()
+                        .file_name()
+                        .unwrap_or_default()
+                        .to_string_lossy()
+                )
+            })
+    } else {
+        Ok(())
+    }
 }
diff --git a/src/deploy/s3.rs b/src/deploy/s3.rs
@@ -0,0 +1,25 @@
+use std::fs::File;
+use std::path::PathBuf;
+
+use anyhow::{anyhow, bail, Context, Error, Ok, Result};
+use itertools::Itertools;
+use simplelog::*;
+
+use crate::builder::BuildResult;
+use crate::clients::bucket_client;
+use crate::configparser::config::ProfileConfig;
+use crate::configparser::{enabled_challenges, get_config, get_profile_config, ChallengeConfig};
+
+/// Upload files to frontend asset bucket
+/// Returns urls of upload files.
+pub async fn upload_assets(
+    profile_name: &str,
+    build_results: &[(&ChallengeConfig, BuildResult)],
+) -> Result<Vec<String>> {
+    let profile = get_profile_config(profile_name)?;
+    let enabled_challenges = enabled_challenges(profile_name)?;
+
+    let bucket = bucket_client(&profile.s3)?;
+
+    todo!();
+}
