blackship 0.2.1

A FreeBSD jail manager with state machine control
//! Armada (docker-compose style) orchestration commands

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

use crate::cli::ArmadaAction;
use crate::error::Result;
use crate::image::copy_release_to;
use crate::{blueprint, bridge, error, manifest, provision};

pub fn handle(
    _config_path: &Path,
    verbose: bool,
    files: &[PathBuf],
    action: ArmadaAction,
) -> Result<()> {
    match action {
        ArmadaAction::Init { file, force } => init(&file, force),

        ArmadaAction::Up {
            detach,
            jails,
            build,
            no_build,
            dry_run,
        } => {
            let mode = if no_build {
                None
            } else if build {
                Some(BuildMode::Force)
            } else {
                Some(BuildMode::IfMissing)
            };
            up(files, verbose, &jails, mode, dry_run, detach)
        }

        ArmadaAction::Down { jails, dry_run } => down(files, verbose, &jails, dry_run),

        ArmadaAction::Build { jails, dry_run } => {
            let config = manifest::load_merged(files)?;

            let jails_to_build = select_jails(&config, &jails)?;

            if dry_run {
                println!("=== DRY RUN - No changes will be made ===\n");
            }

            build_jails(&config, &jails_to_build, BuildMode::Force, dry_run, verbose)?;
            Ok(())
        }

        ArmadaAction::Ps { json } => {
            let config = manifest::load_merged(files)?;
            let bridge = bridge::Bridge::open(config, verbose)?;
            bridge.ps(json);
            Ok(())
        }

        ArmadaAction::Config { show } => config(files, show),
    }
}

/// Starter manifest written by `armada init`
const ARMADA_TEMPLATE: &str = r#"# Blackship Armada Configuration
# https://github.com/seuros/blackship

[config]
# data_dir defaults to ~/.local/share/blackship (XDG_DATA_HOME)
# Uncomment to override:
# data_dir = "/var/blackship"
# zfs_enabled = true
# zpool = "zroot"

# Example jail referencing a Jailfile:
# [[jails]]
# name = "web"
# build = "./web"              # Directory containing Jailfile
# depends_on = ["db"]
#
# [jails.network]
# ip_cidr = "10.0.1.10/24"
#
# [[jails.hooks]]
# phase = "post_start"
# command = "echo 'Web started'"

# Example jail without Jailfile (using release directly):
# [[jails]]
# name = "db"
# release = "15.1-RELEASE"
# path = "/jails/db"
"#;

/// `armada init`: write a starter blackship.toml
fn init(file: &Path, force: bool) -> Result<()> {
    if file.exists() && !force {
        eprintln!(
            "Error: {} already exists. Use -y/--force to overwrite.",
            file.display()
        );
        std::process::exit(1);
    }

    std::fs::write(file, ARMADA_TEMPLATE)?;
    println!("Created {}", file.display());
    println!("\nNext steps:");
    println!("  1. Edit {} to define your jails", file.display());
    println!("  2. Run 'blackship armada up' to start all jails");
    Ok(())
}

/// `armada up`: build what `mode` asks for (`None` = --no-build), then start
fn up(
    files: &[PathBuf],
    verbose: bool,
    jails: &[String],
    mode: Option<BuildMode>,
    dry_run: bool,
    detach: bool,
) -> Result<()> {
    let config = manifest::load_merged(files)?;

    let selected = select_jails(&config, jails)?;
    if let Some(mode) = mode {
        build_jails(&config, &selected, mode, dry_run, verbose)?;
    } else {
        for jail_def in &selected {
            if jail_def.build.is_some() && !jail_rootfs(&config, &jail_def.name).exists() {
                return Err(error::Error::User(format!(
                    "Jail '{}' is not built and --no-build was given. Run 'blackship armada build {}' first.",
                    jail_def.name, jail_def.name
                )));
            }
        }
    }

    let mut bridge = bridge::Bridge::open(config, verbose)?;

    if jails.is_empty() {
        if dry_run {
            bridge.up_dry_run(None)?;
        } else {
            bridge.up(None)?;
        }
    } else {
        for jail in jails {
            if dry_run {
                bridge.up_dry_run(Some(jail))?;
            } else {
                bridge.up(Some(jail))?;
            }
        }
    }

    if detach {
        println!("Jails started in background.");
        println!("Use 'blackship supervise' for warden mode with auto-restart.");
    }
    Ok(())
}

/// `armada down`: stop the selected jails, or all of them
fn down(files: &[PathBuf], verbose: bool, jails: &[String], dry_run: bool) -> Result<()> {
    let config = manifest::load_merged(files)?;
    let mut bridge = bridge::Bridge::open(config, verbose)?;

    if jails.is_empty() {
        if dry_run {
            bridge.down_dry_run(None)?;
        } else {
            bridge.down(None)?;
        }
    } else {
        for jail in jails {
            if dry_run {
                bridge.down_dry_run(Some(jail))?;
            } else {
                bridge.down(Some(jail))?;
            }
        }
    }
    Ok(())
}

/// `armada config`: validate the merged config, optionally print it
fn config(files: &[PathBuf], show: bool) -> Result<()> {
    let config = manifest::load_merged(files)?;

    if show {
        println!("# Merged configuration from: {files:?}\n");
        println!("[config]");
        println!("data_dir = \"{}\"", config.config.data_dir.display());
        if config.config.zfs_enabled {
            println!("zfs_enabled = true");
            if let Some(pool) = &config.config.zpool {
                println!("zpool = \"{pool}\"");
            }
        }
        println!();
        for jail in &config.jails {
            println!("[[jails]]");
            println!("name = \"{}\"", jail.name);
            if let Some(path) = &jail.path {
                println!("path = \"{}\"", path.display());
            }
            if let Some(release) = &jail.release {
                println!("release = \"{release}\"");
            }
            if let Some(build) = &jail.build {
                println!("build = \"{}\"", build.display());
            }
            if !jail.depends_on.is_empty() {
                println!("depends_on = {:?}", jail.depends_on);
            }
            println!();
        }
    } else {
        println!("Configuration valid.");
        println!("  Files: {files:?}");
        println!("  Jails: {}", config.jails.len());
    }
    Ok(())
}

/// Whether a build should replace an existing rootfs or only fill a missing one
#[derive(Clone, Copy)]
enum BuildMode {
    Force,
    IfMissing,
}

/// Resolve requested jail names against the config, or select all jails
fn select_jails<'a>(
    config: &'a manifest::BlackshipConfig,
    jails: &[String],
) -> Result<Vec<&'a manifest::JailDef>> {
    if jails.is_empty() {
        return Ok(config.jails.iter().collect());
    }
    let mut service_names = Vec::new();
    for name in jails {
        let (service_name, _full_name) = config
            .resolve_jail_names(name)
            .ok_or_else(|| error::Error::JailNotFound(name.clone()))?;
        service_names.push(service_name);
    }
    Ok(config
        .jails
        .iter()
        .filter(|j| service_names.contains(&j.name))
        .collect())
}

/// Where a jail's built rootfs lives
fn jail_rootfs(config: &manifest::BlackshipConfig, service_name: &str) -> std::path::PathBuf {
    config.config.jail_root(&config.jail_name(service_name))
}

/// Build every selected jail that has a build context, honoring `mode`
fn build_jails(
    config: &manifest::BlackshipConfig,
    jails: &[&manifest::JailDef],
    mode: BuildMode,
    dry_run: bool,
    verbose: bool,
) -> Result<()> {
    for jail_def in jails {
        let Some(build_path) = &jail_def.build else {
            continue;
        };
        if matches!(mode, BuildMode::IfMissing) && jail_rootfs(config, &jail_def.name).exists() {
            continue;
        }
        let jailfile_path = build_path.join("Jailfile");
        if jailfile_path.exists() {
            build_jail_from_file(
                config,
                &jailfile_path,
                &jail_def.name,
                Some(build_path),
                dry_run,
                verbose,
            )?;
        } else if let Some(jailfile_explicit) = &jail_def.jailfile {
            if jailfile_explicit.exists() {
                let context_dir = jailfile_explicit
                    .parent()
                    .unwrap_or_else(|| std::path::Path::new("."));
                build_jail_from_file(
                    config,
                    jailfile_explicit,
                    &jail_def.name,
                    Some(&context_dir.to_path_buf()),
                    dry_run,
                    verbose,
                )?;
            } else {
                eprintln!(
                    "Warning: Jailfile not found at {}",
                    jailfile_explicit.display()
                );
            }
        } else {
            eprintln!("Warning: No Jailfile found at {}", jailfile_path.display());
        }
    }
    Ok(())
}

/// Build a jail from a Jailfile, bootstrapping the base release if needed
fn build_jail_from_file(
    config: &manifest::BlackshipConfig,
    jailfile_path: &std::path::Path,
    service_name: &str,
    context_dir: Option<&std::path::PathBuf>,
    dry_run: bool,
    verbose: bool,
) -> Result<()> {
    use blueprint::{BuildContext, TemplateExecutor, parse_jailfile};

    let full_name = config.jail_name(service_name);
    println!(
        "Building jail '{}' from {}",
        full_name,
        jailfile_path.display()
    );

    let content = std::fs::read_to_string(jailfile_path).map_err(|e| {
        error::Error::TemplateParseFailed(format!(
            "Failed to read {}: {}",
            jailfile_path.display(),
            e
        ))
    })?;
    let jailfile = parse_jailfile(&content)?;

    let target_path = config.config.jail_root(&full_name);

    crate::blueprint::context::reject_symlink_ancestors(&config.config.data_dir, &target_path)?;
    crate::blueprint::context::reject_symlink_target(&target_path)?;

    if let Some(release) = &jailfile.from {
        crate::manifest::validate_name("release", release)?;
        let bs = provision::Provisioner::from_config(&config.config)?;
        let release_path = config.config.releases_dir.join(release);

        if !release_path.exists() {
            println!("  Base release '{release}' not found. Bootstrapping...");
            if !dry_run {
                bs.bootstrap(release, false)?;
            }
        }

        if !dry_run && !target_path.exists() {
            println!("  Creating jail root from {release}...");
            std::fs::create_dir_all(&target_path)?;
            copy_release_to(&release_path, &target_path)?;
        }
    }

    let ctx_dir = context_dir.map_or_else(
        || {
            jailfile_path
                .parent()
                .unwrap_or_else(|| std::path::Path::new("."))
        },
        std::path::PathBuf::as_path,
    );

    let ctx = BuildContext::new(ctx_dir, &target_path, &full_name).verbose(verbose);
    let mut executor = TemplateExecutor::new(ctx).dry_run(dry_run);
    executor.execute(&jailfile)?;

    if !dry_run {
        println!("  Build complete: {}\n", target_path.display());
    }

    Ok(())
}