helm idempotent installs

Author: xeniape

rust/helm-sys/go-helm-wrapper/main.go

@@ -58,6 +58,30 @@ func go_install_helm_release(releaseName *C.char, chartName *C.char, chartVersio
 	return C.CString("")
 }
 
+//export go_upgrade_or_install_helm_release
+func go_upgrade_or_install_helm_release(releaseName *C.char, chartName *C.char, chartVersion *C.char, valuesYaml *C.char, namespace *C.char, suppressOutput bool) *C.char {
+	helmClient := getHelmClient(namespace, suppressOutput)
+
+	timeout, _ := time.ParseDuration("20m")
+	chartSpec := gohelm.ChartSpec{
+		ReleaseName: C.GoString(releaseName),
+		ChartName:   C.GoString(chartName),
+		Version:     C.GoString(chartVersion),
+		ValuesYaml:  C.GoString(valuesYaml),
+		Namespace:   C.GoString(namespace),
+		UpgradeCRDs: true,
+		Wait:        true,
+		Timeout:     timeout,
+		Force:       true,
+	}
+
+	if _, err := helmClient.InstallOrUpgradeChart(context.Background(), &chartSpec, nil); err != nil {
+		return C.CString(fmt.Sprintf("%s%s", HELM_ERROR_PREFIX, err))
+	}
+
+	return C.CString("")
+}
+
 //export go_uninstall_helm_release
 func go_uninstall_helm_release(releaseName *C.char, namespace *C.char, suppressOutput bool) *C.char {
 	helmClient := getHelmClient(namespace, suppressOutput)

rust/helm-sys/src/lib.rs

@@ -37,6 +37,34 @@ pub fn install_helm_release(
     }
 }
 
+pub fn upgrade_or_install_helm_release(
+    release_name: &str,
+    chart_name: &str,
+    chart_version: &str,
+    values_yaml: &str,
+    namespace: &str,
+    suppress_output: bool,
+) -> String {
+    let release_name = CString::new(release_name).unwrap();
+    let chart_name = CString::new(chart_name).unwrap();
+    let chart_version = CString::new(chart_version).unwrap();
+    let values_yaml = CString::new(values_yaml).unwrap();
+    let namespace = CString::new(namespace).unwrap();
+
+    unsafe {
+        let c = go_upgrade_or_install_helm_release(
+            release_name.as_ptr() as *mut c_char,
+            chart_name.as_ptr() as *mut c_char,
+            chart_version.as_ptr() as *mut c_char,
+            values_yaml.as_ptr() as *mut c_char,
+            namespace.as_ptr() as *mut c_char,
+            suppress_output as u8,
+        );
+
+        cstr_ptr_to_string(c)
+    }
+}
+
 pub fn uninstall_helm_release(
     release_name: &str,
     namespace: &str,

rust/stackable-cockpit/src/helm.rs

@@ -61,6 +61,9 @@ pub enum Error {
     #[snafu(display("failed to install Helm release"))]
     InstallRelease { source: InstallReleaseError },
 
+    #[snafu(display("failed to upgrade/install Helm release"))]
+    UpgradeRelease { source: InstallReleaseError },
+
     #[snafu(display("failed to uninstall Helm release ({error})"))]
     UninstallRelease { error: String },
 }
@@ -248,6 +251,78 @@ pub fn install_release_from_repo_or_registry(
     })
 }
 
+/// Upgrades a Helm release from a repo or registry.
+///
+/// This function expects the fully qualified Helm release name. In case of our
+/// operators this is: `<PRODUCT_NAME>-operator`.
+#[instrument(skip(values_yaml), fields(with_values = values_yaml.is_some(), indicatif.pb_show = true))]
+pub fn upgrade_or_install_release_from_repo_or_registry(
+    release_name: &str,
+    ChartVersion {
+        chart_source,
+        chart_name,
+        chart_version,
+    }: ChartVersion,
+    values_yaml: Option<&str>,
+    namespace: &str,
+    suppress_output: bool,
+) -> Result<InstallReleaseStatus, Error> {
+    // Ideally, each Helm invocation would spawn_blocking instead in/around helm_sys,
+    // but that requires a larger refactoring
+    block_in_place(|| {
+        debug!("Install/Upgrade Helm release from repo");
+        Span::current()
+            .pb_set_message(format!("Installing/Upgrading {chart_name} Helm chart").as_str());
+
+        if check_release_exists(release_name, namespace)? {
+            let release = get_release(release_name, namespace)?.ok_or(Error::InstallRelease {
+                source: InstallReleaseError::NoSuchRelease {
+                    name: release_name.to_owned(),
+                },
+            })?;
+
+            let current_version = release.version;
+
+            match chart_version {
+                Some(chart_version) => {
+                    if chart_version == current_version {
+                        return Ok(InstallReleaseStatus::ReleaseAlreadyInstalledWithVersion {
+                            requested_version: chart_version.to_string(),
+                            release_name: release_name.to_string(),
+                            current_version,
+                        });
+                    }
+                }
+                None => {
+                    return Ok(InstallReleaseStatus::ReleaseAlreadyInstalledUnspecified {
+                        release_name: release_name.to_string(),
+                        current_version,
+                    });
+                }
+            }
+        }
+
+        let full_chart_name = format!("{chart_source}/{chart_name}");
+        let chart_version = chart_version.unwrap_or(HELM_DEFAULT_CHART_VERSION);
+
+        debug!(
+            release_name,
+            chart_version, full_chart_name, "Installing Helm release"
+        );
+
+        upgrade_release(
+            release_name,
+            &full_chart_name,
+            chart_version,
+            values_yaml,
+            namespace,
+            suppress_output,
+        )?;
+
+        Ok(InstallReleaseStatus::Installed(release_name.to_string()))
+    })
+}
+
 /// Installs a Helm release.
 ///
 /// This function expects the fully qualified Helm release name. In case of our
@@ -281,6 +356,43 @@ fn install_release(
     Ok(())
 }
 
+/// Upgrades a Helm release.
+/// If a release with the specified `chart_name` does not already exist,
+/// this function installs it instead.
+///
+/// This function expects the fully qualified Helm release name. In case of our
+/// operators this is: `<PRODUCT_NAME>-operator`.
+#[instrument(fields(with_values = values_yaml.is_some()))]
+fn upgrade_release(
+    release_name: &str,
+    chart_name: &str,
+    chart_version: &str,
+    values_yaml: Option<&str>,
+    namespace: &str,
+    suppress_output: bool,
+) -> Result<(), Error> {
+    let result = helm_sys::upgrade_or_install_helm_release(
+        release_name,
+        chart_name,
+        chart_version,
+        values_yaml.unwrap_or(""),
+        namespace,
+        suppress_output,
+    );
+
+    if let Some(error) = helm_sys::to_helm_error(&result) {
+        error!(
+            "Go wrapper function go_upgrade_or_install_helm_release encountered an error: {error}"
+        );
+
+        return Err(Error::UpgradeRelease {
+            source: InstallReleaseError::HelmWrapper { error },
+        });
+    }
+
+    Ok(())
+}
+
 /// Uninstall a Helm release.
 ///
 /// This function expects the fully qualified Helm release name. In case of our

rust/stackable-cockpit/src/platform/manifests.rs

@@ -116,7 +116,7 @@ pub trait InstallManifestsExt {
                         .context(SerializeOptionsSnafu)?;
 
                     // Install the Helm chart using the Helm wrapper
-                    helm::install_release_from_repo_or_registry(
+                    helm::upgrade_or_install_release_from_repo_or_registry(
                         &helm_chart.release_name,
                         helm::ChartVersion {
                             chart_source: &helm_chart.repo.name,