coa-server-manager/src-tauri/src/docker_install.rs

//! The Linux (Docker) side of the install commands. `lib.rs` asks `coa_core::platform::flavor()` once per command and
//! calls this module for a Docker install; the code for a repack install stays where it was and is not changed by what
//! happens here.

use std::path::{Path, PathBuf};

use coa_core::docker::{self, install as core_install, SystemDocker};
use coa_core::download::Cancel;
use coa_core::install::{Preflight, Source};
use coa_core::registry::Registry;
use coa_core::{Error, Result};
use serde::Serialize;
use tauri::{AppHandle, Emitter, State};

use super::{blocking, data_dir, summary, AppState, InstallRequirements, ServerSummary, UiError};

/// What the install screen needs to know about this computer before it asks anything.
#[derive(Serialize)]
pub struct Environment {
    pub flavor: coa_core::platform::Flavor,
    pub default_dir: String,
    /// Why Docker cannot be used (not installed, not running, no permission), in Docker's own words; none when it works.
    pub docker_problem: Option<String>,
}

pub fn default_dir() -> String {
    default_dir_in(std::env::var("HOME").ok().as_deref())
}

fn default_dir_in(home: Option<&str>) -> String {
    match home.map(|h| h.trim_end_matches('/')).filter(|h| !h.is_empty()) {
        Some(h) => format!("{h}/CoaServer"),
        None => "/srv/coa".into(),
    }
}

pub fn docker_problem() -> Option<String> {
    docker::check_docker(&SystemDocker).err().map(|e| e.to_string())
}

pub fn environment() -> Environment {
    Environment { flavor: coa_core::platform::flavor(), default_dir: default_dir(), docker_problem: docker_problem() }
}

pub fn preflight(dest: &str, data: Option<String>, needed: Option<u64>, registry: &Registry) -> Preflight {
    // The size comes from the signed package list when the screen already has it; it is checked again at install time.
    core_install::preflight(Path::new(dest), Path::new(data.as_deref().unwrap_or("")), needed.unwrap_or(1024 * 1024 * 1024), registry)
}

/// The Linux package has no default address yet: it is published only after the maintainer has signed it.
pub fn package_source(custom: Option<String>) -> Result<Source> {
    let pick = custom.filter(|s| !s.trim().is_empty()).or_else(|| std::env::var("COA_PACKAGE_SOURCE").ok().filter(|s| !s.trim().is_empty()));
    match pick {
        Some(p) if p.to_ascii_lowercase().starts_with("http") => Ok(Source::Url(p)),
        Some(p) => Ok(Source::Dir(PathBuf::from(p))),
        None => Err(Error::Invalid("Choose the Linux server package (a folder or an address): none is published yet.".into())),
    }
}

/// The key a Linux package must be signed with. A debug build (`tauri dev`) may name another one in `COA_DEV_TRUSTED_KEY`,
/// to try the installer on a package signed with a throwaway key; a release build always uses the embedded key.
pub fn trusted_key() -> String {
    #[cfg(debug_assertions)]
    if let Ok(k) = std::env::var("COA_DEV_TRUSTED_KEY") {
        if !k.trim().is_empty() {
            return k.trim().to_string();
        }
    }
    coa_core::signing::EMBEDDED_PUBLIC_KEY.to_string()
}

pub async fn requirements(package: Option<String>) -> std::result::Result<InstallRequirements, UiError> {
    blocking(move || {
        let (m, _) = coa_core::pkgsource::fetch_manifest(&package_source(package)?, &trusted_key())?;
        let archive = m.archive.ok_or_else(|| Error::InvalidManifest("no archive".into()))?;
        Ok(InstallRequirements { download_bytes: archive.parts.iter().map(|p| p.size).sum(), unpacked_bytes: archive.unpacked_size, version: m.version })
    })
    .await
}

pub async fn install(app: AppHandle, state: State<'_, AppState>, dest: String, package: Option<String>, data: Option<String>) -> std::result::Result<ServerSummary, UiError> {
    let source = package_source(package)?;
    let data_dir_path = PathBuf::from(data.filter(|d| !d.trim().is_empty()).ok_or_else(|| Error::Invalid("Choose the folder that holds the game data.".into()))?);
    let cancel = Cancel::default();
    *state.install_cancel.lock().map_err(|_| Error::Invalid("state poisoned".into()))? = Some(cancel.clone());
    let registry = Registry::at(data_dir().join("installs.json"));
    let dest_path = PathBuf::from(dest);
    let key = trusted_key();
    let result = tauri::async_runtime::spawn_blocking(move || {
        core_install::install(
            &core_install::Params { source, dest: dest_path, data_dir: data_dir_path, trusted_key: &key, registry: &registry, cancel },
            &|step| {
                let _ = app.emit("install-progress", step);
            },
        )
    })
    .await;
    if let Ok(mut c) = state.install_cancel.lock() {
        *c = None;
    }
    let done = result.map_err(|e| Error::Invalid(e.to_string()))??;
    Ok(summary(done.id, PathBuf::from(done.path)))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn the_default_folder_is_in_the_home_folder() {
        assert_eq!(default_dir_in(Some("/home/ana")), "/home/ana/CoaServer");
        assert_eq!(default_dir_in(Some("/home/ana/")), "/home/ana/CoaServer");
        assert_eq!(default_dir_in(None), "/srv/coa");
        assert_eq!(default_dir_in(Some("")), "/srv/coa");
    }

    #[test]
    fn a_linux_package_must_be_named_there_is_no_default() {
        std::env::remove_var("COA_PACKAGE_SOURCE");
        assert!(package_source(None).is_err());
        assert!(package_source(Some("   ".into())).is_err());
        assert!(matches!(package_source(Some("/tmp/pkg".into())).unwrap(), Source::Dir(_)));
        assert!(matches!(package_source(Some("https://example.org/pkg".into())).unwrap(), Source::Url(_)));
    }
}