xianyun_cli/commands/

deploy.rs

//! `caproni deploy`: deploy or update Helm charts to the cluster.
//!
//! Port of Go's `cmd/deploy` package.

use std::sync::Arc;

use anyhow::Context as _;
use clap::Args;
use xianyun_cluster::clusterdomain;
use xianyun_cluster::driver::{Driver, State};
use xianyun_core::config::caproni::load_from_context;
use xianyun_core::config::global::Context;
use xianyun_core::config::latest::CaproniConfig;
use xianyun_deploy::deploy::orchestrator::{DeployerFilterFunc, Orchestrator};
use xianyun_executor::exec::CommandRunner;

#[derive(Args, Debug)]
pub struct DeployArgs {
    /// Deploy only the specified deployer (must match a key under
    /// deployers: in caproni.yaml).
    #[arg(long = "repo")]
    pub repo: Option<String>,

    /// Update repositories before deploying (pull latest changes for
    /// deployer-referenced repos).
    #[arg(long = "update")]
    pub update: bool,
}

pub fn run(args: &DeployArgs, ctx: &Context) -> anyhow::Result<()> {
    run_deploy(
        ctx,
        args.repo.as_deref(),
        args.update,
        crate::commands::up::connect_kubectl,
    )
}

/// Port of `deploy.ErrClusterNotReady`'s call site: `deploy::
/// verify_cluster_ready` has no port in `xianyun-deploy` yet (it isn't
/// among the four crates this task's dispatch scoped for
/// sibling-crate checks), so it's ported here directly — it's a
/// three-line status check, not a meaningful chunk of missing
/// functionality to leave stubbed.
#[derive(Debug, thiserror::Error)]
pub enum DeployError {
    #[error("cluster is not ready (state: {0:?}). Run 'caproni up' first")]
    ClusterNotReady(Option<State>),
    #[error("one or more repository updates failed")]
    RepositoryUpdatesFailed,
}

/// Port of `deploy.VerifyClusterReady`.
///
/// Returns `anyhow::Error` (not `DeployError`) so a failure of
/// `mgr.status()` itself keeps the underlying `DriverError`'s identity
/// for `downcast_ref`-style checks; only the "wrong state" case is a
/// `DeployError::ClusterNotReady`.
fn verify_cluster_ready(mgr: &dyn Driver) -> anyhow::Result<()> {
    let status = mgr.status().context("checking cluster status")?;

    if status.state != Some(State::Ready) {
        anyhow::bail!(DeployError::ClusterNotReady(status.state));
    }

    tracing::info!(state = ?status.state, driver = mgr.name(), "cluster verified");

    Ok(())
}

/// Port of `deploy.runDeploy`: loads the configuration, verifies the
/// cluster is ready, resolves its DNS domain, optionally updates
/// repositories, then deploys the (optionally filtered) declared
/// deployers.
///
/// # Errors
///
/// Returns an error if configuration loading, verifying the cluster is
/// ready, getting its kubeconfig, resolving its DNS domain, or deploying
/// fails. Repository-update failures are logged and reported via
/// [`DeployError::RepositoryUpdatesFailed`] but do not abort deployment
/// (matching Go's `slog.Warn`-then-continue).
pub fn run_deploy(
    ctx: &Context,
    repo_filter: Option<&str>,
    update: bool,
    connect: clusterdomain::resolve::Connector,
) -> anyhow::Result<()> {
    crate::drivers::ensure_registered();

    let mut container = load_from_context(ctx).context("loading configuration")?;

    let deployer_filter: Option<Box<DeployerFilterFunc<'_>>> = repo_filter.map(|repo| {
        tracing::info!(deployer = repo, "deploying single deployer");
        Box::new(move |name: &str| name == repo) as Box<DeployerFilterFunc<'_>>
    });

    let manager = xianyun_cluster::registry::new_manager(
        container.caproni.cluster.clone(),
        container.global.profile_name.clone(),
    )
    .context("creating cluster manager")?;

    verify_cluster_ready(manager.as_ref()).context("verifying cluster ready")?;

    let kubeconfig = manager.get_kubeconfig().context("getting kubeconfig")?;

    let reader = connect(manager.as_ref()).context("connecting to cluster DNS")?;

    let mut container = clusterdomain::resolve::resolve_and_reload(
        &mut container,
        Some(manager.as_ref()),
        reader.as_ref(),
    )
    .context("resolving cluster DNS domain")?;

    if update {
        tracing::info!("updating repositories");

        if let Err(e) = update_repositories_for_deploy(&container, deployer_filter.as_deref()) {
            tracing::warn!(error = %e, "repository update encountered errors");
        }
    }

    tracing::info!("deploying charts");

    let orch = Orchestrator::new();
    orch.deploy_all(&container, deployer_filter.as_deref(), &kubeconfig)
        .context("deploying charts")?;

    tracing::info!("all deployments complete");

    let _ = &mut container;

    Ok(())
}

/// Port of `deploy.updateRepositoriesForDeploy`: updates repositories
/// referenced by deployers being deployed. Returns an error if any
/// repository update fails, but this should not abort deployment (the
/// caller logs and continues).
fn update_repositories_for_deploy(
    container: &xianyun_core::config::container::Container,
    deployer_filter: Option<&DeployerFilterFunc<'_>>,
) -> Result<(), DeployError> {
    let executor: Arc<dyn CommandRunner + Send + Sync> =
        Arc::new(xianyun_executor::exec::Client::new());
    let git_backend = Arc::new(xianyun_backends::git::Client::new(executor.clone()));

    let repo_filter = build_repo_filter_for_deployers(&container.caproni, deployer_filter);

    let updater = xianyun_update::updater::Updater::new(
        git_backend,
        xianyun_update::updater::UpdateOptions {
            strategy: xianyun_update::updater::UpdateStrategy::FullUpdate,
            filter: Some(repo_filter),
            ..Default::default()
        },
    );

    let (results, success) = updater.update_repositories(executor.as_ref(), container);

    for result in &results {
        match result.status {
            xianyun_update::updater::UpdateStatus::Failed => {
                tracing::warn!(
                    repo = %result.repo_name,
                    error = ?result.error,
                    "repository update failed"
                );
            }
            xianyun_update::updater::UpdateStatus::Updated => {
                tracing::info!(repo = %result.repo_name, notes = %result.notes, "repository updated");
            }
            _ => {}
        }
    }

    if !success {
        return Err(DeployError::RepositoryUpdatesFailed);
    }

    Ok(())
}

/// Port of `deploy.buildRepoFilterForDeployers`: creates a repo filter
/// that includes only repos referenced by deployers matching the
/// deployer filter.
fn build_repo_filter_for_deployers(
    caproni_cfg: &CaproniConfig,
    deployer_filter: Option<&DeployerFilterFunc<'_>>,
) -> xianyun_update::updater::RepoFilterFn {
    // Materialized eagerly (rather than captured by the returned
    // closure) so the closure only owns a plain `HashSet<String>`,
    // trivially `Send + Sync` — unlike `deployer_filter`'s `&dyn Fn`,
    // which `RepoFilterFn`'s `Send + Sync` bound rejects.
    let mut required_repos = std::collections::HashSet::new();

    if let Some(deployers) = &caproni_cfg.deployers {
        for (name, deployer_config) in deployers.iter() {
            if let Some(filter) = deployer_filter
                && !filter(name)
            {
                continue;
            }

            if let Some(repository) = &deployer_config.repository {
                required_repos.insert(repository.clone());
            }
        }
    }

    Box::new(move |repo_name: &str| required_repos.contains(repo_name))
}