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),
}
}
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"
"#;
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(())
}
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(())
}
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(())
}
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(())
}
#[derive(Clone, Copy)]
enum BuildMode {
Force,
IfMissing,
}
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())
}
fn jail_rootfs(config: &manifest::BlackshipConfig, service_name: &str) -> std::path::PathBuf {
config.config.jail_root(&config.jail_name(service_name))
}
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(())
}
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(())
}