feat: Add uninstall demo/stack feature

Author: xeniape

Cargo.lock

@@ -28,8 +28,10 @@ clap = { version = "4.5", features = ["derive", "env"] }
 clap_complete = "4.5"
 clap_complete_nushell = "4.5"
 comfy-table = { version = "7.1", features = ["custom_styling"] }
+dialoguer = "0.12.0"
 directories = "5.0"
 dotenvy = "0.15"
+either = "1.15.0"
 futures = "0.3"
 indexmap = { version = "2.2", features = ["serde"] }
 indicatif = "0.18"

Cargo.toml

@@ -17,6 +17,7 @@ helm-sys = { path = "../helm-sys" }
 
 bcrypt.workspace = true
 clap.workspace = true
+either.workspace = true
 indexmap.workspace = true
 k8s-openapi.workspace = true
 kube.workspace = true

rust/stackable-cockpit/Cargo.toml

@@ -3,6 +3,8 @@ use stackable_operator::kvp::Labels;
 use crate::platform::operator::ChartSourceType;
 
 pub struct DemoInstallParameters {
+    pub demo_name: String,
+
     pub operator_namespace: String,
     pub demo_namespace: String,
 
@@ -14,3 +16,13 @@ pub struct DemoInstallParameters {
     pub labels: Labels,
     pub chart_source: ChartSourceType,
 }
+
+pub struct DemoUninstallParameters {
+    pub demo_name: String,
+
+    pub operator_namespace: String,
+    pub demo_namespace: String,
+
+    pub skip_operators: bool,
+    pub skip_crds: bool
+}

rust/stackable-cockpit/src/platform/demo/params.rs

@@ -1,3 +1,4 @@
+use kube::api::{ApiResource, GroupVersionKind};
 use serde::{Deserialize, Serialize};
 use snafu::{OptionExt, ResultExt, Snafu};
 use tracing::{Span, debug, info, instrument, warn};
@@ -9,13 +10,13 @@ use crate::{
     common::manifest::ManifestSpec,
     platform::{
         cluster::{ResourceRequests, ResourceRequestsError},
-        demo::DemoInstallParameters,
+        demo::{DemoInstallParameters, DemoUninstallParameters},
         manifests::{self, InstallManifestsExt},
         release::ReleaseList,
-        stack::{self, StackInstallParameters, StackList},
+        stack::{self, StackInstallParameters, StackList, StackSpec},
     },
     utils::{
-        k8s::Client,
+        k8s::{self, Client},
         params::{
             IntoParameters, IntoParametersError, Parameter, RawParameter, RawParameterParseError,
         },
@@ -47,8 +48,18 @@ pub enum Error {
     #[snafu(display("failed to install stack"))]
     InstallStack { source: stack::Error },
 
+    /// This error indicates that the release failed to uninstall.
+    #[snafu(display("failed to uninstall release"))]
+    UninstallRelease { source: stack::Error },
+
     #[snafu(display("failed to install stack manifests"))]
     InstallManifests { source: manifests::Error },
+
+    #[snafu(display("failed to uninstall Helm manifests"))]
+    UninstallHelmManifests { source: manifests::Error },
+
+    #[snafu(display("failed to delete object"))]
+    DeleteObject { source: k8s::Error },
 }
 
 impl InstallManifestsExt for DemoSpec {}
@@ -159,7 +170,6 @@ impl DemoSpec {
             labels: install_parameters.stack_labels.clone(),
             skip_release: install_parameters.skip_release,
             stack_name: self.stack.clone(),
-            demo_name: None,
             chart_source: install_parameters.chart_source.clone(),
         };
 
@@ -178,32 +188,133 @@ impl DemoSpec {
             .await
     }
 
+    #[instrument(skip_all, fields(
+        demo_name = %uninstall_parameters.demo_name,
+        demo_namespace = %uninstall_parameters.demo_namespace,
+        stack_name = %self.stack,
+    ))]
+    pub async fn uninstall(
+        &self,
+        release_list: ReleaseList,
+        uninstall_parameters: DemoUninstallParameters,
+        client: &Client,
+        transfer_client: &xfer::Client,
+        stack: StackSpec,
+    ) -> Result<(), Error> {
+        // Uninstall Helm Charts
+        let parameters = &mut Vec::new()
+            .into_params(self.parameters.clone())
+            .context(ParseParametersSnafu)?;
+
+        // We add the DEMO parameter, so that demos can use that to render e.g. the demo label
+        parameters.insert("DEMO".to_owned(), uninstall_parameters.demo_name.clone());
+
+        Self::uninstall_helm_manifests(
+            &self.manifests,
+            parameters,
+            &uninstall_parameters.demo_namespace.to_owned(),
+            transfer_client,
+        )
+        .await
+        .context(UninstallHelmManifestsSnafu)?;
+
+        let stack_parameters = &mut Vec::new()
+            .into_params(stack.parameters.clone())
+            .context(ParseParametersSnafu)?;
+
+        // We add the STACK parameter, so that stacks can use that to render e.g. the stack label
+        stack_parameters.insert("STACK".to_owned(), self.stack.clone());
+
+        Self::uninstall_helm_manifests(
+            &stack.manifests,
+            stack_parameters,
+            &uninstall_parameters.demo_namespace.to_owned(),
+            transfer_client,
+        )
+        .await
+        .context(UninstallHelmManifestsSnafu)?;
+
+        // Delete demo namespace
+        client
+            .delete_object(
+                &uninstall_parameters.demo_namespace,
+                &ApiResource::from_gvk(&GroupVersionKind {
+                    group: "".to_owned(),
+                    version: "v1".to_owned(),
+                    kind: "Namespace".to_owned(),
+                }),
+                None,
+            )
+            .await
+            .context(DeleteObjectSnafu)?;
+
+        // Delete remaining objects not namespace scoped
+        client
+            .delete_all_objects_with_label("stackable.tech/demo", &uninstall_parameters.demo_name, None)
+            .await
+            .context(DeleteObjectSnafu)?;
+
+        // Delete operators and the operator namespace
+        if !uninstall_parameters.skip_operators {
+            stack
+                .uninstall_release(release_list, &uninstall_parameters.operator_namespace)
+                .await
+                .context(UninstallReleaseSnafu)?;
+
+            client
+                .delete_object(
+                    &uninstall_parameters.operator_namespace,
+                    &ApiResource::from_gvk(&GroupVersionKind {
+                        group: "".to_owned(),
+                        version: "v1".to_owned(),
+                        kind: "Namespace".to_owned(),
+                    }),
+                    None,
+                )
+                .await
+                .context(DeleteObjectSnafu)?;
+        }
+
+        // Delete CRDs
+        if !uninstall_parameters.skip_crds {
+            client
+                .delete_crds_with_group_suffix("stackable.tech")
+                .await
+                .context(DeleteObjectSnafu)?;
+        }
+
+        Ok(())
+    }
+
     #[instrument(skip_all, fields(
         stack_name = %self.stack,
-        operator_namespace = %install_params.operator_namespace,
-        demo_namespace = %install_params.demo_namespace,
+        operator_namespace = %install_parameters.operator_namespace,
+        demo_namespace = %install_parameters.demo_namespace,
         indicatif.pb_show = true
     ))]
     async fn prepare_manifests(
         &self,
-        install_params: DemoInstallParameters,
+        install_parameters: DemoInstallParameters,
         client: &Client,
         transfer_client: &xfer::Client,
     ) -> Result<(), Error> {
         info!("Installing demo manifests");
         Span::current().pb_set_message("Installing manifests");
 
-        let params = install_params
+        let mut parameters = install_parameters
             .parameters
             .to_owned()
             .into_params(&self.parameters)
             .context(ParseParametersSnafu)?;
 
+        // We add the DEMO parameter, so that demos can use that to render e.g. the demo label
+        parameters.insert("DEMO".to_owned(), install_parameters.demo_name);
+
         Self::install_manifests(
             &self.manifests,
-            &params,
-            &install_params.demo_namespace,
-            install_params.labels,
+            &parameters,
+            &install_parameters.demo_namespace,
+            install_parameters.labels,
             client,
             transfer_client,
         )