xianyun_deploy/deployer/helm/

chartresolve.rs

//! Ported from `internal/deployer/helm/chartresolve.go`.

use std::path::Path;

use tracing::{debug, info, warn};

use xianyun_backends::helm::Backend as HelmBackend;

use super::HelmError;
use super::chartdeps::{chart_repo_name, dependencies_satisfied, locked_repositories};
use super::manager::Manager;

impl<B: HelmBackend> Manager<B> {
    /// Ported from `resolveChartDependencies`.
    pub(super) fn resolve_chart_dependencies(&self, chart_dir: &Path) -> Result<(), HelmError> {
        let list_output = self
            .backend
            .dependency_list(&chart_dir.display().to_string())
            .map_err(|e| HelmError::Backend {
                context: "listing chart dependencies".to_string(),
                source: e,
            })?;

        if dependencies_satisfied(&list_output) {
            debug!(chart = %chart_dir.display(), "chart dependencies already satisfied");
            return Ok(());
        }

        self.register_locked_repositories(chart_dir);

        info!(chart = %chart_dir.display(), "resolving chart dependencies");

        self.backend
            .dependency_build(&chart_dir.display().to_string(), true)
            .map_err(|e| HelmError::Backend {
                context: format!(
                    "chart {} (run `helm dependency update` there if Chart.lock is out of step \
                    with Chart.yaml, or `helm repo add` any private repository it needs)",
                    chart_dir.display()
                ),
                source: e,
            })
    }

    /// Ported from `registerLockedRepositories`.
    fn register_locked_repositories(&self, chart_dir: &Path) {
        let repos = match locked_repositories(chart_dir) {
            Ok(repos) => repos,
            Err(e) => {
                warn!(chart = %chart_dir.display(), error = %e, "could not read the chart's dependency lock");
                return;
            }
        };

        if repos.is_empty() {
            return;
        }

        let existing = match self.get_existing_helm_repos() {
            Ok(existing) => existing,
            Err(e) => {
                warn!(error = %e, "could not read the configured helm repositories");
                return;
            }
        };

        for repo_url in repos {
            if let Some(registered) = self.find_helm_repo_by_url(&existing, &repo_url) {
                // Already the user's, credentials and all, so it is
                // refreshed rather than re-added: the build reads the cached
                // index, and a stale one does not hold the version the lock
                // pins.
                if let Err(e) = self.backend.repo_update(&registered.name) {
                    warn!(
                        name = %registered.name, url = %repo_url, error = %e,
                        "could not refresh a chart dependency's repository"
                    );
                }

                continue;
            }

            let name = chart_repo_name(&repo_url);

            info!(name = %name, url = %repo_url, "registering a chart dependency's repository");

            // RepoAdd fetches the index as part of adding, so the build that
            // follows needs no refresh of its own.
            if let Err(e) = self.backend.repo_add(&name, &repo_url, true) {
                warn!(
                    name = %name, url = %repo_url, error = %e,
                    "could not register a chart dependency's repository"
                );
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use xianyun_executor::exec::ExecError;

    use super::super::chartdeps::chart_repo_name;
    use super::super::manager::Manager;
    use super::super::test_support::MockHelmBackend;

    const TEST_REPO_URL: &str = "https://charts.jetstack.io";

    const SATISFIED_LIST: &str =
        "NAME\tVERSION\tREPOSITORY\tSTATUS\ncert-manager\t1.16.2\thttps://charts.jetstack.io\tok\n";
    const UNSATISFIED_LIST: &str = "NAME\tVERSION\tREPOSITORY\tSTATUS\ncert-manager\t1.16.2\thttps://charts.jetstack.io\tmissing\n";

    fn lock_with_test_repo() -> tempfile::TempDir {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(
            dir.path().join("Chart.lock"),
            format!(
                "dependencies:\n- name: cert-manager\n  repository: {TEST_REPO_URL}\n  version: 1.16.2\ndigest: sha256:abc\n"
            ),
        )
        .unwrap();
        dir
    }

    fn err_repo_unreachable() -> ExecError {
        ExecError::RunFailed(
            "looks like the repository is not a valid chart repository".to_string(),
        )
    }

    fn err_lock_out_of_sync() -> ExecError {
        ExecError::RunFailed("the lock file (Chart.lock) is out of sync".to_string())
    }

    fn err_helm_missing() -> ExecError {
        ExecError::RunFailed("exec: helm: executable file not found".to_string())
    }

    // Ported from internal/deployer/helm/chartresolve_test.go
    #[test]
    // Ported from internal/deployer/helm/chartresolve_test.go:42 (TestResolveChartDependencies_SatisfiedChartIsLeftAlone)
    fn test_resolve_chart_dependencies_satisfied_chart_is_left_alone() {
        let dir = lock_with_test_repo();
        let dir_str = dir.path().display().to_string();

        // Only the probe is expected; any other call would be wasted work.
        let backend = MockHelmBackend::new().expect_dependency_list(move |chart_dir| {
            assert_eq!(chart_dir, dir_str);
            Ok(SATISFIED_LIST.to_string())
        });

        let mgr = Manager::new(backend);

        mgr.resolve_chart_dependencies(dir.path()).unwrap();
    }

    #[test]
    // Ported from internal/deployer/helm/chartresolve_test.go:56 (TestResolveChartDependencies_RegistersAnUnknownRepositoryThenBuilds)
    fn test_resolve_chart_dependencies_registers_an_unknown_repository_then_builds() {
        let dir = lock_with_test_repo();
        let want_name = chart_repo_name(TEST_REPO_URL);

        let backend = MockHelmBackend::new()
            .expect_dependency_list(|_| Ok(UNSATISFIED_LIST.to_string()))
            .expect_repo_list(|| Ok("[]".to_string()))
            .expect_repo_add(move |name, url, force_update| {
                assert_eq!(name, want_name);
                assert_eq!(url, TEST_REPO_URL);
                assert!(force_update);
                Ok(())
            })
            // --skip-refresh: RepoAdd has just fetched the index.
            .expect_dependency_build(|_, skip_refresh| {
                assert!(skip_refresh);
                Ok(())
            });

        let mgr = Manager::new(backend);

        mgr.resolve_chart_dependencies(dir.path()).unwrap();
    }

    #[test]
    // Ported from internal/deployer/helm/chartresolve_test.go:75 (TestResolveChartDependencies_RefreshesAnAlreadyRegisteredRepository)
    fn test_resolve_chart_dependencies_refreshes_an_already_registered_repository() {
        let dir = lock_with_test_repo();

        // Registered under the user's own name, possibly with credentials, so
        // it is not re-added. Its index is refreshed instead.
        let backend = MockHelmBackend::new()
            .expect_dependency_list(|_| Ok(UNSATISFIED_LIST.to_string()))
            .expect_repo_list(|| {
                Ok(r#"[{"name":"jetstack","url":"https://charts.jetstack.io/"}]"#.to_string())
            })
            .expect_repo_update(|name| {
                assert_eq!(name, "jetstack");
                Ok(())
            })
            .expect_dependency_build(|_, _| Ok(()));

        let mgr = Manager::new(backend);

        mgr.resolve_chart_dependencies(dir.path()).unwrap();
    }

    #[test]
    // Ported from internal/deployer/helm/chartresolve_test.go:95 (TestResolveChartDependencies_PreparationFailuresStillReachTheBuild)
    fn test_resolve_chart_dependencies_preparation_failures_still_reach_the_build() {
        // Everything before the build is advisory: it makes a repository
        // usable, and helm reports what is actually wrong with the chart
        // better than a guess here would.

        // a repository that cannot be registered
        {
            let dir = lock_with_test_repo();
            let backend = MockHelmBackend::new()
                .expect_dependency_list(|_| Ok(UNSATISFIED_LIST.to_string()))
                .expect_repo_list(|| Ok("[]".to_string()))
                .expect_repo_add(|_, _, _| Err(err_repo_unreachable()))
                .expect_dependency_build(|_, _| Ok(()));
            Manager::new(backend)
                .resolve_chart_dependencies(dir.path())
                .unwrap();
        }

        // a repository whose index cannot be refreshed
        {
            let dir = lock_with_test_repo();
            let backend = MockHelmBackend::new()
                .expect_dependency_list(|_| Ok(UNSATISFIED_LIST.to_string()))
                .expect_repo_list(|| {
                    Ok(r#"[{"name":"jetstack","url":"https://charts.jetstack.io"}]"#.to_string())
                })
                .expect_repo_update(|_| Err(err_repo_unreachable()))
                .expect_dependency_build(|_, _| Ok(()));
            Manager::new(backend)
                .resolve_chart_dependencies(dir.path())
                .unwrap();
        }

        // a repository list that cannot be parsed
        {
            let dir = lock_with_test_repo();
            let backend = MockHelmBackend::new()
                .expect_dependency_list(|_| Ok(UNSATISFIED_LIST.to_string()))
                .expect_repo_list(|| Ok("not json".to_string()))
                .expect_dependency_build(|_, _| Ok(()));
            Manager::new(backend)
                .resolve_chart_dependencies(dir.path())
                .unwrap();
        }

        // a lock that cannot be read
        {
            let dir = lock_with_test_repo();
            std::fs::write(dir.path().join("Chart.lock"), "dependencies: [oh dear\n").unwrap();
            let backend = MockHelmBackend::new()
                .expect_dependency_list(|_| Ok(UNSATISFIED_LIST.to_string()))
                .expect_dependency_build(|_, _| Ok(()));
            Manager::new(backend)
                .resolve_chart_dependencies(dir.path())
                .unwrap();
        }
    }

    #[test]
    // Ported from internal/deployer/helm/chartresolve_test.go:156 (TestResolveChartDependencies_ReportsAFailedBuild)
    fn test_resolve_chart_dependencies_reports_a_failed_build() {
        let dir = lock_with_test_repo();

        // No fallback: an out-of-step lock is the user's to resolve, and the
        // error says so, because helm's own message only reaches them under
        // --debug.
        let backend = MockHelmBackend::new()
            .expect_dependency_list(|_| Ok(UNSATISFIED_LIST.to_string()))
            .expect_repo_list(|| Ok("[]".to_string()))
            .expect_repo_add(|_, _, _| Ok(()))
            .expect_dependency_build(|_, _| Err(err_lock_out_of_sync()));

        let err = Manager::new(backend)
            .resolve_chart_dependencies(dir.path())
            .unwrap_err();

        let message = err.to_string();
        assert!(message.contains("the lock file (Chart.lock) is out of sync"));
        assert!(message.contains("helm dependency update"));
    }

    #[test]
    // Ported from internal/deployer/helm/chartresolve_test.go:175 (TestResolveChartDependencies_ReportsAFailedProbe)
    fn test_resolve_chart_dependencies_reports_a_failed_probe() {
        let dir = lock_with_test_repo();

        let backend = MockHelmBackend::new().expect_dependency_list(|_| Err(err_helm_missing()));

        let err = Manager::new(backend)
            .resolve_chart_dependencies(dir.path())
            .unwrap_err();

        assert!(
            err.to_string()
                .contains("exec: helm: executable file not found")
        );
    }

    #[test]
    // Ported from internal/deployer/helm/chartresolve_test.go:188 (TestResolveChartDependencies_RegistersEveryRepositoryTheLockNames)
    fn test_resolve_chart_dependencies_registers_every_repository_the_lock_names() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(
            dir.path().join("Chart.lock"),
            "dependencies:\n\
            - name: cert-manager\n  repository: https://charts.jetstack.io\n  version: 1.16.2\n\
            - name: prometheus\n  repository: https://prometheus-community.github.io/helm-charts\n  version: 25.8.0\n\
            - name: in-tree\n  repository: \"\"\n  version: 1.0.0\n",
        )
        .unwrap();

        let added = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
        let added_1 = added.clone();
        let added_2 = added.clone();

        let backend = MockHelmBackend::new()
            .expect_dependency_list(|_| Ok(UNSATISFIED_LIST.to_string()))
            .expect_repo_list(|| Ok("[]".to_string()))
            .expect_repo_add(move |_, url, _| {
                added_1.lock().unwrap().push(url.to_string());
                Ok(())
            })
            .expect_repo_add(move |_, url, _| {
                added_2.lock().unwrap().push(url.to_string());
                Ok(())
            })
            .expect_dependency_build(|_, _| Ok(()));

        Manager::new(backend)
            .resolve_chart_dependencies(dir.path())
            .unwrap();

        assert_eq!(
            *added.lock().unwrap(),
            vec![
                "https://charts.jetstack.io".to_string(),
                "https://prometheus-community.github.io/helm-charts".to_string(),
            ]
        );
    }
}