//! Release tooling for the CoA server packages. Used by CI and by the maintainer; never shipped to players. //! //! coa-release pack-base --tree DIR --out DIR --version X [--core-commit SHA] [--part-size BYTES] //! coa-release pack-update --tree DIR --base-manifest FILE --core DIR --out DIR --version X //! [--bots DIR] [--repairs DIR] [--core-commit SHA] [--bots-commit SHA] [--part-size BYTES] //! coa-release extract-schema-base --package DIR --fixture NEW-coa-schema-fixture-DIR //! coa-release schema-contract --repack FIXTURE --tree DIR --core DIR [--bots DIR] [--repairs DIR] //! coa-release clean-base --repack DIR --core DIR --tree DIR --out DIR [--bots DIR] [--data DIR] //! coa-release export-baseline --server DIR --out DIR (the three databases of a prepared server, for a Linux package) //! coa-release sign --dir DIR (key: env COA_SIGNING_KEY, or ~/.coa-manager/signing/manifest-signing.key) //! coa-release verify --dir DIR (against the public keys built into this tool) //! coa-release derive-preview --stable DIR --core DIR --recommended FILE --version X --core-commit SHA //! --min-manager-version X --out DIR (Modules Preview update from a stable update) //! coa-release public-key (public half of the signing key, to embed in the app) use std::collections::HashMap; use std::path::PathBuf; use coa_core::manifest::{Kind, Manifest}; use coa_core::package::{build, BuildOptions, DEFAULT_PART_SIZE}; use coa_core::release::{pack_update, sign_manifest, UpdateParams}; fn args(rest: &[String]) -> HashMap { let mut m = HashMap::new(); let mut it = rest.iter(); while let Some(k) = it.next() { if let (Some(k), Some(v)) = (k.strip_prefix("--"), it.next()) { m.insert(k.to_string(), v.clone()); } } m } fn need<'a>(a: &'a HashMap, k: &str) -> Result<&'a String, String> { a.get(k).ok_or_else(|| format!("missing --{k}")) } fn signing_key() -> Result { if let Ok(k) = std::env::var("COA_SIGNING_KEY") { return Ok(k); } let home = std::env::var("USERPROFILE") .or_else(|_| std::env::var("HOME")) .map_err(|_| "no home folder".to_string())?; std::fs::read_to_string(PathBuf::from(home).join(".coa-manager/signing/manifest-signing.key")) .map_err(|_| "no signing key: set COA_SIGNING_KEY".to_string()) } fn run() -> Result<(), String> { let all: Vec = std::env::args().skip(1).collect(); let (cmd, rest) = all .split_first() .ok_or("usage: coa-release ...")?; let a = args(rest); let e = |x: coa_core::Error| x.to_string(); let part = a .get("part-size") .and_then(|v| v.parse().ok()) .unwrap_or(DEFAULT_PART_SIZE); match cmd.as_str() { "plan-update" => { let mut meta = coa_core::registry::InstallMeta::new( coa_core::registry::InstallKind::New, std::path::Path::new("unused"), ); meta.core.version = Some(need(&a, "from")?.clone()); let selection = coa_core::update_route::select( &meta, coa_core::pkgsource::Source::Url(need(&a, "source")?.clone()), coa_core::signing::EMBEDDED_PUBLIC_KEY, ) .map_err(e)?; let (manifest, _) = coa_core::pkgsource::fetch_manifest( &selection.source, coa_core::signing::EMBEDDED_PUBLIC_KEY, ) .map_err(e)?; println!( "{}", serde_json::json!({"from":meta.core.version,"next":manifest.version,"latest":selection.latest_version}) ); } "verify-install" => { coa_core::release_schema::verify_install_package( &PathBuf::from(need(&a, "dir")?), coa_core::signing::EMBEDDED_PUBLIC_KEY, ) .map_err(e)?; } "compose-install" => { coa_core::release_schema::compose_install( &PathBuf::from(need(&a, "base")?), &PathBuf::from(need(&a, "candidate")?), &PathBuf::from(need(&a, "fixture")?), coa_core::signing::EMBEDDED_PUBLIC_KEY, ) .map_err(e)?; } "qualify-install" => { let report = coa_core::release_schema::qualify_install_against( &PathBuf::from(need(&a, "package")?), Some(&PathBuf::from(need(&a, "update")?)), &PathBuf::from(need(&a, "fixture")?), coa_core::signing::EMBEDDED_PUBLIC_KEY, ) .map_err(e)?; coa_core::fsx::atomic_write_json(&PathBuf::from(need(&a, "report")?), &report) .map_err(e)?; } "qualify-upgrade" => { let report = coa_core::release_schema::qualify_upgrade( &PathBuf::from(need(&a, "base")?), &PathBuf::from(need(&a, "source")?), &PathBuf::from(need(&a, "candidate")?), &PathBuf::from(need(&a, "fixture")?), coa_core::signing::EMBEDDED_PUBLIC_KEY, ) .map_err(e)?; coa_core::fsx::atomic_write_json(&PathBuf::from(need(&a, "report")?), &report) .map_err(e)?; println!("Manager upgrade transaction passed isolated qualification"); } "qualify-startup" => { coa_core::release_schema::validate_startup( &PathBuf::from(need(&a, "fixture")?), &PathBuf::from(need(&a, "tree")?), &PathBuf::from(need(&a, "base")?), coa_core::signing::EMBEDDED_PUBLIC_KEY, ) .map_err(e)?; println!("authserver and worldserver passed isolated startup qualification"); } "verify-channel" => { let bytes = std::fs::read(need(&a, "file")?).map_err(|x| x.to_string())?; let pointer = coa_core::channels::verify( &bytes, need(&a, "channel")?, coa_core::signing::EMBEDDED_PUBLIC_KEY, ) .map_err(e)?; println!( "{}", serde_json::to_string(&pointer).map_err(|x| x.to_string())? ); } "verify-manifest" => { let source = coa_core::pkgsource::Source::Dir(PathBuf::from(need(&a, "dir")?)); let (manifest, _) = coa_core::pkgsource::fetch_manifest( &source, coa_core::signing::EMBEDDED_PUBLIC_KEY, ) .map_err(e)?; println!("verified signed manifest {}", manifest.version); } "verify-upgrade-fixture" => { coa_core::release_schema::verify_upgrade_fixture( &PathBuf::from(need(&a, "dir")?), coa_core::signing::EMBEDDED_PUBLIC_KEY, ) .map_err(e)?; println!("verified signed upgrade fixture and every archive file"); } "extract-schema-base" => { coa_core::release_schema::extract_base( &PathBuf::from(need(&a, "package")?), &PathBuf::from(need(&a, "fixture")?), coa_core::signing::EMBEDDED_PUBLIC_KEY, ) .map_err(e)?; println!("signed base extracted into a disposable database fixture"); } "schema-contract" => { let repack = PathBuf::from(need(&a, "repack")?); let tree = PathBuf::from(need(&a, "tree")?); if let Some(core) = a.get("core") { let bots = a.get("bots").map(PathBuf::from); let repairs = a.get("repairs").map(PathBuf::from); let sql = coa_core::release_schema::collect( &PathBuf::from(core), bots.as_deref(), repairs.as_deref(), ) .map_err(e)?; coa_core::release_schema::capture_release(&repack, &tree, &sql).map_err(e)?; } else { coa_core::backup::with_database(&repack, |db| { coa_core::schema_check::capture(db, &tree) }) .map_err(e)?; } println!("database schema contract captured"); } "pack-base" => { coa_core::schema_check::require_release_contract(&PathBuf::from(need(&a, "tree")?)) .map_err(e)?; let opts = BuildOptions { kind: Kind::Base, version: need(&a, "version")?.clone(), core_commit: a.get("core-commit").cloned(), built_at: chrono_now(), part_size: part, bots_commit: a.get("bots-commit").cloned(), migrations: vec![], }; let m = build( &PathBuf::from(need(&a, "tree")?), &PathBuf::from(need(&a, "out")?), &opts, &|s| eprintln!("{s}"), ) .map_err(e)?; println!( "base {}: {} files, {} parts", m.version, m.files.len(), m.archive.as_ref().map(|x| x.parts.len()).unwrap_or(0) ); } "pack-update" => { let base: Manifest = Manifest::parse( &std::fs::read(need(&a, "base-manifest")?).map_err(|x| x.to_string())?, ) .map_err(e)?; coa_core::schema_check::require_release_contract(&PathBuf::from(need(&a, "tree")?)) .map_err(e)?; let bots = a.get("bots").map(PathBuf::from); let repairs = a.get("repairs").map(PathBuf::from); let sql = coa_core::release_schema::collect( &PathBuf::from(need(&a, "core")?), bots.as_deref(), repairs.as_deref(), ) .map_err(e)?; let out = PathBuf::from(need(&a, "out")?); let m = pack_update( &UpdateParams { tree: &PathBuf::from(need(&a, "tree")?), base_manifest: &base, sql: &sql, out: &out, version: need(&a, "version")?.clone(), core_commit: a.get("core-commit").cloned(), bots_commit: a.get("bots-commit").cloned(), part_size: part, }, &|s| eprintln!("{s}"), ) .map_err(e)?; println!( "update {}: {} files, {} migrations", m.version, m.files.len(), m.migrations.len() ); } "clean-base" => { let (repack, core, tree, out) = ( PathBuf::from(need(&a, "repack")?), PathBuf::from(need(&a, "core")?), PathBuf::from(need(&a, "tree")?), PathBuf::from(need(&a, "out")?), ); let bots = a.get("bots").map(PathBuf::from); let data = a.get("data").map(PathBuf::from); coa_core::cleanbase::build( &coa_core::cleanbase::Params { repack: &repack, core: &core, bots: bots.as_deref(), tree: &tree, data: data.as_deref(), out: &out, }, &|s| eprintln!("{s}"), ) .map_err(e)?; println!("clean base tree at {}", out.display()); } "export-baseline" => { let done = coa_core::release::export_baseline( &PathBuf::from(need(&a, "server")?), &PathBuf::from(need(&a, "out")?), ) .map_err(e)?; for (kind, bytes) in done { println!("{kind}.sql.zst: {:.1} MB", bytes as f64 / 1e6); } } "sign" => { let dir = PathBuf::from(need(&a, "dir")?); require_contract_entry(&dir)?; sign_manifest(&dir, &signing_key()?).map_err(e)?; coa_core::release_schema::verify_package(&dir, coa_core::signing::EMBEDDED_PUBLIC_KEY) .map_err(e)?; println!("signed {}", dir.join("manifest.json").display()); } "verify" => { let dir = PathBuf::from(need(&a, "dir")?); coa_core::release_schema::verify_package(&dir, coa_core::signing::EMBEDDED_PUBLIC_KEY) .map_err(e)?; println!("signature, archive contents and database schema contract OK"); } "derive-preview" => { let out = PathBuf::from(need(&a, "out")?); let m = coa_core::release::derive_preview_update( &coa_core::release::PreviewParams { stable: std::path::Path::new(need(&a, "stable")?), core: std::path::Path::new(need(&a, "core")?), recommended: std::path::Path::new(need(&a, "recommended")?), version: need(&a, "version")?.clone(), core_commit: need(&a, "core-commit")?.clone(), min_manager_version: need(&a, "min-manager-version")?.clone(), out: &out, }, &|s| eprintln!("{s}"), ) .map_err(e)?; println!("preview update {} ({} files) in {}", m.version, m.files.len(), out.display()); } "public-key" => { // The public half of the signing key (COA_SIGNING_KEY or the key file), for the app to embed. println!("{}", coa_core::signing::public_key_of(&signing_key()?).map_err(e)?); } "sign-channel" => { let pointer = coa_core::channels::Pointer { schema: 1, channel: need(&a, "channel")?.clone(), version: need(&a, "version")?.clone(), release_tag: coa_core::channels::release_tag(need(&a, "channel")?, need(&a, "version")?), snapshot: need(&a, "snapshot")?.clone(), }; let bytes = coa_core::channels::sign(&pointer, &signing_key()?).map_err(e)?; coa_core::fsx::atomic_write(&PathBuf::from(need(&a, "out")?), &bytes).map_err(e)?; } other => return Err(format!("unknown command {other}")), } Ok(()) } fn require_contract_entry(dir: &std::path::Path) -> Result<(), String> { let manifest = Manifest::parse(&std::fs::read(dir.join("manifest.json")).map_err(|e| e.to_string())?) .map_err(|e| e.to_string())?; if !manifest .files .iter() .any(|f| f.path == coa_core::schema_check::CONTRACT && f.size > 0) { return Err( "The release is missing its database schema contract; refusing to sign or publish it." .into(), ); } Ok(()) } fn chrono_now() -> String { chrono::Utc::now().to_rfc3339() } fn main() { if let Err(e) = run() { eprintln!("error: {e}"); std::process::exit(1); } }