xianyun_cli/commands/

up.rs

//! `caproni up` (alias `start`): start the cluster and deploy all deployers.
//!
//! Port of Go's `cmd/up` package.

use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;

use anyhow::Context as _;
use clap::Args;
use xianyun_backends::kubectl;
use xianyun_cluster::driver::{DnsReader, Driver, DriverError};
use xianyun_core::config::caproni::load_from_context;
use xianyun_core::config::container::Container;
use xianyun_core::config::global::Context;
use xianyun_core::config::latest::CaproniConfig;
use xianyun_core::config::types::ClusterConfig;
use xianyun_executor::exec::CommandRunner;

#[derive(Args, Debug)]
pub struct UpArgs {}

pub fn run(_args: &UpArgs, ctx: &Context) -> anyhow::Result<()> {
    run_start(ctx, &default_kubectl_factory)
}

/// Port of `up.clusterAPIReadyTimeout`: how long `run_start` waits for the
/// cluster API to answer after the driver reports the cluster started.
const CLUSTER_API_READY_TIMEOUT: Duration = Duration::from_secs(180);
/// Port of `up.clusterAPIReadyInterval`.
const CLUSTER_API_READY_INTERVAL: Duration = Duration::from_secs(2);

/// Port of Go's `kubectlFactory`: builds a kubectl backend once the
/// cluster has been started and its kubeconfig is available. Tests inject
/// a factory that returns a fake backend without touching the cluster.
pub type KubectlFactory = dyn Fn(&dyn Driver) -> anyhow::Result<Box<dyn kubectl::Backend>>;

/// Port of `up.defaultKubectlFactory`: fetches the kubeconfig from the
/// cluster and builds a real kubectl client bound to it.
fn default_kubectl_factory(mgr: &dyn Driver) -> anyhow::Result<Box<dyn kubectl::Backend>> {
    let kubeconfig = mgr.get_kubeconfig().context("getting kubeconfig")?;
    let executor: Arc<dyn CommandRunner + Send + Sync> =
        Arc::new(xianyun_executor::exec::Client::new());
    Ok(Box::new(kubectl::Client::with_config(
        executor,
        &kubeconfig,
    )))
}

/// Adapts a [`kubectl::Backend`] to [`DnsReader`] so `clusterdomain::resolve`
/// (which only needs `get`/`get_raw`/`run_job`) can read cluster DNS state
/// through it, mapping `KubectlError` into `DriverError::Other` the same
/// way every other driver in this workspace surfaces backend failures.
///
/// `pub(crate)` (not private): `commands::ca` reuses this and
/// [`connect_kubectl`] as the `Connector` its `clusterdomain::
/// resolve_running` call needs, mirroring Go's `clusterdomain.
/// ConnectKubectl` being shared across `cmd/up` and `cmd/ca`.
pub(crate) struct KubectlDnsReader {
    backend: Box<dyn kubectl::Backend>,
}

/// Port of `clusterdomain.ConnectKubectl`: opens a kubectl-backed
/// [`DnsReader`] on a cluster that is known to be running, matching
/// [`Connector`](xianyun_cluster::clusterdomain::resolve::Connector)'s
/// signature.
pub(crate) fn connect_kubectl(
    mgr: &dyn Driver,
) -> Result<Box<dyn DnsReader>, xianyun_cluster::clusterdomain::resolve::ResolveError> {
    let backend = default_kubectl_factory(mgr).map_err(|e| {
        xianyun_cluster::clusterdomain::resolve::ResolveError::Driver(DriverError::Other(
            e.to_string(),
        ))
    })?;
    Ok(Box::new(KubectlDnsReader { backend }))
}

impl DnsReader for KubectlDnsReader {
    fn get(&self, resource_type: &str, name: &str, namespace: &str) -> Result<String, DriverError> {
        self.backend
            .get(resource_type, name, namespace)
            .map_err(|e| DriverError::Other(e.to_string()))
    }

    fn get_raw(&self, path: &str) -> Result<String, DriverError> {
        self.backend
            .get_raw(path)
            .map_err(|e| DriverError::Other(e.to_string()))
    }

    fn run_job(
        &self,
        image: &str,
        namespace: &str,
        timeout: Duration,
        command: &[&str],
    ) -> Result<String, DriverError> {
        self.backend
            .run_job(image, namespace, timeout, command)
            .map_err(|e| DriverError::Other(e.to_string()))
    }
}

/// Port of `up.runStart`: loads the configuration, ensures the managed
/// registry mirror (if configured), starts the cluster, resolves its DNS
/// domain, clones repositories needed by edit-mode deployers/reloaders,
/// prepares the dev CA, runs `edit_mode_prepare` hooks, then deploys every
/// declared deployer.
///
/// # Errors
///
/// Returns an error if configuration loading, the managed registry,
/// starting the cluster, getting its status/kubeconfig, resolving its DNS
/// domain, cloning repositories, preparing the dev CA, running prepare
/// hooks, or deploying fails.
///
/// /etc/hosts validation (Go's non-blocking `validateAndWarnHosts`) is not
/// ported: `xianyun_backends::hosts` is still an unimplemented stub in
/// this worktree. See `PORT_NOTES.md`.
pub fn run_start(ctx: &Context, new_kubectl: &KubectlFactory) -> anyhow::Result<()> {
    crate::drivers::ensure_registered();

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

    tracing::info!(
        driver = %container.caproni.cluster.driver,
        "configuration loaded successfully"
    );

    ensure_managed_registry(&mut container)?;

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

    tracing::info!(driver = %container.caproni.cluster.driver, "starting cluster");

    manager.start().context("starting cluster")?;

    tracing::info!("cluster started successfully");

    let status = manager.status().context("getting cluster status")?;

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

    let kubectl_backend = new_kubectl(manager.as_ref()).context("creating kubectl backend")?;

    let kversion = kubectl_backend
        .get_version(CLUSTER_API_READY_TIMEOUT, CLUSTER_API_READY_INTERVAL)
        .context("getting kubectl version")?;

    tracing::info!(
        tag = %kversion.server_version.git_version,
        "cluster version"
    );

    let reader = KubectlDnsReader {
        backend: kubectl_backend,
    };

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

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

    clone_repos(&container)?;

    // Reload config now that repos are cloned so caproni-project.yaml files
    // inside the freshly cloned repos are picked up.
    let ctx =
        xianyun_core::config::global::with_context(Context::default(), container.global.clone());
    let mut container = load_from_context(&ctx).context("reloading configuration after clone")?;

    // After the reload, so the resolved cluster domain is in the CA constraints.
    ensure_dev_ca(&container.global.profile_name, &container.caproni)
        .context("preparing dev CA")?;

    run_prepare_hooks(&container)?;

    let orch = xianyun_deploy::deploy::orchestrator::Orchestrator::new();
    orch.deploy_all(&container, None, &kubeconfig)
        .context("deploying all deployers")?;

    // Config is loaded through `load_from_context` again on the next
    // command invocation; nothing further needs `container` mutably, but
    // keep the binding so a future caller extending this function has it
    // in scope without re-loading.
    let _ = &mut container;

    tracing::info!("caproni cluster is ready");

    Ok(())
}

/// Port of `up.ensureManagedRegistry`: resolves the registry mirror
/// endpoint for the managed case. See the Go doc comment for the full
/// semantics (bring-your-own mirrors are left untouched; a managed mirror
/// with no upstreams, or a failure to start zot, disables the mirror).
#[allow(clippy::unnecessary_wraps)] // kept `Result` for symmetry with Go's ensureManagedRegistry
pub fn ensure_managed_registry(container: &mut Container) -> anyhow::Result<()> {
    let Some(mirror) = container.caproni.cluster.registry_mirror.clone() else {
        return Ok(());
    };

    if !mirror.managed {
        return Ok(());
    }

    if mirror.upstreams.is_empty() {
        container.caproni.cluster.registry_mirror = None;
        return Ok(());
    }

    match xianyun_deploy::registrycache::ensure(&container.global.profile_name, &mirror.upstreams) {
        Ok(endpoint) => {
            let host = node_mirror_host(&container.caproni.cluster.driver);
            let mut mirror = mirror;
            mirror.endpoint = format!("http://{}", endpoint.host_port(host));
            container.caproni.cluster.registry_mirror = Some(mirror);
        }
        Err(e) => {
            tracing::warn!(
                error = %e,
                hint = "image pulls will go directly to upstream; check `caproni registry status` and ~/.local/share/caproni/registry/zot.log",
                "registry cache could not be started; continuing without it"
            );
            container.caproni.cluster.registry_mirror = None;
        }
    }

    Ok(())
}

/// Port of `up.nodeMirrorHost`: the hostname cluster nodes use to reach
/// the host machine where the managed zot cache listens.
#[must_use]
pub fn node_mirror_host(driver: &str) -> &'static str {
    const COLIMA_HOST: &str = "host.docker.internal";
    const K3D_HOST: &str = "host.k3d.internal";

    match driver {
        "k3d" => K3D_HOST,
        "auto" => {
            if std::env::consts::OS == "linux" {
                K3D_HOST
            } else {
                COLIMA_HOST
            }
        }
        _ => COLIMA_HOST,
    }
}

/// Port of `up.ensureDevCA`: generates (or loads) caproni's per-profile
/// dev CA so it exists on disk before the deployer orchestrator runs.
pub fn ensure_dev_ca(profile_name: &str, caproni_cfg: &CaproniConfig) -> anyhow::Result<()> {
    let pki_dir = pki_dir_for_profile(profile_name).context("resolving PKI directory")?;

    let permitted_dns = permitted_dns_for_cluster(&caproni_cfg.cluster, profile_name);

    let (ca, previous) = xianyun_pki::ca::ensure_current(&pki_dir, &permitted_dns)
        .context("loading or generating CA")?;

    match previous {
        Some(previous) => {
            tracing::warn!(
                path = %pki_dir.display(),
                previous_constraints = ?previous,
                current_constraints = ?permitted_dns,
                "caproni dev CA re-signed with its existing key: constraints changed"
            );
            tracing::info!(
                "certificates it already issued stay valid; to trust the new names from your host, run: caproni ca trust"
            );
        }
        None if ca.generated => {
            tracing::info!(
                path = %pki_dir.display(),
                constraints = ?permitted_dns,
                "caproni dev CA generated"
            );
            tracing::info!("to trust this CA in your browser, run: caproni ca trust");
        }
        None => {
            tracing::debug!(path = %pki_dir.display(), "using existing CA");
        }
    }

    Ok(())
}

/// Port of `pki.PermittedDNSFor`'s call site shape: computes the CA Name
/// Constraint permitted DNS domains for a cluster config, bridging into
/// `xianyun_pki::constraints`' narrow stand-in type. `pub(crate)` so
/// `commands::ca`'s `permittedDNSFromConfig` port can reuse it.
pub(crate) fn permitted_dns_for_cluster(
    cluster: &ClusterConfig,
    profile_name: &str,
) -> Vec<String> {
    xianyun_pki::constraints::permitted_dns_for(&to_pki_cluster_config(cluster), profile_name)
}

/// Port of `datadir.PKIDir`'s call site shape: resolves the profile's PKI
/// directory under the real `$HOME`. `pub(crate)` so `commands::ca` can
/// reuse it.
pub(crate) fn pki_dir_for_profile(profile_name: &str) -> anyhow::Result<PathBuf> {
    let home = home_dir().context("resolving home directory")?;
    xianyun_executor::datadir::pki_dir_in(&home, profile_name).map_err(anyhow::Error::from)
}

/// Converts the shared `xianyun_core` cluster config into the narrow
/// stand-in type `xianyun_pki::constraints::permitted_dns_for` expects
/// (see that crate's `PORT_NOTES.md`: it was ported before the real
/// config crate existed).
fn to_pki_cluster_config(cluster: &ClusterConfig) -> xianyun_pki::constraints::ClusterConfig {
    xianyun_pki::constraints::ClusterConfig {
        network: cluster
            .network
            .as_ref()
            .map(|network| xianyun_pki::constraints::NetworkConfig {
                hostname: network.hostname.clone(),
                cluster_domain: network.cluster_domain.clone(),
            }),
    }
}

/// Returns the current user's home directory, mirroring `os.UserHomeDir()`.
fn home_dir() -> std::io::Result<PathBuf> {
    std::env::var_os("HOME")
        .map(PathBuf::from)
        .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::NotFound, "HOME is not set"))
}

/// Port of `up.runPrepareHooks`: runs `edit_mode_prepare` lifecycle hooks
/// for every repository that has an active edit-mode reloader.
fn run_prepare_hooks(container: &Container) -> anyhow::Result<()> {
    let Some(repositories) = &container.caproni.repositories else {
        return Ok(());
    };

    let executor: Arc<dyn CommandRunner + Send + Sync> =
        Arc::new(xianyun_executor::exec::Client::new());

    for (name, repo_config) in repositories.iter() {
        if !should_run_prepare_hook(container, name) {
            continue;
        }

        let hooks = xianyun_update::lifecyclehooks::resolve_repository_hooks(
            &container.caproni,
            name,
            xianyun_update::lifecyclehooks::HookType::EditModePrepare,
        );

        if hooks.is_empty() {
            continue;
        }

        xianyun_update::lifecyclehooks::run_hooks(
            executor.as_ref(),
            &container.caproni,
            container.resolver.as_ref(),
            repo_config,
            name,
            &hooks,
            None,
        )
        .with_context(|| format!("running prepare hooks for {name}"))?;
    }

    Ok(())
}

/// Port of `up.shouldRunPrepareHook`.
#[must_use]
pub fn should_run_prepare_hook(container: &Container, repo_name: &str) -> bool {
    let Some(repositories) = &container.caproni.repositories else {
        return false;
    };

    let Some(repo) = repositories.get(&repo_name.to_string()) else {
        return false;
    };

    if repo.edit_mode {
        return true;
    }

    let Some(reloaders) = &container.caproni.reloaders else {
        return false;
    };

    reloaders
        .values()
        .iter()
        .any(|reloader| reloader.repository == repo_name && reloader.edit_mode)
}

/// Port of `up.cloneRepos`: ensures git repositories are cloned for
/// edit-mode deployers/reloaders. Prepare hooks are skipped here (matching
/// Go's `SkipPrepareHooks: true`); they run after the config reload in
/// [`run_start`].
fn clone_repos(container: &Container) -> anyhow::Result<()> {
    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 updater = xianyun_update::updater::Updater::new(
        git_backend,
        xianyun_update::updater::UpdateOptions {
            strategy: xianyun_update::updater::UpdateStrategy::MinimalRequired,
            skip_prepare_hooks: true,
            ..Default::default()
        },
    );

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

    for result in &results {
        if result.status == xianyun_update::updater::UpdateStatus::Updated
            && result.notes == "Cloned"
            && let Some(repo_config) = container
                .caproni
                .repositories
                .as_ref()
                .and_then(|repos| repos.get(&result.repo_name))
        {
            let repo_dir = container.caproni.resolve_path(&repo_config.directory);
            tracing::info!(name = %result.repo_name, directory = %repo_dir, "cloned repository");
        }
    }

    if !success
        && let Some(failed) = results
            .iter()
            .find(|r| r.status == xianyun_update::updater::UpdateStatus::Failed)
    {
        anyhow::bail!(
            "cloning repository {}: {}",
            failed.repo_name,
            failed
                .error
                .as_ref()
                .map_or_else(|| failed.notes.clone(), std::string::ToString::to_string)
        );
    }

    Ok(())
}