Method exec

lib-engine/src/helm.rs:646–783

(
        &self,
        kubernetes_config: &Path,
        envs: &[(&str, &str)],
        payload: Option<ChartPayload>,
        cmd_killer: &CommandKiller,
    )

    }

    fn exec(
        &self,
        kubernetes_config: &Path,
        envs: &[(&str, &str)],
        payload: Option<ChartPayload>,
        cmd_killer: &CommandKiller,
    ) -> Result<Option<ChartPayload>, HelmChartError> {
        let chart_info = self.get_chart_info();
        let helm = match &chart_info.helm_list_cache {
            Some(cache) => Helm::new_with_cache(Some(kubernetes_config), envs, cache.clone())?,
            None => Helm::new(Some(kubernetes_config), envs)?,
        };

        match chart_info.action {
            Deploy => {
                if let Err(e) = helm.uninstall_chart_if_breaking_version(chart_info, &[]) {
                    warn!(
                        "error while trying to destroy chart if breaking change is detected: {:?}",
                        e.to_string()
                    );
                }

                let installed_chart_version = match helm.get_chart_version(
                    &chart_info.name,
                    Some(chart_info.get_namespace_string().as_str()),
                    envs,
                ) {
                    Ok(versions) => match versions {
                        None => None,
                        Some(versions) => versions.chart_version,
                    },
                    Err(e) => {
                        warn!("error while trying to get installed version: {:?}", e);
                        None
                    }
                };

                // Allow to skip the deployment if the chart is already installed
                if chart_info.skip_if_already_installed && installed_chart_version.is_some() {
                    info!(
                        "chart {} is already installed and option to skip it if installed is set to true, skipping",
                        &chart_info.name
                    );
                    return Ok(payload);
                }

                let upgrade_status = prepare_chart_backup_on_upgrade(
                    kubernetes_config,
                    chart_info.clone(),
                    envs,
                    installed_chart_version,
                )
                .unwrap_or_else(|e| {
                    warn!("error while trying to prepare backup: {:?}", e);
                    BackupStatus {
                        is_backupable: false,
                        backup_path: PathBuf::new(),
                    }