xianyun_cluster/driver/

colima.rs

//! Port of `internal/cluster/colima/driver.go`: a [`super::Driver`]
//! implementation using Colima as the backend.
//!
//! This is the highest-churn driver file in the Go codebase (45 commits per
//! VCS hotspot analysis), so its tests are ported with extra care for edge
//! cases in `tests/colima_driver.rs`.
//!
//! **Executor injection.** Following the pattern established by
//! `external::Driver` (see its module doc comment), this driver takes its
//! `Arc<dyn CommandRunner + Send + Sync>` at construction rather than
//! through an ambient context. [`Driver::new`] wires in the real
//! `xianyun_executor::exec::Client` so existing callers (`driver::auto`)
//! need no change; [`Driver::with_runner`] is the test-facing constructor
//! that takes an explicit runner (typically
//! `xianyun_testutil::MockCommandRunner`).

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

use super::{Driver as DriverTrait, DriverError, State, Status};
use xianyun_core::config::types::{
    ClusterConfig, ColimaConfig, K3sConfig, NetworkConfig, RegistryMirrorConfig,
};
use xianyun_executor::exec::{CommandRunner, Options};

pub const DRIVER_NAME: &str = "colima";

/// Port of colima's `ErrInvalidSizeFormat` et al.
#[derive(Debug, thiserror::Error, PartialEq, Eq)]
pub enum ColimaError {
    #[error("invalid size format: {0}")]
    InvalidSizeFormat(String),
    #[error("invalid size value: {0}")]
    InvalidSizeValue(String),
    #[error("colima k3s version is not set: set cluster.colima.k3s_version in caproni.yaml")]
    K3sVersionNotDefined,
    #[error(
        "upstream is not a bare registry host (path separators and \"..\" are not allowed): {0:?}"
    )]
    InvalidUpstream(String),
    #[error("colima profile is running without Kubernetes enabled")]
    KubernetesNotEnabled,
    #[error("colima profile is running but k3s is not ready")]
    K3sNotReady,
    #[error("colima profile is running on a non-containerd runtime")]
    RuntimeMismatch,
    #[error("colima VM has no network IP")]
    NoVmIp,
    #[error("{0}")]
    Other(String),
}

impl From<ColimaError> for DriverError {
    fn from(err: ColimaError) -> Self {
        DriverError::Other(err.to_string())
    }
}

/// Port of `colima.Driver`.
pub struct Driver {
    pub cfg: ClusterConfig,
    pub profile_name: String,
    pub goos: String,
    runner: Arc<dyn CommandRunner + Send + Sync>,
}

impl Driver {
    /// Port of `colima.NewDriver`, wired to the real subprocess executor.
    #[must_use]
    pub fn new(cfg: ClusterConfig, profile_name: String) -> Self {
        Self::with_runner(
            cfg,
            profile_name,
            Arc::new(xianyun_executor::exec::Client::new()),
        )
    }

    /// Test-facing constructor: takes the injected `CommandRunner`
    /// explicitly. See the module doc comment.
    #[must_use]
    pub fn with_runner(
        cfg: ClusterConfig,
        profile_name: String,
        runner: Arc<dyn CommandRunner + Send + Sync>,
    ) -> Self {
        Self {
            cfg,
            profile_name,
            goos: std::env::consts::OS.to_string(),
            runner,
        }
    }
}

impl DriverTrait for Driver {
    fn name(&self) -> &str {
        DRIVER_NAME
    }

    fn start(&self) -> Result<(), DriverError> {
        let cfg = self.cfg.clone();

        if !is_colima_available(self) {
            return Err(DriverError::DriverNotFound("colima".to_string()));
        }

        let Some(colima_cfg) = cfg.colima.clone() else {
            return Err(DriverError::MissingDriverConfig);
        };

        let memory_gib = parse_size_gib(&colima_cfg.memory)
            .map_err(|e| DriverError::Other(format!("parsing memory: {e}")))?;

        let already_running = check_running_cluster(self, memory_gib, &colima_cfg)?;

        if already_running {
            return reconcile_running_cluster(self, &cfg);
        }

        start_new_cluster(self, &cfg, memory_gib)
    }

    fn stop(&self) -> Result<(), DriverError> {
        let status = status_impl(self)?;

        if status.state == Some(State::Stopped) {
            return Ok(());
        }

        tracing::info!(profile = %self.profile_name, "stopping colima cluster");

        let args = vec![
            "stop".to_string(),
            profile_flag(),
            self.profile_name.clone(),
        ];

        self.runner
            .exec_streamed_command(
                Some(xianyun_executor::exec::ExecStreamedOpts {
                    env: colima_env(),
                    ..Default::default()
                }),
                "colima",
                &args,
            )
            .map_err(|e| DriverError::Other(format!("stopping colima: {e}")))
    }

    fn destroy(&self) -> Result<(), DriverError> {
        if !is_colima_available(self) {
            return Err(DriverError::DriverNotFound("colima".to_string()));
        }

        let status = status_impl(self)?;

        if status.state == Some(State::Stopped) && !profile_exists(self) {
            return Ok(());
        }

        tracing::info!(profile = %self.profile_name, "destroying colima cluster");

        let args = vec![
            "delete".to_string(),
            profile_flag(),
            self.profile_name.clone(),
            "--data".to_string(),
            "--force".to_string(),
        ];

        self.runner
            .exec_streamed_command(
                Some(xianyun_executor::exec::ExecStreamedOpts {
                    env: colima_env(),
                    ..Default::default()
                }),
                "colima",
                &args,
            )
            .map_err(|e| DriverError::Other(format!("destroying colima: {e}")))
    }

    fn status(&self) -> Result<Status, DriverError> {
        status_impl(self)
    }

    fn get_kubeconfig(&self) -> Result<String, DriverError> {
        if !is_colima_available(self) {
            return Err(DriverError::DriverNotFound("colima".to_string()));
        }

        let status = status_impl(self)?;

        if status.state != Some(State::Ready) {
            return Err(DriverError::ClusterNotRunning);
        }

        read_colima_stdout(
            self,
            &[
                &profile_flag(),
                &self.profile_name,
                "ssh",
                "cat",
                "/etc/rancher/k3s/k3s.yaml",
            ],
        )
        .map_err(|e| DriverError::Other(format!("reading kubeconfig: {e}")))
    }
}

/// Port of `colima.profileFlag`.
fn profile_flag() -> String {
    "--profile".to_string()
}

fn start_new_cluster(
    driver: &Driver,
    cfg: &ClusterConfig,
    memory_gib: f64,
) -> Result<(), DriverError> {
    let colima_cfg = cfg.colima.as_ref().expect("checked by caller");

    let mut args = vec![
        "start".to_string(),
        profile_flag(),
        driver.profile_name.clone(),
    ];
    args.extend(
        build_start_args(colima_cfg, cfg.network.as_ref(), memory_gib, &driver.goos)
            .map_err(DriverError::from)?,
    );

    ensure_colima_containerd_config(driver).map_err(|e| {
        DriverError::Other(format!(
            "configuring colima containerd registry config_path: {e}"
        ))
    })?;

    tracing::info!(
        profile = %driver.profile_name,
        memory = format!("{memory_gib:.2}"),
        cores = colima_cfg.cores,
        "starting colima cluster"
    );

    let result = driver.runner.exec_streamed_command(
        Some(xianyun_executor::exec::ExecStreamedOpts {
            env: colima_env(),
            ..Default::default()
        }),
        "colima",
        &args,
    );

    if let Err(err) = result {
        if driver.goos == "darwin"
            && let Ok(status) = status_impl(driver)
            && status.state == Some(State::Ready)
            && status.ip_address.is_empty()
        {
            return Err(DriverError::Other(format!(
                "{} (colima start: {err}): this may happen when Docker Desktop or Rancher Desktop is \
                        running, or a stale `limactl` process from a previous run is still active. Run \
                        `colima delete --profile {}` and try again",
                ColimaError::NoVmIp,
                driver.profile_name
            )));
        }

        return Err(DriverError::Other(format!("starting colima: {err}")));
    }

    check_containerd_runtime(driver).map_err(DriverError::from)?;

    if let Some(mirror) = &cfg.registry_mirror {
        ensure_containerd_mirror(driver, mirror)
            .map_err(|e| DriverError::Other(format!("ensuring containerd registry mirror: {e}")))?;
    }

    Ok(())
}

fn reconcile_running_cluster(driver: &Driver, cfg: &ClusterConfig) -> Result<(), DriverError> {
    if let Some(mirror) = &cfg.registry_mirror {
        if !registry_mirror_config_active(driver) {
            tracing::warn!(
                profile = %driver.profile_name,
                "registry_mirror is configured but this colima VM has no containerd registry config_path, \
                so the mirror is inactive; the VM was likely provisioned by an older caproni that predates \
                this setting. Run `caproni destroy && caproni up` to re-provision the VM and activate the mirror."
            );
        }

        ensure_containerd_mirror(driver, mirror)
            .map_err(|e| DriverError::Other(format!("ensuring containerd registry mirror: {e}")))?;
    }

    Ok(())
}

fn check_running_cluster(
    driver: &Driver,
    memory_gib: f64,
    colima_cfg: &ColimaConfig,
) -> Result<bool, DriverError> {
    let status = match status_impl(driver) {
        Ok(status) => status,
        Err(_) => return Ok(false),
    };

    if status.state == Some(State::Stopped) {
        return Ok(false);
    }

    if status.kubernetes_version.is_empty() {
        return Err(DriverError::Other(format!(
            "{}: run `colima delete --profile {}` and try again",
            ColimaError::KubernetesNotEnabled,
            driver.profile_name
        )));
    }

    check_k3s_ready(driver).map_err(DriverError::from)?;
    check_containerd_runtime(driver).map_err(DriverError::from)?;

    let (enough, running_memory, running_cores) =
        enough_resources_provisioned(driver, memory_gib, colima_cfg.cores)
            .map_err(|e| DriverError::Other(format!("checking running configuration: {e}")))?;

    if enough {
        return Ok(true);
    }

    Err(DriverError::Other(format!(
        "cluster configuration mismatch: current config (memory={running_memory:.2}, cores={running_cores}) \
        is less than requested config (memory={}, cores={})",
        colima_cfg.memory, colima_cfg.cores
    )))
}

fn status_impl(driver: &Driver) -> Result<Status, DriverError> {
    if !is_colima_available(driver) {
        return Err(DriverError::DriverNotFound("colima".to_string()));
    }

    let mut status = Status {
        driver: DRIVER_NAME.to_string(),
        state: Some(State::Stopped),
        kube_context: format!("colima-{}", driver.profile_name),
        ..Default::default()
    };

    let stdout = match read_colima_stdout(
        driver,
        &["list", &profile_flag(), &driver.profile_name, "--json"],
    ) {
        Ok(out) => out,
        Err(_) => {
            return Ok(status);
        }
    };

    let colima_list: ColimaListJson = serde_json::from_str(&stdout)
        .map_err(|e| DriverError::Other(format!("parsing colima list JSON: {e}")))?;

    if colima_list.status == "Running" {
        status.state = Some(State::Ready);
    }

    if colima_list.runtime.contains("k3s") {
        status.kubernetes_version = "k3s".to_string();
    }

    status.ip_address = colima_list.ip_address;
    status.host_ip = status.ip_address.clone();

    Ok(status)
}

fn profile_exists(driver: &Driver) -> bool {
    read_colima_stdout(
        driver,
        &["list", &profile_flag(), &driver.profile_name, "--json"],
    )
    .is_ok()
}

pub fn is_colima_available(driver: &Driver) -> bool {
    driver.runner.look_path("colima").is_ok()
}

fn check_containerd_runtime(driver: &Driver) -> Result<(), ColimaError> {
    let stdout = read_colima_stdout(
        driver,
        &["list", &profile_flag(), &driver.profile_name, "--json"],
    )
    .map_err(|e| ColimaError::Other(format!("reading colima profile list: {e}")))?;

    let colima_list: ColimaListJson = serde_json::from_str(&stdout)
        .map_err(|e| ColimaError::Other(format!("parsing colima list JSON: {e}")))?;

    if !colima_list.runtime.contains("containerd") {
        return Err(ColimaError::Other(format!(
            "{} (got {:?}): run `caproni destroy && caproni up` to recreate the profile",
            ColimaError::RuntimeMismatch,
            colima_list.runtime
        )));
    }

    Ok(())
}

fn enough_resources_provisioned(
    driver: &Driver,
    cfg_memory_gib: f64,
    cfg_cores: i32,
) -> Result<(bool, f64, i32), ColimaError> {
    let stdout = read_colima_stdout(
        driver,
        &["list", &profile_flag(), &driver.profile_name, "--json"],
    )
    .map_err(|e| ColimaError::Other(format!("reading colima configuration: {e}")))?;

    let colima_list: ColimaListJson = serde_json::from_str(&stdout)
        .map_err(|e| ColimaError::Other(format!("parsing colima list JSON: {e}")))?;

    let running_memory_gib = colima_list.memory as f64 / (1024.0 * 1024.0 * 1024.0);
    let running_cores = colima_list.cpus;

    let matches = running_memory_gib >= cfg_memory_gib && running_cores >= cfg_cores;

    Ok((matches, running_memory_gib, running_cores))
}

/// Port of `colima.parseSizeGiB`.
pub fn parse_size_gib(size: &str) -> Result<f64, ColimaError> {
    let (number, unit) =
        split_size(size).ok_or_else(|| ColimaError::InvalidSizeFormat(size.to_string()))?;

    let value: f64 = number
        .parse()
        .map_err(|_| ColimaError::InvalidSizeValue(number.to_string()))?;

    let gib = match unit {
        "GiB" => value,
        "GB" => value * (1_000_000_000.0 / (1024.0 * 1024.0 * 1024.0)),
        "MiB" => value / 1024.0,
        "MB" => value * (1_000_000.0 / (1024.0 * 1024.0 * 1024.0)),
        _ => unreachable!("split_size only returns known units"),
    };

    Ok((gib * 100.0).round() / 100.0)
}

/// Splits a size string like "10GiB" into its numeric prefix and unit
/// suffix, matching the Go regex `^(\d+(?:\.\d+)?)(GiB|GB|MiB|MB)$`.
fn split_size(size: &str) -> Option<(&str, &str)> {
    for unit in ["GiB", "GB", "MiB", "MB"] {
        if let Some(number) = size.strip_suffix(unit)
            && !number.is_empty()
            && is_unsigned_decimal(number)
        {
            return Some((number, unit));
        }
    }
    None
}

fn is_unsigned_decimal(s: &str) -> bool {
    let mut seen_dot = false;
    let mut seen_digit = false;

    for c in s.chars() {
        if c == '.' {
            if seen_dot {
                return false;
            }
            seen_dot = true;
        } else if c.is_ascii_digit() {
            seen_digit = true;
        } else {
            return false;
        }
    }

    seen_digit
}

/// Port of `colima.parseDiskGiB`.
pub fn parse_disk_gib(disk: &str) -> Result<i64, ColimaError> {
    let gib = parse_size_gib(disk).map_err(|e| ColimaError::Other(format!("parsing disk: {e}")))?;
    Ok(gib.round() as i64)
}

/// Port of `colima.colimaListJSON`, the JSON shape of `colima list --json`.
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ColimaListJson {
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub status: String,
    #[serde(default)]
    pub arch: String,
    #[serde(default)]
    pub cpus: i32,
    #[serde(default)]
    pub memory: i64,
    #[serde(default)]
    pub disk: i64,
    #[serde(default)]
    pub runtime: String,
    #[serde(rename = "address", default)]
    pub ip_address: String,
}

/// Port of `colima.colimaEnv`: sets HOME to the sudo user's home when
/// running under sudo, so colima finds its profiles under sudo.
pub fn colima_env() -> Option<Vec<String>> {
    if std::env::var("SUDO_USER").unwrap_or_default().is_empty() {
        return None;
    }

    let home = match colima_home_dir() {
        Ok(home) => home,
        Err(err) => {
            tracing::warn!(error = %err, "failed to look up sudo user home directory, colima may not find cluster profile");
            return None;
        }
    };

    let mut env: Vec<String> = std::env::vars().map(|(k, v)| format!("{k}={v}")).collect();

    for entry in &mut env {
        if entry.starts_with("HOME=") {
            *entry = format!("HOME={home}");
            return Some(env);
        }
    }

    env.push(format!("HOME={home}"));
    Some(env)
}

/// Port of `colima.colimaHomeDir`.
pub fn colima_home_dir() -> Result<String, ColimaError> {
    let sudo_user = std::env::var("SUDO_USER").unwrap_or_default();

    if !sudo_user.is_empty() {
        return lookup_user_home_dir(&sudo_user).ok_or_else(|| {
            ColimaError::Other("looking up sudo user home directory: user not found".to_string())
        });
    }

    std::env::var("HOME")
        .map_err(|_| ColimaError::Other("getting home directory: $HOME is not set".to_string()))
}

/// Minimal `/etc/passwd` lookup, standing in for `os/user.Lookup` (no such
/// crate is a dependency of this crate; see `PORT_NOTES.md`).
fn lookup_user_home_dir(username: &str) -> Option<String> {
    let contents = std::fs::read_to_string("/etc/passwd").ok()?;

    for line in contents.lines() {
        let fields: Vec<&str> = line.split(':').collect();
        if fields.len() >= 6 && fields[0] == username {
            return Some(fields[5].to_string());
        }
    }

    None
}

/// Port of `(*colima.Driver).readColimaStdout`.
pub fn read_colima_stdout(driver: &Driver, args: &[&str]) -> Result<String, ColimaError> {
    let args_owned: Vec<String> = args.iter().map(|s| s.to_string()).collect();

    match colima_env() {
        None => driver
            .runner
            .read_stdout("colima", &args_owned)
            .map_err(|e| ColimaError::Other(format!("running colima: {e}"))),
        Some(env) => {
            let opts = Options {
                env: Some(env),
                disable_streaming: true,
                log_level: Some(tracing::Level::DEBUG),
                stderr_log_level: Some(tracing::Level::DEBUG),
                ..Default::default()
            };

            let result = driver.runner.run("colima", &args_owned, Some(opts));

            if let Some(err) = result.error {
                return Err(ColimaError::Other(format!("running colima: {err}")));
            }

            Ok(result.stdout.join("\n"))
        }
    }
}

/// Port of `(*colima.Driver).buildStartArgs`.
pub fn build_start_args(
    colima_cfg: &ColimaConfig,
    network: Option<&NetworkConfig>,
    memory_gib: f64,
    goos: &str,
) -> Result<Vec<String>, ColimaError> {
    if colima_cfg.k3s_version.is_empty() {
        return Err(ColimaError::K3sVersionNotDefined);
    }

    // `start` and the `--profile <name>` pair are prepended by the caller
    // (`start_new_cluster`), which knows the driver's profile name; this
    // function is pure over `ColimaConfig` alone, matching the ported test
    // table in `tests/colima_driver.rs` (none of which assert on `start`
    // or the profile flag).
    let mut args: Vec<String> = vec![
        "--runtime".to_string(),
        "containerd".to_string(),
        "--activate=false".to_string(),
        "--kubernetes".to_string(),
        "--kubernetes-version".to_string(),
        colima_cfg.k3s_version.clone(),
        "--memory".to_string(),
        format!("{memory_gib:.2}"),
        "--cpu".to_string(),
        colima_cfg.cores.to_string(),
    ];

    args.extend(k3s_server_args(colima_cfg.k3s.as_ref(), network));

    if !colima_cfg.disk.is_empty() {
        let disk_gib = parse_disk_gib(&colima_cfg.disk)?;
        args.push("--disk".to_string());
        args.push(disk_gib.to_string());
    }

    if goos == "darwin" {
        args.push("--network-address".to_string());
        args.push("--vm-type".to_string());
        args.push("vz".to_string());
    }

    Ok(args)
}

/// Port of `colima.k3sServerArgs`.
pub fn k3s_server_args(
    k3s_cfg: Option<&K3sConfig>,
    network: Option<&NetworkConfig>,
) -> Vec<String> {
    let mut values: Vec<String> = Vec::new();

    if let Some(k3s_cfg) = k3s_cfg {
        for component in &k3s_cfg.disable {
            values.push(format!("--disable={component}"));
        }
    }

    if let Some(network) = network
        && !network.cluster_domain.is_empty()
    {
        values.push(format!("--cluster-domain={}", network.cluster_domain));
    }

    if values.is_empty() {
        return vec!["--k3s-arg".to_string(), String::new()];
    }

    let mut args = Vec::with_capacity(values.len() * 2);
    for v in values {
        args.push("--k3s-arg".to_string());
        args.push(v);
    }

    args
}

/// Port of `colima.upstreamServerURL`.
pub fn upstream_server_url(upstream: &str) -> String {
    if upstream == "docker.io" {
        "https://registry-1.docker.io".to_string()
    } else {
        format!("https://{upstream}")
    }
}

/// Port of `colima.renderHostsTOML`.
pub fn render_hosts_toml(upstream: &str, mirror_url: &str) -> String {
    format!(
        "server = \"{}\"\n\n[host.\"{mirror_url}\"]\ncapabilities = [\"pull\", \"resolve\"]\nskip_verify = true\n",
        upstream_server_url(upstream)
    )
}

const CONTAINERD_CERTS_DIR: &str = "/etc/containerd/certs.d";

const COLIMA_CONTAINERD_CONFIG: &str = "[grpc]\ngid = 1000\n\n[plugins.'io.containerd.cri.v1.images'.registry]\nconfig_path = '/etc/containerd/certs.d'\n";

/// Port of `(*colima.Driver).ensureContainerdMirror`.
pub fn ensure_containerd_mirror(
    driver: &Driver,
    mirror: &RegistryMirrorConfig,
) -> Result<(), ColimaError> {
    let endpoint = mirror.host_port();
    let mirror_url = format!("http://{endpoint}");

    for upstream in &mirror.upstreams {
        if upstream == "." || upstream == ".." || upstream != &base_name(upstream) {
            return Err(ColimaError::InvalidUpstream(upstream.clone()));
        }
    }

    let certs_dir = certs_dir(&driver.profile_name)?;

    tracing::info!(
        profile = %driver.profile_name,
        endpoint = %endpoint,
        upstreams = ?mirror.upstreams,
        certs_dir = %certs_dir.display(),
        "ensuring containerd registry mirror for colima VM"
    );

    if certs_dir.exists() {
        std::fs::remove_dir_all(&certs_dir)
            .map_err(|e| ColimaError::Other(format!("clearing certs directory: {e}")))?;
    }

    for upstream in &mirror.upstreams {
        let dir = certs_dir.join(upstream);

        std::fs::create_dir_all(&dir)
            .map_err(|e| ColimaError::Other(format!("creating {}: {e}", dir.display())))?;

        std::fs::write(
            dir.join("hosts.toml"),
            render_hosts_toml(upstream, &mirror_url),
        )
        .map_err(|e| ColimaError::Other(format!("writing {}/hosts.toml: {e}", dir.display())))?;
    }

    symlink_certs_dir(driver, &certs_dir.to_string_lossy())
}

fn base_name(path: &str) -> String {
    std::path::Path::new(path)
        .file_name()
        .map(|n| n.to_string_lossy().into_owned())
        .unwrap_or_default()
}

/// Resolves the certs.d directory for `profile`, mirroring
/// `datadir.CertsDir` but taking `$HOME` (respecting `colima_home_dir`'s
/// sudo-aware resolution) directly rather than depending on the
/// out-of-scope `xianyun-executor::datadir` module's ambient-HOME entry
/// point.
fn certs_dir(profile: &str) -> Result<PathBuf, ColimaError> {
    let home = std::env::var("HOME")
        .map_err(|_| ColimaError::Other("getting home directory: $HOME is not set".to_string()))?;

    let dir = PathBuf::from(home)
        .join(".local/share/caproni")
        .join(profile)
        .join("certs.d");

    std::fs::create_dir_all(&dir)
        .map_err(|e| ColimaError::Other(format!("creating certs directory: {e}")))?;

    Ok(dir)
}

/// Port of `(*colima.Driver).colimaConfigDir`.
pub fn colima_config_dir(driver: &Driver) -> Result<String, ColimaError> {
    if let Ok(dir) = std::env::var("COLIMA_HOME")
        && !dir.is_empty()
        && std::path::Path::new(&dir).exists()
    {
        return Ok(dir);
    }

    let home = colima_home_dir()?;

    let legacy_dir = PathBuf::from(&home).join(".colima");
    if legacy_dir.exists() {
        return Ok(legacy_dir.to_string_lossy().into_owned());
    }

    if let Ok(xdg) = std::env::var("XDG_CONFIG_HOME")
        && !xdg.is_empty()
    {
        return Ok(PathBuf::from(xdg)
            .join("colima")
            .to_string_lossy()
            .into_owned());
    }

    if driver.goos == "darwin" {
        return Ok(legacy_dir.to_string_lossy().into_owned());
    }

    Ok(PathBuf::from(&home)
        .join(".config")
        .join("colima")
        .to_string_lossy()
        .into_owned())
}

fn colima_containerd_config_path(driver: &Driver) -> Result<PathBuf, ColimaError> {
    let dir = colima_config_dir(driver)?;
    Ok(PathBuf::from(dir)
        .join(&driver.profile_name)
        .join("containerd")
        .join("config.toml"))
}

/// Port of `(*colima.Driver).ensureColimaContainerdConfig`.
pub fn ensure_colima_containerd_config(driver: &Driver) -> Result<(), ColimaError> {
    let path = colima_containerd_config_path(driver)?;

    let parent = path.parent().ok_or_else(|| {
        ColimaError::Other("colima containerd config path has no parent".to_string())
    })?;

    std::fs::create_dir_all(parent).map_err(|e| {
        ColimaError::Other(format!("creating colima containerd config directory: {e}"))
    })?;

    std::fs::write(&path, COLIMA_CONTAINERD_CONFIG)
        .map_err(|e| ColimaError::Other(format!("writing colima containerd config: {e}")))?;

    tracing::info!(
        profile = %driver.profile_name,
        path = %path.display(),
        "wrote colima containerd config with registry config_path"
    );

    Ok(())
}

/// Port of `(*colima.Driver).registryMirrorConfigActive`.
pub fn registry_mirror_config_active(driver: &Driver) -> bool {
    let out = match read_colima_stdout(
        driver,
        &[
            &profile_flag(),
            &driver.profile_name,
            "ssh",
            "--",
            "sudo",
            "containerd",
            "config",
            "dump",
        ],
    ) {
        Ok(out) => out,
        Err(_) => return true,
    };

    out.contains(CONTAINERD_CERTS_DIR)
}

const K3S_MANIFESTS_DIR_PATH: &str = "/var/lib/rancher/k3s/server/manifests";

/// Port of `(*colima.Driver).checkK3sReady`.
pub fn check_k3s_ready(driver: &Driver) -> Result<(), ColimaError> {
    read_colima_stdout(
        driver,
        &[
            &profile_flag(),
            &driver.profile_name,
            "ssh",
            "--",
            "sudo",
            "test",
            "-d",
            K3S_MANIFESTS_DIR_PATH,
        ],
    )
    .map(|_| ())
    .map_err(|_| {
        ColimaError::Other(format!(
            "{}: run `colima delete --profile {}` and try again",
            ColimaError::K3sNotReady,
            driver.profile_name
        ))
    })
}

/// Port of `(*colima.Driver).symlinkCertsDir`.
pub fn symlink_certs_dir(driver: &Driver, certs_dir: &str) -> Result<(), ColimaError> {
    read_colima_stdout(
        driver,
        &[
            &profile_flag(),
            &driver.profile_name,
            "ssh",
            "--",
            "sudo",
            "rm",
            "-rf",
            CONTAINERD_CERTS_DIR,
        ],
    )
    .map_err(|e| ColimaError::Other(format!("clearing containerd certs.d in colima VM: {e}")))?;

    read_colima_stdout(
        driver,
        &[
            &profile_flag(),
            &driver.profile_name,
            "ssh",
            "--",
            "sudo",
            "ln",
            "-sfn",
            certs_dir,
            CONTAINERD_CERTS_DIR,
        ],
    )
    .map_err(|e| ColimaError::Other(format!("symlinking containerd certs.d in colima VM: {e}")))?;

    tracing::info!(
        target = certs_dir,
        link = CONTAINERD_CERTS_DIR,
        "containerd certs.d symlinked in VM"
    );

    Ok(())
}