feat: pinnable context names per profile

Author: juliamertz

src/cmd/deploy.rs

@@ -1,4 +1,4 @@
-use std::{path::Path, sync::Arc};
+use std::{collections::HashMap, path::Path, sync::Arc};
 
 use miette::Diagnostic;
 
@@ -17,11 +17,24 @@ pub enum InputError {
     Serde(#[from] serde_json::Error),
 }
 
+#[derive(Debug, Diagnostic, thiserror::Error)]
+pub enum ContextError {
+    #[error("attempted to deploy to the wrong cluster (expected `{expected}`, got `{actual}`)")]
+    Mismatch { expected: String, actual: String },
+    #[error("no active kubernetes context found")]
+    Missing,
+    #[error("failed to read kubeconfig")]
+    KubeConfig(#[from] kube::config::KubeconfigError),
+}
+
 #[derive(Debug, Diagnostic, thiserror::Error)]
 pub enum Error {
     #[error("failed to read input file")]
     #[diagnostic(transparent)]
     Input(#[from] InputError),
+    #[error("failed verify kubernetes context")]
+    #[diagnostic(transparent)]
+    Context(#[from] ContextError),
     #[error("failed to deploy")]
     #[diagnostic(transparent)]
     Deploy(#[from] DeployError),
@@ -35,7 +48,29 @@ async fn read_input(path: impl AsRef<Path>) -> Result<Output, InputError> {
     Ok(serde_json::from_slice(&content)?)
 }
 
-pub async fn run(config: Config, input_file: &Path) -> Result<(), Error> {
+async fn ensure_context<'a>(
+    profile: Option<&str>,
+    mappings: &'a HashMap<String, String>,
+) -> Result<Option<&'a str>, ContextError> {
+    let Some(expected) = profile.and_then(|profile| mappings.get(profile)) else {
+        return Ok(None);
+    };
+
+    let kubeconfig = kube::config::Kubeconfig::read()?;
+    let current_context = kubeconfig.current_context.ok_or(ContextError::Missing)?;
+    if current_context.ne(expected) {
+        return Err(ContextError::Mismatch {
+            expected: expected.to_string(),
+            actual: current_context.to_string(),
+        });
+    }
+
+    Ok(Some(expected.as_str()))
+}
+
+pub async fn run(profile: Option<&str>, config: Config, input_file: &Path) -> Result<(), Error> {
+    ensure_context(profile, &config.context_mappings).await?;
+
     let input = read_input(input_file).await?;
     let root = progress::tree();
     let handle = progress::setup_line_renderer(&root);

src/config.rs

@@ -26,6 +26,8 @@ pub struct Config {
     pub tag_format: String,
     #[serde(default)]
     pub use_monolithic_push: bool,
+    #[serde(default)]
+    pub context_mappings: HashMap<String, String>,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]

src/main.rs

@@ -162,7 +162,7 @@ async fn run(opts: Opts) -> Result<(), AppError> {
             input_file,
         } => {
             let config = config::load_from_path(profile.as_deref(), config_path).await?;
-            cmd::deploy::run(config, &input_file).await?;
+            cmd::deploy::run(profile.as_deref(), config, &input_file).await?;
         }
         Cmd::Run {
             profile,
@@ -186,7 +186,7 @@ async fn run(opts: Opts) -> Result<(), AppError> {
 
             dest.sync_all().await?;
 
-            cmd::deploy::run(config, dest.file_path()).await?;
+            cmd::deploy::run(profile.as_deref(), config, dest.file_path()).await?;
         }
     }