Files
coa-server-manager/crates/coa-core/src/update.rs
T
ДмитрийandClaude Opus 5.5 8353b791fb The Manager no longer edits Scripts/manage.py
Repacks ship no .bat files, and the Manager starts servers with
coa-core::launcher, so the realm-profile patch it wrote into manage.py
served no one. It is no longer applied (realm creation, realm switching and
start).

Recognising the edits older Managers made (realm patch, bridge import fix)
moves into legacy_launcher, so updates and file checks still treat such a
file as unmodified. Nothing there writes a file.

manage.py itself stays complete in the repack: Managers up to 0.9.10 run it
through their bridge and patch its text, so it cannot become a thin wrapper
until those Managers are no longer supported.

Verified: coa-core unit tests; examples/manager_launcher_e2e on a disposable
repack (manage.py unchanged after a start with a realm profile).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 13:07:41 +05:00

3724 lines
136 KiB
Rust

//! Update transaction: Prepare -> Verify -> Snapshot -> Apply -> Migrate -> Validate -> Commit.
//!
//! Nothing is changed until the signed package is downloaded, verified and extracted into staging. Every file that is
//! about to change is first copied into the transaction's `before/` folder, each operation is journaled, and a crash or
//! failure at any point leaves the installation recoverable: `rollback` restores binaries and configuration exactly.
//! Full recovery points protect database changes as well as files. Interrupted updates must be resolved first.
use std::collections::BTreeMap;
use std::fs;
use std::path::{Path, PathBuf};
use serde::{Deserialize, Serialize};
use crate::config::{merge, parser::ConfFile};
use crate::download::Cancel;
use crate::error::{Error, Result};
use crate::fsx;
use crate::manifest::{FileEntry, Kind, Manifest, ReplacePolicy};
use crate::migrations::ApplyReport;
use crate::package;
use crate::pkgsource::{fetch_manifest, fetch_parts, Source};
use crate::registry::{InstallMeta, MetaDir};
const STAGED_PREFIX: &str = "_migrations/";
const CHARACTER_BASELINE: &str = "character-start-baseline.json";
const CHARACTER_BASELINE_HASH: &str = "@character-starts";
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum State {
Prepared,
Applying,
/// Files replaced; waiting for migrations / health check.
Applied,
/// Files replaced but the new build did not become healthy; the owner decides (rollback is offered).
NeedsDecision,
Committed,
RolledBack,
Failed,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum Action {
Create,
Replace,
MergeConfig,
Skip,
Conflict,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Op {
pub path: String,
pub action: Action,
pub reason: Option<String>,
/// sha256 the file will have after the operation.
pub new_sha256: String,
pub had_previous: bool,
pub started: bool,
pub done: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum Resolution {
Keep,
Replace,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Txn {
pub id: String,
pub state: State,
pub from_version: Option<String>,
pub to_version: String,
pub recovery_point: Option<String>,
#[serde(default = "legacy_databases_started")]
pub databases_started: bool,
pub ops: Vec<Op>,
pub message: Option<String>,
#[serde(default)]
pub recovery_hashes: BTreeMap<String, String>,
}
fn legacy_databases_started() -> bool {
true
}
/// Everything the transaction needs from the outside world; tests provide a fake.
pub trait Env {
fn activate(&self) -> Result<()> {
Ok(())
}
fn recover_validation(&self) -> Result<()> {
Ok(())
}
fn automatic_rollback(&self) -> bool {
false
}
fn validate_recovery(&self) -> Result<()> {
self.validate()
}
fn ensure_stopped(&self) -> Result<()>;
fn preflight(&self, _manifest: &Manifest) -> Result<()> {
Ok(())
}
fn verify_snapshot(&self, _id: &str) -> Result<()> {
Ok(())
}
fn character_start_baseline(&self) -> Result<Option<crate::character_start_check::Baseline>> {
Ok(None)
}
fn snapshot(&self) -> Result<String>;
fn restore_snapshot(&self, id: &str) -> Result<()>;
fn migrate(&self, manifest: &Manifest, staged_migrations: &Path) -> Result<ApplyReport>;
/// Start the server and confirm it becomes healthy.
fn validate(&self) -> Result<()>;
}
fn updates_dir(meta: &Path) -> PathBuf {
meta.join("updates")
}
fn txn_dir(meta: &Path, id: &str) -> Result<PathBuf> {
if id.is_empty()
|| !id
.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_'))
{
return Err(Error::PathRejected(format!("bad update id {id:?}")));
}
Ok(updates_dir(meta).join(id))
}
fn save(meta: &Path, t: &Txn) -> Result<()> {
fsx::atomic_write_json(&txn_dir(meta, &t.id)?.join("txn.json"), t)
}
pub fn load(meta: &Path, id: &str) -> Result<Txn> {
read_journal(&txn_dir(meta, id)?.join("txn.json"))
}
fn read_journal(path: &Path) -> Result<Txn> {
let mut txn: Txn = fsx::read_json(path).map_err(|e| {
Error::Invalid(format!(
"Update journal {} cannot be read: {e}. Available recovery copies were preserved.",
path.display()
))
})?;
if path
.parent()
.and_then(Path::file_name)
.and_then(|id| id.to_str())
!= Some(txn.id.as_str())
{
return Err(Error::Invalid(
"Update journal identity is inconsistent.".into(),
));
}
txn_dir(path.parent().unwrap(), &txn.id)?;
if let Some(id) = &txn.recovery_point {
if id.is_empty()
|| !id
.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '.'))
|| id.contains("..")
{
return Err(Error::Invalid(
"Update journal contains an invalid recovery point identity.".into(),
));
}
}
let valid_hash = |hash: &str| hash.len() == 64 && hash.bytes().all(|b| b.is_ascii_hexdigit());
let mut completed_legacy_repair = false;
// Older successful repairs saved Committed without setting done. Recover only that
// specific shape, and only if every repaired file still has its expected bytes.
if txn.state == State::Committed
&& txn.id.contains("-repair-")
&& txn.message.as_deref() == Some("Repair is in progress.")
&& txn.from_version.as_deref() == Some(txn.to_version.as_str())
&& txn.databases_started
&& txn.recovery_point.is_some()
&& txn.recovery_hashes.contains_key("@install")
&& txn.ops.iter().any(|op| !op.done)
&& txn.ops.iter().all(|op| {
op.started
&& matches!(
(op.action, op.had_previous),
(Action::Create, false) | (Action::Replace, true)
)
&& valid_hash(&op.new_sha256)
})
{
let meta_dir = path
.parent()
.and_then(Path::parent)
.and_then(Path::parent)
.ok_or_else(|| Error::Invalid("Invalid repair journal location.".into()))?;
let (_, installed) = MetaDir::open(meta_dir)?;
let root = Path::new(&installed.server_path);
if fsx::canonicalize_lenient(&crate::registry::metadata_dir_for(root)?)?
!= fsx::canonicalize_lenient(meta_dir)?
{
return Err(Error::Invalid(
"The repair journal does not belong to its installed server.".into(),
));
}
complete_repair_ops(root, &mut txn)?;
completed_legacy_repair = true;
}
let mut seen = std::collections::BTreeSet::new();
for op in &txn.ops {
fsx::safe_join(path.parent().unwrap(), &op.path)?;
if !seen.insert(op.path.replace('\\', "/").to_ascii_lowercase())
|| !valid_hash(&op.new_sha256)
|| (op.done && !op.started && !matches!(op.action, Action::Skip | Action::Conflict))
|| (txn.state == State::Prepared && op.started)
|| (txn.state == State::Committed && !op.done)
{
return Err(Error::Invalid(
"Update journal contains inconsistent file operations.".into(),
));
}
}
if txn.recovery_hashes.values().any(|hash| !valid_hash(hash)) {
return Err(Error::Invalid(
"Update journal contains invalid recovery hashes.".into(),
));
}
for key in txn.recovery_hashes.keys().filter(|key| {
!matches!(
key.as_str(),
"@install" | "@point" | CHARACTER_BASELINE_HASH
)
}) {
fsx::safe_join(path.parent().unwrap(), key)?;
}
if completed_legacy_repair {
// Persist the verified completion once: later legitimate updates can change
// these files. Retain the original record for diagnostics and crash recovery.
let original = path.with_file_name("txn-before-repair-completion.json");
if !original.exists() {
fsx::atomic_write(&original, &fs::read(path)?)?;
}
fsx::atomic_write_json(path, &txn)?;
}
Ok(txn)
}
#[derive(Serialize, Deserialize)]
struct CleanupMarker {
id: String,
state: State,
}
fn cleanup_marker(meta: &Path, id: &str) -> Result<PathBuf> {
txn_dir(meta, id)?;
Ok(meta.join("update-cleanup").join(format!("{id}.json")))
}
fn journals(meta: &Path) -> Result<Vec<Txn>> {
let entries = match fs::read_dir(updates_dir(meta)) {
Ok(entries) => entries,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(vec![]),
Err(e) => return Err(e.into()),
};
let mut all = Vec::new();
for entry in entries {
let entry = entry?;
if entry.file_type()?.is_symlink() {
return Err(Error::Invalid(
"Linked update storage cannot be recovered safely.".into(),
));
}
if !entry.file_type()?.is_dir() {
continue;
}
let dir = fsx::ensure_within(meta, &entry.path())?;
let path = dir.join("txn.json");
if !path.is_file() {
let id = entry.file_name().to_string_lossy().into_owned();
let marker = cleanup_marker(meta, &id)?;
if fsx::read_json::<CleanupMarker>(&marker).is_ok_and(|m| {
m.id == id && matches!(m.state, State::Committed | State::RolledBack)
}) {
continue;
}
return Err(Error::Invalid(format!("Update {id} has no journal. Preserve its recovery copies and inspect it before starting or changing the server.")));
}
all.push(read_journal(&path)?);
}
all.sort_by(|a, b| b.id.cmp(&a.id));
Ok(all)
}
pub fn pending_checked(meta: &Path) -> Result<Option<Txn>> {
Ok(journals(meta)?.into_iter().find(|t| {
!matches!(
t.state,
State::Committed | State::RolledBack | State::Prepared
) && (t.state != State::Failed || t.databases_started || t.ops.iter().any(|o| o.started))
}))
}
/// A transaction that started but never reached a final state (crash, power loss). The UI offers rollback.
pub fn unfinished(meta: &Path) -> Option<Txn> {
pending_checked(meta).ok().flatten()
}
pub fn ensure_recovered(meta: &Path) -> Result<()> {
if crate::update_isolation::pending(meta) {
return Err(Error::Invalid(
"Interrupted startup validation must be recovered before starting the server.".into(),
));
}
if let Some(t) = pending_checked(meta)? {
return Err(Error::Invalid(format!(
"Resolve unfinished update {} before changing or starting the server.",
t.id
)));
}
Ok(())
}
fn sha_if_exists(p: &Path) -> Option<String> {
p.is_file().then(|| fsx::sha256_file(p).ok()).flatten()
}
#[derive(Debug, Serialize)]
pub struct PlanItem {
pub path: String,
pub action: Action,
pub reason: Option<String>,
}
/// What an update would do to this installation. Read-only.
pub fn plan(
root: &Path,
meta: &InstallMeta,
manifest: &Manifest,
resolutions: &BTreeMap<String, Resolution>,
staged: Option<&Path>,
) -> Result<Vec<PlanItem>> {
let mut out = Vec::new();
// An update is decided by version. The same version has the same files, so a file the owner edited (or removed)
// is not an update: Repair lists such files and restores them on request.
let same_version = meta
.core
.version
.as_deref()
.is_some_and(|installed| installed == manifest.version);
for f in manifest
.files
.iter()
.filter(|f| !f.path.starts_with(STAGED_PREFIX))
{
let target = fsx::ensure_within(root, &fsx::safe_join(root, &f.path)?)?;
if same_version {
out.push(PlanItem {
path: f.path.clone(),
action: Action::Skip,
reason: Some("same version; Repair restores changed files".into()),
});
continue;
}
let cur = sha_if_exists(&target);
let recorded = meta.original_hashes.get(&f.path);
let (action, reason) = match (f.policy, &cur) {
(ReplacePolicy::NeverTouch, _) => (Action::Skip, Some("managed by you".to_string())),
(_, None) => (Action::Create, None),
(ReplacePolicy::CreateIfMissing, Some(_)) => {
(Action::Skip, Some("kept your existing file".into()))
}
(ReplacePolicy::MergeConfig, Some(_)) => {
let would_add = match staged {
Some(tree) => {
let (a, b) = (
fs::read(&target)?,
fs::read(fsx::safe_join(tree, &f.path)?)?,
);
!merge::plan(&ConfFile::parse_bytes(&a)?, &ConfFile::parse_bytes(&b)?)
.added
.is_empty()
}
None => true,
};
if would_add {
(
Action::MergeConfig,
Some("new settings are added; your values are kept".into()),
)
} else {
(Action::Skip, Some("no new settings".into()))
}
}
(_, Some(c)) if c.eq_ignore_ascii_case(&f.sha256) => {
(Action::Skip, Some("already up to date".into()))
}
(_, Some(_))
if f.path == "Scripts/manage.py"
&& staged.is_some_and(|tree| {
match (fs::read_to_string(tree.join(&f.path)), fs::read(&target)) {
(Ok(signed), Ok(actual)) => {
fsx::sha256_bytes(signed.as_bytes()) == f.sha256
&& crate::legacy_launcher::launcher_matches(&signed, &actual)
}
_ => false,
}
}) =>
{
(
Action::Skip,
Some("already up to date with Manager integration".into()),
)
}
(ReplacePolicy::Replace | ReplacePolicy::ReplaceIfPristine, Some(c)) => {
let manager_launcher = f.path == "Scripts/manage.py"
&& recorded.is_some_and(|hash| {
fs::read(&target).is_ok_and(|bytes| {
crate::legacy_launcher::launcher_matches_recorded(hash, &bytes)
})
});
if f.path == "Core/worldserver.exe"
&& meta.kind == crate::registry::InstallKind::Imported
&& crate::squid::imported_repack(root)
{
match resolutions.get(&f.path) {
Some(Resolution::Replace) => (Action::Replace, Some("Replacing this binary stops the original SquidBots launcher/updater from accepting its hash.".into())),
Some(Resolution::Keep) => (Action::Skip, Some("kept the original SquidBots binary".into())),
None => (Action::Conflict, Some("This SquidBots repack verifies its worldserver hash. Replacing it stops Start_All_Bots/coa_update from working. Choose explicitly whether to replace this binary.".into())),
}
} else if recorded.map(|r| r.eq_ignore_ascii_case(c)).unwrap_or(false)
|| manager_launcher
{
(Action::Replace, None)
} else if f.policy == ReplacePolicy::ReplaceIfPristine {
(
Action::Skip,
Some("modified outside CoA Server Manager; kept".into()),
)
} else {
match resolutions.get(&f.path) {
Some(Resolution::Replace) => (
Action::Replace,
Some("you chose to replace your modified file".into()),
),
Some(Resolution::Keep) => (
Action::Skip,
Some("you chose to keep your modified file".into()),
),
None => (
Action::Conflict,
Some("modified outside CoA Server Manager".into()),
),
}
}
}
};
out.push(PlanItem {
path: f.path.clone(),
action,
reason,
});
}
Ok(out)
}
#[derive(Debug, Serialize)]
pub struct Preview {
pub from_version: Option<String>,
pub to_version: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
pub items: Vec<PlanItem>,
pub conflicts: Vec<String>,
pub migrations: usize,
pub pending_migrations: usize,
pub download_bytes: u64,
/// False when the pending SQL was not counted (database stopped during a background check, or an error).
pub database_checked: bool,
/// Why the database could not be inspected. The check still answers about the files; applying the update starts
/// the database itself and reports its own failure.
#[serde(skip_serializing_if = "Option::is_none")]
pub database_check_error: Option<String>,
}
/// Whether looking for an update may start the database to count pending SQL.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DatabaseAccess {
/// An explicit check: start the database if it is stopped (and stop it again afterwards).
Start,
/// The background check that repeats every few minutes must not start and stop MySQL on a stopped server.
OnlyIfRunning,
}
/// The update packages are those of the Windows repack (executables, a bundled MySQL, a launcher): applying one to a Docker
/// server would put Windows files in a Linux server folder. Updating a Docker server is separate work.
fn refuse_for_docker(root: &Path) -> Result<()> {
if crate::docker::is_docker(root) {
return Err(Error::Invalid(
"Updates are not available for Docker servers yet.".into(),
));
}
Ok(())
}
/// Describe the update; a managed launcher may need a one-time authenticated payload check.
pub fn preview(
root: &Path,
meta: &InstallMeta,
source: &Source,
trusted_key: &str,
resolutions: &BTreeMap<String, Resolution>,
) -> Result<Preview> {
preview_with(
root,
meta,
source,
trusted_key,
resolutions,
DatabaseAccess::Start,
)
}
pub fn preview_with(
root: &Path,
meta: &InstallMeta,
source: &Source,
trusted_key: &str,
resolutions: &BTreeMap<String, Resolution>,
access: DatabaseAccess,
) -> Result<Preview> {
refuse_for_docker(root)?;
let meta_dir = crate::registry::metadata_dir_for(root)?;
let observed_version = MetaDir::open(&meta_dir)?.1.core.version;
let (m, _) = fetch_manifest(source, trusted_key)?;
let _lock = operation_lock_for(&meta_dir, "checking updates", true)?;
ensure_recovered(&meta_dir)?;
let (_, current_meta) = MetaDir::open(&meta_dir)?;
let meta = if current_meta.core.version != observed_version {
&current_meta
} else {
meta
};
check_manifest(&m)?;
reject_downgrade(meta, &m)?;
let mut items = plan(root, meta, &m, resolutions, None)?;
if items
.iter()
.any(|item| item.path == "Scripts/manage.py" && item.action != Action::Skip)
&& launcher_already_integrated(root, meta, &m)?
{
if let Some(item) = items
.iter_mut()
.find(|item| item.path == "Scripts/manage.py")
{
item.action = Action::Skip;
item.reason = Some("already up to date with Manager integration".into());
}
}
// Counting pending SQL needs the database. If it cannot be started the files can still be compared, so report
// that instead of failing the whole check.
let (pending_migrations, database_checked, database_check_error) = match (RepackEnv {
root,
meta_dir: &meta_dir,
})
.pending_migrations_with(&m, access)
{
Ok(Some(count)) => (count, true, None),
Ok(None) => (m.migrations.len(), false, None),
Err(error) => {
tracing::warn!(%error, "update check: the database could not be inspected");
(m.migrations.len(), false, Some(error.to_string()))
}
};
Ok(Preview {
from_version: meta.core.version.clone(),
to_version: m.version.clone(),
latest_version: None,
conflicts: items
.iter()
.filter(|i| i.action == Action::Conflict)
.map(|i| i.path.clone())
.collect(),
items,
migrations: m.migrations.len(),
pending_migrations,
download_bytes: m
.archive
.as_ref()
.map(|a| a.parts.iter().map(|p| p.size).sum())
.unwrap_or(0),
database_checked,
database_check_error,
})
}
fn launcher_already_integrated(
root: &Path,
meta: &InstallMeta,
manifest: &Manifest,
) -> Result<bool> {
let Some(file) = manifest
.files
.iter()
.find(|file| file.path == "Scripts/manage.py")
else {
return Ok(false);
};
let Ok(actual) = fs::read(root.join(&file.path)) else {
return Ok(false);
};
if meta.original_hashes.get(&file.path) != Some(&fsx::sha256_bytes(&actual)) {
return Ok(false);
}
Ok(crate::legacy_launcher::launcher_matches_recorded(
&file.sha256,
&actual,
))
}
fn reject_downgrade(meta: &InstallMeta, manifest: &Manifest) -> Result<()> {
if let Some(c) = &manifest.compatibility {
let platform = if cfg!(windows) {
"windows-x86_64"
} else {
"linux-x86_64"
};
if c.platform != platform {
return Err(Error::Invalid(format!(
"This package targets {} rather than {platform}.",
c.platform
)));
}
// The source list records release qualification, not an exclusive upgrade route.
// Database history and target validation decide whether the update can complete.
if meta
.core
.version
.as_deref()
.and_then(crate::manifest::parse_version)
.is_none()
{
return Err(Error::Invalid("The installed server version is unknown. An imported repack needs a verified starting state before updating.".into()));
}
}
if let Some(installed) = meta.core.version.as_deref() {
if let (Some(have), Some(candidate)) = (
crate::manifest::parse_version(installed),
crate::manifest::parse_version(&manifest.version),
) {
if candidate < have {
return Err(Error::Invalid(format!("Installed server {installed} is newer than package {}. Use its recovery point to undo an update; older packages cannot be applied.", manifest.version)));
}
}
}
Ok(())
}
fn check_manifest(m: &Manifest) -> Result<()> {
if m.kind != Kind::Update {
return Err(Error::Invalid("This is not an update package.".into()));
}
if !m.compatible_with_manager(crate::MANAGER_VERSION) {
return Err(Error::Invalid(
"This update needs a newer version of CoA Server Manager.".into(),
));
}
Ok(())
}
pub fn validate_candidate(meta: &InstallMeta, manifest: &Manifest) -> Result<()> {
check_manifest(manifest)?;
reject_downgrade(meta, manifest)
}
pub struct Params<'a> {
pub root: &'a Path,
pub meta_dir: &'a Path,
pub source: Source,
pub trusted_key: &'a str,
pub cancel: Cancel,
pub resolutions: BTreeMap<String, Resolution>,
pub env: &'a dyn Env,
/// Test hook: fail after this many completed file operations.
pub fail_after_ops: Option<usize>,
}
#[derive(Debug, Serialize)]
pub struct Outcome {
pub txn: Txn,
pub preexisting_character_count: usize,
pub migrations: Option<ApplyReport>,
}
fn step(report: &dyn Fn(&str, u8), name: &str, pct: u8) {
tracing::info!(step = name, percent = pct, "server update progress");
report(name, pct);
}
/// Run the whole update. On failure before the new build is validated the files are rolled back automatically;
/// a build that is applied but unhealthy is left in `NeedsDecision` so the owner chooses.
pub fn apply(p: &Params, report: &dyn Fn(&str, u8)) -> Result<Outcome> {
refuse_for_docker(p.root)?;
let (root, meta_dir) = (p.root, p.meta_dir);
let _lock = operation_lock(meta_dir)?;
ensure_recovered(meta_dir)?;
let (md, mut meta) = MetaDir::open(meta_dir)?;
let _ = md;
step(report, "Checking the update", 2);
let (m, manifest_bytes) = fetch_manifest(&p.source, p.trusted_key)?;
tracing::info!(root = %root.display(), from_version = ?meta.core.version, to_version = %m.version, migrations = m.migrations.len(), "server update selected");
check_manifest(&m)?;
reject_downgrade(&meta, &m)?;
p.env.preflight(&m)?;
let archive = m
.archive
.clone()
.ok_or_else(|| Error::InvalidManifest("no archive".into()))?;
let id = format!(
"{}-{}-{}",
chrono::Utc::now().format("%Y%m%d-%H%M%S"),
m.version.replace('.', "_"),
uuid::Uuid::new_v4().simple()
);
let tdir = txn_dir(meta_dir, &id)?;
let (tree, before) = (tdir.join("tree"), tdir.join("before"));
fs::create_dir_all(&before)?;
let signature = crate::pkgsource::fetch_small(&p.source, "manifest.json.sig")?;
crate::signing::verify(
&manifest_bytes,
&String::from_utf8_lossy(&signature),
p.trusted_key,
)?;
fsx::atomic_write(&tdir.join("manifest.json"), &manifest_bytes)?;
fsx::atomic_write(&tdir.join("manifest.json.sig"), &signature)?;
fsx::atomic_write(
&before.join("manager-install.json"),
&fs::read(meta_dir.join("install.json"))?,
)?;
let mut txn = Txn {
id: id.clone(),
state: State::Prepared,
from_version: meta.core.version.clone(),
to_version: m.version.clone(),
recovery_point: None,
databases_started: false,
ops: Vec::new(),
message: None,
recovery_hashes: BTreeMap::new(),
};
txn.recovery_hashes.insert(
"@install".into(),
fsx::sha256_file(&before.join("manager-install.json"))?,
);
save(meta_dir, &txn)?;
// Nothing has touched the installation yet; failures up to here just discard the staging area.
let staged = (|| -> Result<PathBuf> {
step(report, "Downloading the update", 5);
let parts = fetch_parts(
&p.source,
&m,
&meta_dir.join("staging").join("download"),
&p.cancel,
&|f, _| step(report, "Downloading the update", 5 + (f * 35.0) as u8),
)?;
step(report, "Verifying the update", 42);
package::extract(&parts, &m, &tree, &|_, _| {})?;
crate::migrations::verify_files(&m.migrations, &tree.join("_migrations"))?;
Ok(tree.clone())
})();
let tree = match staged {
Ok(t) => t,
Err(e) => {
txn.state = State::Failed;
txn.message = Some(e.to_string());
let _ = save(meta_dir, &txn);
let _ = fs::remove_dir_all(&tree);
return Err(e);
}
};
let items = plan(root, &meta, &m, &p.resolutions, Some(&tree))?;
if let Some(c) = items.iter().find(|i| i.action == Action::Conflict) {
txn.state = State::Failed;
txn.message = Some(format!("{} needs a decision", c.path));
save(meta_dir, &txn)?;
let _ = fs::remove_dir_all(&tree);
return Err(Error::Invalid(format!("Some files were modified outside CoA Server Manager and need your decision (for example {}).", c.path)));
}
let need: u64 = m
.files
.iter()
.filter(|f| {
items.iter().any(|i| {
i.path == f.path
&& matches!(
i.action,
Action::Replace | Action::Create | Action::MergeConfig
)
})
})
.map(|f| f.size)
.sum();
fsx::require_space(root, need)?;
fsx::require_space(meta_dir, need)?;
step(report, "Making sure the server is stopped", 48);
p.env.ensure_stopped()?;
step(report, "Saving a recovery point", 52);
txn.recovery_point = Some(p.env.snapshot().map_err(|e| {
Error::Invalid(format!(
"The update was not applied because the safety backup failed: {e}"
))
})?);
let point_meta = crate::backup::point_json(meta_dir, txn.recovery_point.as_deref().unwrap())?;
if point_meta.is_file() {
txn.recovery_hashes
.insert("@point".into(), fsx::sha256_file(&point_meta)?);
}
save(meta_dir, &txn)?;
// Capture before any new files or SQL are applied; retry must reuse these exact bytes.
let baseline = match p.env.character_start_baseline() {
Ok(baseline) => baseline,
Err(error) => {
txn.state = State::Failed;
txn.message = Some(format!("The update was not applied because the character baseline could not be captured: {error}"));
save(meta_dir, &txn)?;
return Err(error);
}
};
let preexisting_character_count = baseline
.as_ref()
.map_or(0, |b| b.realms.values().map(|r| r.len()).sum());
if let Some(baseline) = &baseline {
let path = tdir.join(CHARACTER_BASELINE);
fsx::atomic_write_json(&path, baseline)?;
txn.recovery_hashes
.insert(CHARACTER_BASELINE_HASH.into(), fsx::sha256_file(&path)?);
save(meta_dir, &txn)?;
}
txn.ops = items
.iter()
.filter(|i| i.action != Action::Skip)
.map(|i| {
let f = m
.files
.iter()
.find(|f| f.path == i.path)
.expect("planned from manifest");
Op {
path: i.path.clone(),
action: i.action,
reason: i.reason.clone(),
new_sha256: f.sha256.clone(),
had_previous: fsx::safe_join(root, &i.path)
.map(|t| t.is_file())
.unwrap_or(false),
started: false,
done: false,
}
})
.collect();
txn.state = State::Applying;
save(meta_dir, &txn)?;
step(report, "Applying the update", 58);
let applied = apply_ops(
root,
&tree,
&before,
&m.files,
&mut txn,
meta_dir,
p.fail_after_ops,
);
if let Err(e) = applied {
step(report, "Undoing the update", 70);
return fail_after_apply(p, &mut txn, &before, &tree, e.to_string(), None);
}
txn.state = State::Applied;
save(meta_dir, &txn)?;
// MySQL DDL can commit before a later statement fails. Restore the full recovery point on failure.
let mut migrated = None;
if !m.migrations.is_empty()
|| m.files
.iter()
.any(|file| file.path == crate::schema_check::CONTRACT)
{
step(report, "Updating the database", 75);
txn.databases_started = true;
save(meta_dir, &txn)?;
match p.env.migrate(&m, &tree.join("_migrations")) {
Ok(r) if r.failed.is_none() => migrated = Some(r),
Ok(r) => {
let (mid, why) = r.failed.clone().unwrap();
step(report, "Undoing the update", 76);
return fail_after_apply(
p,
&mut txn,
&before,
&tree,
format!("Database update {mid} failed: {why}"),
Some(r),
);
}
Err(e) => {
step(report, "Undoing the update", 76);
return fail_after_apply(p, &mut txn, &before, &tree, e.to_string(), None);
}
}
}
step(report, "Starting the updated server", 85);
// Core startup can apply SQL and write character data even when the package has no explicit migrations.
txn.databases_started = true;
save(meta_dir, &txn)?;
if let Err(e) = p.env.validate() {
if p.env.automatic_rollback() {
return fail_after_apply(
p,
&mut txn,
&before,
&tree,
format!("The updated server did not start correctly: {e}"),
migrated,
);
}
txn.state = State::NeedsDecision;
txn.message = Some(format!("The updated server did not start correctly: {e}"));
save(meta_dir, &txn)?;
return Ok(Outcome {
txn,
preexisting_character_count,
migrations: migrated,
});
}
finish(root, meta_dir, &mut meta, &m, &tree, &mut txn)?;
p.env.activate()?;
step(report, "Done", 100);
let _ = archive;
Ok(Outcome {
txn,
preexisting_character_count,
migrations: migrated,
})
}
fn finish(
root: &Path,
meta_dir: &Path,
meta: &mut InstallMeta,
m: &Manifest,
tree: &Path,
txn: &mut Txn,
) -> Result<()> {
meta.core.version = Some(m.version.clone());
meta.core.commit = m.core.commit.clone().or(meta.core.commit.clone());
for op in &txn.ops {
let hash = if op.path == "Scripts/manage.py" {
match (
fs::read_to_string(tree.join(&op.path)),
fs::read(root.join(&op.path)),
) {
(Ok(signed), Ok(actual)) if crate::legacy_launcher::launcher_matches(&signed, &actual) => {
fsx::sha256_bytes(&actual)
}
_ => op.new_sha256.clone(),
}
} else {
op.new_sha256.clone()
};
meta.original_hashes.insert(op.path.clone(), hash);
if !meta.managed_files.contains(&op.path) {
meta.managed_files.push(op.path.clone());
}
}
for file in &m.files {
if !txn.ops.iter().any(|op| op.path == file.path) {
let path = fsx::safe_join(root, &file.path)?;
if path.is_file() && fsx::sha256_file(&path)? == file.sha256 {
meta.original_hashes
.insert(file.path.clone(), file.sha256.clone());
}
}
}
fsx::atomic_write_json(&meta_dir.join("install.json"), meta)?;
fsx::atomic_write(
&meta_dir
.join("manifests")
.join(format!("update-{}.json", m.version)),
&serde_json::to_vec_pretty(m)?,
)?;
txn.state = State::Committed;
txn.message = None;
save(meta_dir, txn)?;
let _ = fs::remove_dir_all(tree);
prune(meta_dir, 3);
Ok(())
}
pub fn retry_validation(
root: &Path,
meta_dir: &Path,
id: &str,
fallback: &Source,
trusted_key: &str,
env: &dyn Env,
) -> Result<Txn> {
let _lock = operation_lock(meta_dir)?;
let mut txn = load(meta_dir, id)?;
if txn.state != State::NeedsDecision || unfinished(meta_dir).is_none_or(|t| t.id != id) {
return Err(Error::Invalid(
"Only an applied update awaiting startup validation can be retried.".into(),
));
}
let dir = txn_dir(meta_dir, id)?;
let source = if dir.join("manifest.json").is_file() {
Source::Dir(dir.clone())
} else {
fallback.clone()
};
let (manifest, _) = fetch_manifest(&source, trusted_key)?;
check_manifest(&manifest)?;
if manifest.version != txn.to_version || txn.ops.iter().any(|op| !op.done) {
return Err(Error::Invalid(
"The saved update does not match the applied transaction.".into(),
));
}
for op in txn
.ops
.iter()
.filter(|op| matches!(op.action, Action::Create | Action::Replace))
{
let path = fsx::safe_join(root, &op.path)?;
let file = manifest
.files
.iter()
.find(|f| f.path == op.path)
.ok_or_else(|| {
Error::Invalid(
"The update journal contains a file absent from the signed package.".into(),
)
})?;
if matches!(
file.policy,
ReplacePolicy::CreateIfMissing | ReplacePolicy::MergeConfig | ReplacePolicy::NeverTouch
) {
continue;
}
let bytes = fs::read(&path)?;
let actual = fsx::sha256_bytes(&bytes);
let launcher = op.path == "Scripts/manage.py"
&& fs::read_to_string(dir.join("tree").join(&op.path))
.ok()
.filter(|s| fsx::sha256_bytes(s.as_bytes()) == file.sha256)
.is_some_and(|s| crate::legacy_launcher::launcher_matches(&s, &bytes));
if actual != file.sha256 && !launcher {
return Err(Error::Invalid(format!(
"{} changed since the update was applied; use repair or rollback.",
op.path
)));
}
}
read_character_baseline(meta_dir, &txn)?;
env.ensure_stopped()?;
if let Err(error) = env.validate() {
txn.message = Some(format!(
"The updated server did not start correctly: {error}"
));
save(meta_dir, &txn)?;
return Ok(txn);
}
let (_, mut meta) = MetaDir::open(meta_dir)?;
finish(
root,
meta_dir,
&mut meta,
&manifest,
&dir.join("tree"),
&mut txn,
)?;
env.activate()?;
Ok(txn)
}
fn fail_after_apply(
p: &Params,
txn: &mut Txn,
before: &Path,
tree: &Path,
why: String,
report: Option<ApplyReport>,
) -> Result<Outcome> {
tracing::error!(transaction = %txn.id, databases_started = txn.databases_started, "server update failed; restoring recovery point");
let restored = restore_transaction(p.root, p.meta_dir, before, txn, p.env).and_then(|()| {
if p.env.automatic_rollback() {
p.env.validate_recovery()
} else {
Ok(())
}
});
if restored.is_err() {
let _ = p.env.ensure_stopped();
}
tracing::info!(transaction = %txn.id, recovered = restored.is_ok(), "server update recovery finished");
txn.state = if restored.is_ok() {
State::RolledBack
} else {
State::Failed
};
txn.message = Some(match &restored {
Ok(()) => why.clone(),
Err(e) => format!("{why} Recovery failed: {e}"),
});
save(p.meta_dir, txn)?;
if restored.is_ok() {
let _ = fs::remove_dir_all(tree);
if p.env.automatic_rollback() {
p.env.activate()?;
}
}
let _ = report;
Err(Error::Invalid(match restored {
Ok(()) if txn.databases_started => {
format!("{why} The server files and databases were restored to the recovery point.")
}
Ok(()) => format!("{why} The server files were restored."),
Err(e) => format!(
"{why} Recovery failed: {e}. Resolve the unfinished update before starting the server."
),
}))
}
fn restore_transaction(
root: &Path,
meta: &Path,
before: &Path,
txn: &mut Txn,
env: &dyn Env,
) -> Result<()> {
// This baseline is a validation input, not a recovery copy: corruption must block
// retry/commit, but must never prevent restoration of the verified safety backup.
for (rel, expected) in txn
.recovery_hashes
.iter()
.filter(|(key, _)| key.as_str() != CHARACTER_BASELINE_HASH)
{
let saved = match rel.as_str() {
"@install" => before.join("manager-install.json"),
"@point" => crate::backup::point_json(
meta,
txn.recovery_point.as_deref().ok_or_else(|| {
Error::Invalid("The recovery point identity is missing.".into())
})?,
)?,
_ => fsx::safe_join(before, rel)?,
};
if fsx::sha256_file(&saved)? != *expected {
return Err(Error::Invalid(format!(
"Recovery copy {rel} is damaged; no restoration was started."
)));
}
}
if let Some(id) = &txn.recovery_point {
env.verify_snapshot(id)?;
}
for op in txn.ops.iter().filter(|op| op.started && op.had_previous) {
if !fsx::safe_join(before, &op.path)?.is_file() {
return Err(Error::Invalid(format!(
"The recovery copy of {} is missing; no restoration was started.",
op.path
)));
}
}
if !before.join("manager-install.json").is_file() {
return Err(Error::Invalid(
"The saved installation metadata is missing; no restoration was started.".into(),
));
}
env.ensure_stopped()?;
env.recover_validation()?;
if txn.databases_started {
let id = txn
.recovery_point
.as_deref()
.ok_or_else(|| Error::Invalid("The database recovery point is missing.".into()))?;
env.restore_snapshot(id)?;
}
restore_files(root, before, txn)?;
let saved_meta = before.join("manager-install.json");
if saved_meta.exists() {
fsx::atomic_write(&meta.join("install.json"), &fs::read(saved_meta)?)?;
}
Ok(())
}
#[allow(clippy::explicit_counter_loop)]
fn apply_ops(
root: &Path,
tree: &Path,
before: &Path,
files: &[FileEntry],
txn: &mut Txn,
meta_dir: &Path,
fail_after: Option<usize>,
) -> Result<()> {
if fail_after == Some(0) && !txn.ops.is_empty() {
return Err(Error::Invalid("simulated failure".into()));
}
let entries: BTreeMap<_, _> = files
.iter()
.map(|entry| (entry.path.as_str(), entry))
.collect();
// Prepare every recovery copy before changing any destination. One durable journal
// can then cover the entire file phase: recovery restores old files even if their
// replacement was not reached, and removes newly created files only by exact hash.
// Rewriting the full journal twice per file makes large navigation updates quadratic.
for op in &txn.ops {
let target = fsx::ensure_within(root, &fsx::safe_join(root, &op.path)?)?;
if op.had_previous {
let keep = fsx::safe_join(before, &op.path)?;
fs::create_dir_all(keep.parent().unwrap())?;
fsx::atomic_write(&keep, &fs::read(&target)?)?;
txn.recovery_hashes
.insert(op.path.clone(), fsx::sha256_file(&keep)?);
}
}
for op in &mut txn.ops {
op.started = true;
}
save(meta_dir, txn)?;
let mut completed = 0usize;
for i in 0..txn.ops.len() {
if fail_after == Some(completed) {
return Err(Error::Invalid("simulated failure".into()));
}
let (path, action) = (txn.ops[i].path.clone(), txn.ops[i].action);
let target = fsx::ensure_within(root, &fsx::safe_join(root, &path)?)?;
let staged = fsx::safe_join(tree, &path)?;
let entry = entries.get(path.as_str()).expect("listed");
fs::create_dir_all(target.parent().unwrap())?;
match action {
Action::Create | Action::Replace => {
// Same-volume temp file + rename: the target is either the old or the new file, never half of one.
let tmp = target.with_file_name(format!(
"{}.coa-new",
target.file_name().unwrap().to_string_lossy()
));
fs::copy(&staged, &tmp)?;
if let Err(e) = fs::rename(&tmp, &target) {
let _ = fs::remove_file(&tmp);
return Err(e.into());
}
if !fsx::sha256_file(&target)?.eq_ignore_ascii_case(&entry.sha256) {
return Err(Error::HashMismatch {
path,
expected: entry.sha256.clone(),
actual: "different after writing".into(),
});
}
}
Action::MergeConfig => {
let mut conf = ConfFile::parse_bytes(&fs::read(&target)?)?;
let incoming = ConfFile::parse_bytes(&fs::read(&staged)?)?;
merge::apply(&mut conf, &incoming);
fsx::atomic_write(&target, conf.to_text().as_bytes())?;
txn.ops[i].new_sha256 = fsx::sha256_file(&target)?;
}
Action::Skip | Action::Conflict => {}
}
txn.ops[i].done = true;
completed += 1;
}
save(meta_dir, txn)
}
/// Put every touched file back the way it was. Files created by the update (no previous version) are removed only if
/// they still hold exactly what the update wrote.
fn restore_files(root: &Path, before: &Path, txn: &mut Txn) -> Result<()> {
for op in txn.ops.iter().rev().filter(|o| o.started) {
let target = fsx::ensure_within(root, &fsx::safe_join(root, &op.path)?)?;
let _ = fs::remove_file(target.with_file_name(format!(
"{}.coa-new",
target.file_name().unwrap().to_string_lossy()
)));
if op.had_previous {
let saved = fsx::safe_join(before, &op.path)?;
if !saved.is_file() {
return Err(Error::Invalid(format!(
"the saved copy of {} is missing",
op.path
)));
}
fsx::atomic_write(&target, &fs::read(saved)?)?;
} else if sha_if_exists(&target)
.map(|h| h.eq_ignore_ascii_case(&op.new_sha256))
.unwrap_or(false)
{
fs::remove_file(&target)?;
}
}
Ok(())
}
/// Restore the database recovery point first, then restore binaries and configuration.
pub fn rollback(root: &Path, meta_dir: &Path, id: &str, env: &dyn Env) -> Result<Txn> {
refuse_for_docker(root)?;
let _lock = operation_lock(meta_dir)?;
let mut txn = load(meta_dir, id)?;
if matches!(txn.state, State::Committed | State::RolledBack) {
return Err(Error::Invalid("This update cannot be rolled back.".into()));
}
restore_transaction(
root,
meta_dir,
&txn_dir(meta_dir, id)?.join("before"),
&mut txn,
env,
)?;
txn.state = State::RolledBack;
txn.message = Some("rolled back".into());
save(meta_dir, &txn)?;
let _ = fs::remove_dir_all(txn_dir(meta_dir, id)?.join("tree"));
Ok(txn)
}
pub(crate) fn operation_lock(meta_dir: &Path) -> Result<fs::File> {
operation_lock_for(meta_dir, "server maintenance", false)
}
pub(crate) fn operation_lock_for(
meta_dir: &Path,
operation: &str,
wait_for_check: bool,
) -> Result<fs::File> {
fs::create_dir_all(meta_dir)?;
let lock = fs::OpenOptions::new()
.read(true)
.write(true)
.create(true)
.truncate(false)
.open(meta_dir.join("update.lock"))?;
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
loop {
if fs4::fs_std::FileExt::try_lock_exclusive(&lock)? {
break;
}
let owner =
fsx::read_json::<serde_json::Value>(&meta_dir.join("update-lock-owner.json")).ok();
let checking = owner
.as_ref()
.and_then(|owner| owner.get("operation"))
.and_then(|value| value.as_str())
== Some("checking updates");
if wait_for_check && checking && std::time::Instant::now() < deadline {
std::thread::sleep(std::time::Duration::from_millis(100));
continue;
}
let details = owner
.as_ref()
.and_then(|owner| {
Some(format!(
" Operation: {}; Manager process: {}; started: {}.",
owner.get("operation")?.as_str()?,
owner.get("pid")?.as_u64()?,
owner.get("started")?.as_str()?
))
})
.unwrap_or_default();
return Err(Error::Invalid(format!("Another update, repair or recovery is in progress.{details} Wait for that operation to finish, then retry.")));
}
let record = serde_json::json!({"operation": operation, "pid": std::process::id(), "started": chrono::Utc::now().to_rfc3339()});
fsx::atomic_write_json(&meta_dir.join("update-lock-owner.json"), &record)?;
Ok(lock)
}
/// Repair uses the same durable recovery journal as an update. Its caller holds operation_lock.
pub(crate) fn begin_repair(
root: &Path,
meta_dir: &Path,
version: &str,
backup: &str,
files: &[FileEntry],
) -> Result<Txn> {
let id = format!(
"{}-repair-{}",
chrono::Utc::now().format("%Y%m%d-%H%M%S"),
uuid::Uuid::new_v4().simple()
);
let before = txn_dir(meta_dir, &id)?.join("before");
fsx::atomic_write(
&before.join("manager-install.json"),
&fs::read(meta_dir.join("install.json"))?,
)?;
let mut ops = Vec::new();
for file in files {
let target = fsx::ensure_within(root, &fsx::safe_join(root, &file.path)?)?;
let had_previous = target.is_file();
if had_previous {
fsx::atomic_write(&fsx::safe_join(&before, &file.path)?, &fs::read(&target)?)?;
}
ops.push(Op {
path: file.path.clone(),
action: if had_previous {
Action::Replace
} else {
Action::Create
},
reason: None,
new_sha256: file.sha256.clone(),
had_previous,
started: true,
done: false,
});
}
let mut recovery_hashes = BTreeMap::new();
recovery_hashes.insert(
"@install".into(),
fsx::sha256_file(&before.join("manager-install.json"))?,
);
let point = crate::backup::point_json(meta_dir, backup)?;
if point.is_file() {
recovery_hashes.insert("@point".into(), fsx::sha256_file(&point)?);
}
for op in ops.iter().filter(|op| op.had_previous) {
recovery_hashes.insert(
op.path.clone(),
fsx::sha256_file(&fsx::safe_join(&before, &op.path)?)?,
);
}
let txn = Txn {
id,
state: State::Applying,
from_version: Some(version.into()),
to_version: version.into(),
recovery_point: Some(backup.into()),
databases_started: false,
ops,
message: Some("Repair is in progress.".into()),
recovery_hashes,
};
save(meta_dir, &txn)?;
Ok(txn)
}
pub(crate) fn repair_migrating(meta_dir: &Path, txn: &mut Txn) -> Result<()> {
txn.state = State::Applied;
txn.databases_started = true;
save(meta_dir, txn)
}
pub(crate) fn finish_repair(
root: &Path,
meta_dir: &Path,
txn: &mut Txn,
success: bool,
env: &dyn Env,
) -> Result<()> {
if !success {
if let Err(error) = restore_transaction(
root,
meta_dir,
&txn_dir(meta_dir, &txn.id)?.join("before"),
txn,
env,
) {
txn.state = State::Failed;
txn.message = Some(format!(
"Repair recovery failed: {error}. Its recovery point was preserved."
));
save(meta_dir, txn)?;
return Err(error);
}
}
if success {
complete_repair_ops(root, txn)?;
}
txn.state = if success {
State::Committed
} else {
State::RolledBack
};
save(meta_dir, txn)
}
fn complete_repair_ops(root: &Path, txn: &mut Txn) -> Result<()> {
for op in &txn.ops {
let target = fsx::ensure_within(root, &fsx::safe_join(root, &op.path)?)?;
if fsx::sha256_file(&target)? != op.new_sha256 {
return Err(Error::Invalid(format!(
"Repaired file {} failed verification. Its recovery record was preserved.",
op.path
)));
}
}
for op in &mut txn.ops {
op.done = true;
}
Ok(())
}
fn prune(meta_dir: &Path, keep: usize) {
let Ok(rd) = fs::read_dir(updates_dir(meta_dir)) else {
return;
};
let mut dirs: Vec<_> = rd
.flatten()
.filter(|e| {
read_journal(&e.path().join("txn.json"))
.is_ok_and(|t| matches!(t.state, State::Committed | State::RolledBack))
})
.map(|e| e.path())
.collect();
dirs.sort();
while dirs.len() > keep {
let dir = dirs.remove(0);
if let Ok(txn) = read_journal(&dir.join("txn.json")) {
if let Ok(marker) = cleanup_marker(meta_dir, &txn.id) {
if fsx::atomic_write_json(
&marker,
&CleanupMarker {
id: txn.id,
state: txn.state,
},
)
.is_ok()
&& fs::remove_dir_all(&dir).is_ok()
{
let _ = fs::remove_file(marker);
}
}
}
}
}
fn read_character_baseline(
meta: &Path,
txn: &Txn,
) -> Result<Option<crate::character_start_check::Baseline>> {
let path = txn_dir(meta, &txn.id)?.join(CHARACTER_BASELINE);
let Some(expected) = txn.recovery_hashes.get(CHARACTER_BASELINE_HASH) else {
if path.exists() {
return Err(Error::Invalid(
"An unverified character start baseline was found.".into(),
));
}
return Ok(None); // Older transactions remain strict; never learn a baseline after applying SQL.
};
if fsx::sha256_file(&path)? != *expected {
return Err(Error::Invalid(
"The saved character start baseline failed verification.".into(),
));
}
let baseline: crate::character_start_check::Baseline = fsx::read_json(&path)?;
if baseline.schema != 1 {
return Err(Error::Invalid(
"Unsupported character start baseline.".into(),
));
}
Ok(Some(baseline))
}
/// The real environment: a repack-shaped installation driven through its launcher.
pub struct RepackEnv<'a> {
pub root: &'a Path,
pub meta_dir: &'a Path,
}
impl RepackEnv<'_> {
fn saved_character_baseline(&self) -> Result<Option<crate::character_start_check::Baseline>> {
match unfinished(self.meta_dir) {
Some(txn) => read_character_baseline(self.meta_dir, &txn),
None => Ok(None),
}
}
pub fn pending_migrations(&self, manifest: &Manifest) -> Result<usize> {
Ok(self
.pending_migrations_with(manifest, DatabaseAccess::Start)?
.unwrap_or(0))
}
/// `None` when the database is not running and `access` forbids starting it.
pub fn pending_migrations_with(
&self,
manifest: &Manifest,
access: DatabaseAccess,
) -> Result<Option<usize>> {
if manifest.migrations.is_empty() {
return Ok(Some(0));
}
let count = |db: &crate::db::Db| -> Result<usize> {
let db = db
.clone()
.with_read_deadline(std::time::Instant::now() + std::time::Duration::from_secs(15));
let realms = crate::realms::state(self.root)?;
let modes = realms.modes();
let mut count = 0;
for (index, mode) in modes.into_iter().enumerate() {
let list: Vec<_> = manifest
.migrations
.iter()
.filter(|m| index == 0 || !crate::migrations::shared_auth(&m.db))
.cloned()
.collect();
count += crate::migrations::pending_count(&db.clone().for_realm(mode), &list)?;
}
Ok(count)
};
match access {
DatabaseAccess::Start => crate::backup::with_database(self.root, count).map(Some),
DatabaseAccess::OnlyIfRunning => crate::backup::with_running_database(self.root, count),
}
}
pub(crate) fn verify_recovery_point(&self, point: &crate::backup::RecoveryPoint) -> Result<()> {
if point.kind != crate::backup::Kind::Full
|| !["characters", "auth", "world", "configs"]
.iter()
.all(|name| point.components.iter().any(|c| c.name == *name))
{
return Err(Error::Invalid("The update recovery point does not contain every required database and configuration.".into()));
}
if !crate::backup::verify(self.meta_dir, &point.id)?.ok {
return Err(Error::Invalid(
"The recovery point failed verification.".into(),
));
}
if let Some(snapshot) = &point.mysql_snapshot {
if fsx::sha256_file(&self.root.join("mysql/bin/mysqld.exe"))? != snapshot.server_sha256
{
return Err(Error::Invalid(
"The MySQL executable differs from the recovery point.".into(),
));
}
return Ok(());
}
crate::backup::with_database(self.root, |db| {
let db = db.clone().for_realm(crate::realms::Mode::Coa);
let mut objects = Vec::new();
for component in point.components.iter().filter(|c| c.sha256.is_some()) {
let schema = if component.name.contains('-') || component.name == "playerbots" {
crate::db::schema_of(&component.name)?
} else {
point.realm.schema(&component.name)?
};
objects.extend(db.recovery_objects(schema)?);
}
if !objects.is_empty() {
let path = self
.meta_dir
.join("diagnostics")
.join(format!("database-recovery-{}.json", uuid::Uuid::new_v4()));
let report = serde_json::json!({ "schema": 1, "checkedAt": chrono::Utc::now().to_rfc3339(), "recoveryPoint": point.id, "objects": objects });
if let Err(error) = fsx::atomic_write_json(&path, &report) {
tracing::warn!(%error, "Could not save database recovery compatibility report");
}
let sample = objects
.iter()
.take(3)
.map(|object| {
format!(
"{}.{} ({})",
object["database"].as_str().unwrap_or("?"),
object["name"].as_str().unwrap_or("?"),
object["kind"].as_str().unwrap_or("?")
)
})
.collect::<Vec<_>>()
.join(", ");
return Err(Error::Invalid(format!("Automatic recovery does not support {} database objects: {sample}. Export diagnostics for the complete list. The update was not started.", objects.len())));
}
Ok(())
})
}
fn migration_snapshot(&self) -> Result<String> {
if let Some(id) = unfinished(self.meta_dir).and_then(|t| t.recovery_point) {
if crate::backup::get(self.meta_dir, &id)?.kind == crate::backup::Kind::Full
&& crate::backup::verify(self.meta_dir, &id)?.ok
{
return Ok(id);
}
return Err(Error::Invalid(
"The update recovery point is incomplete or damaged.".into(),
));
}
Ok(crate::backup::create(
self.root,
self.meta_dir,
crate::backup::Kind::Full,
crate::backup::Trigger::BeforeMigration,
None,
&|_| {},
)?
.id)
}
}
impl Env for RepackEnv<'_> {
fn recover_validation(&self) -> Result<()> {
crate::update_isolation::restore(self.root, self.meta_dir)
}
fn activate(&self) -> Result<()> {
ensure_recovered(self.meta_dir)?;
let outcome = crate::driver::validate_update(self.root)?;
if outcome.ok {
Ok(())
} else {
Err(Error::Invalid(format!(
"The update transaction finished, but the server could not start: {}",
crate::driver::startup_failure(self.root, &outcome)
)))
}
}
fn automatic_rollback(&self) -> bool {
true
}
fn preflight(&self, manifest: &Manifest) -> Result<()> {
crate::mysql_snapshot::stop_previous_rehearsals(self.meta_dir)?;
if let Some(compatibility) = &manifest.compatibility {
let (_, meta) = MetaDir::open(self.meta_dir)?;
if let Some(source) = meta
.core
.version
.as_ref()
.and_then(|v| compatibility.source_databases.get(v))
{
if let Some(expected) = &source.schema_sha256 {
let contract = self.root.join("Scripts/database-schema.json");
if fsx::sha256_file(&contract)? != *expected {
return Err(Error::Invalid("The installed database schema contract differs from the qualified upgrade source; repair the installation first.".into()));
}
}
crate::backup::with_database(self.root, |db| {
let modes = crate::realms::state(self.root)?.modes();
for mode in modes {
if let Some(problem) = crate::schema_check::check_with_report(
&db.clone().for_realm(mode),
self.root,
)?
.first()
{
if crate::docker::is_docker(self.root) {
return Err(Error::Invalid(format!("The installed {} database does not match its upgrade source: {}.{}: {}", mode.name(), problem.database, problem.table, problem.detail)));
}
tracing::warn!(realm = mode.name(), table = %problem.table, "Installed schema differs; pending migrations and target validation will run with a full recovery point");
}
}
Ok(())
})?;
}
}
self.pending_migrations(manifest).map(|_| ())
}
fn verify_snapshot(&self, id: &str) -> Result<()> {
let point = crate::backup::get(self.meta_dir, id)?;
if point.kind != crate::backup::Kind::Full
|| !["characters", "auth", "world", "configs"]
.iter()
.all(|name| point.components.iter().any(|c| c.name == *name))
{
return Err(Error::Invalid(
"The recovery point is incomplete; no restoration was started.".into(),
));
}
if !crate::backup::verify(self.meta_dir, id)?.ok {
return Err(Error::Invalid(
"The recovery point is damaged; available copies were preserved.".into(),
));
}
Ok(())
}
fn ensure_stopped(&self) -> Result<()> {
use crate::process::{observe, ServiceState};
let o = observe(self.root, &crate::layout::read_ports(self.root));
if o.world.state != ServiceState::Stopped
|| o.auth.state != ServiceState::Stopped
|| crate::multiworld::is_running(self.root)
{
return Err(Error::Invalid(
"Stop the server before updating it; files cannot be replaced while it is running."
.into(),
));
}
Ok(())
}
fn snapshot(&self) -> Result<String> {
let label = Some("before update".to_string());
let point = crate::backup::create(
self.root,
self.meta_dir,
crate::backup::Kind::Full,
crate::backup::Trigger::BeforeUpdate,
label,
&|_| {},
)?;
self.verify_recovery_point(&point)?;
Ok(point.id)
}
fn restore_snapshot(&self, id: &str) -> Result<()> {
let point = crate::backup::get(self.meta_dir, id)?;
if point.kind != crate::backup::Kind::Full {
return Err(Error::Invalid(
"Database rollback requires a full recovery point.".into(),
));
}
if !["characters", "auth", "world", "configs"]
.iter()
.all(|name| point.components.iter().any(|c| c.name == *name))
|| !crate::backup::verify(self.meta_dir, id)?.ok
{
return Err(Error::Invalid(
"The full database recovery point is incomplete or damaged.".into(),
));
}
if let Some(snapshot) = &point.mysql_snapshot {
crate::mysql_snapshot::stop(self.root)?;
let point_dir = crate::backup::point_json(self.meta_dir, id)?
.parent()
.unwrap()
.to_path_buf();
crate::mysql_snapshot::swap(self.root, self.meta_dir, &point_dir, snapshot, false)?;
crate::backup::restore_configs(self.root, self.meta_dir, id)?;
return Ok(());
}
for component in point.components.iter().filter(|c| c.sha256.is_some()) {
crate::backup::restore_database(self.root, self.meta_dir, id, &component.name)?;
}
crate::backup::restore_configs(self.root, self.meta_dir, id)?;
Ok(())
}
fn character_start_baseline(&self) -> Result<Option<crate::character_start_check::Baseline>> {
crate::backup::with_database(self.root, |db| {
crate::character_start_check::capture(db, self.root)
})
.map(Some)
}
fn migrate(&self, manifest: &Manifest, staged: &Path) -> Result<ApplyReport> {
crate::backup::with_database(self.root, |db| {
let identities = database_identities(db)?;
let baseline = self.saved_character_baseline()?;
let result = migrate_databases(
db,
self.root,
manifest,
staged,
&|| self.migration_snapshot(),
baseline.as_ref(),
)?;
if result.failed.is_none() {
verify_database_identities(db, &identities)?;
}
Ok(result)
})
}
fn validate(&self) -> Result<()> {
self.validate_server(true)
}
fn validate_recovery(&self) -> Result<()> {
self.validate_server(false)
}
}
impl RepackEnv<'_> {
fn validate_server(&self, check_schema: bool) -> Result<()> {
crate::mysql_snapshot::stop(self.root)?;
self.ensure_stopped()?;
self.recover_validation()?;
let baseline = if check_schema {
self.saved_character_baseline()?
} else {
None
};
let result = (|| -> Result<()> {
crate::update_isolation::begin(self.root, self.meta_dir)?;
let database = crate::driver::run(self.root, crate::driver::Verb::StartMysql)?;
if !database.ok {
return Err(Error::Invalid(crate::driver::startup_failure(self.root, &database)));
}
use crate::process::{observe, ServiceState};
let identities = crate::backup::with_database(self.root, |db| {
if check_schema {
let modes = crate::realms::state(self.root)?.modes();
for mode in modes {
if let Some(p) = crate::schema_check::check_update_with_report(
&db.clone().for_realm(mode),
self.root,
baseline.as_ref(),
)?
.first()
{
return Err(Error::Invalid(format!(
"Database validation failed on {}: {}.{}: {}",
mode.name(),
p.database,
p.table,
p.detail
)));
}
}
}
database_identities(db)
})?;
// The check start is the first start of the new build: give the module configs the settings the update added
// (as a normal start does), or the server logs a "missing property" line for every one of them.
match crate::registry::MetaDir::open(self.meta_dir) {
Ok((_, meta)) if meta.kind == crate::registry::InstallKind::New => {
let _ = crate::config::materialize_module_configs(self.root);
}
// An imported server gets the files it lacks (nothing it has is changed).
_ => {
let _ = crate::config::create_missing_module_configs(self.root);
}
}
let started = match crate::driver::validate_update(self.root) {
Ok(out) => out,
Err(e) => {
let _ = crate::driver::run(self.root, crate::driver::Verb::StopAll);
return Err(e);
}
};
let ports = crate::layout::read_ports(self.root);
let healthy = started.ok && {
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(180);
let mut ready_since = None;
loop {
let o = observe(self.root, &ports);
if o.mysql.state == ServiceState::Running
&& o.auth.state == ServiceState::Running
&& o.world.state == ServiceState::Running
&& o.extra_worlds().all(|s| s.state == ServiceState::Running)
{
let since = ready_since.get_or_insert_with(std::time::Instant::now);
if since.elapsed() >= std::time::Duration::from_secs(10) {
break true;
}
} else {
ready_since = None;
}
if std::time::Instant::now() > deadline {
break false;
}
std::thread::sleep(std::time::Duration::from_secs(2));
}
};
if healthy {
crate::backup::with_database(self.root, |db| {
verify_database_identities(db, &identities)?;
if check_schema {
for mode in crate::realms::state(self.root)?.modes() {
if let Some(problem) = crate::schema_check::check_update_with_report(
&db.clone().for_realm(mode),
self.root,
baseline.as_ref(),
)?
.first()
{
return Err(Error::Invalid(format!(
"Database validation failed after startup on {}: {}: {}",
mode.name(),
problem.table,
problem.detail
)));
}
}
}
Ok(())
})?;
return Ok(());
}
let cause = crate::driver::startup_failure(self.root, &started);
// Leave the files unlocked so that a rollback can replace them.
let _ = crate::driver::run(self.root, crate::driver::Verb::StopAll);
Err(Error::Invalid(cause))
})();
crate::mysql_snapshot::stop(self.root)?;
self.ensure_stopped()?;
self.recover_validation()?;
result
}
}
/// One migration pass for both realms, with shared history checks and one recovery point.
fn migrate_databases(
db: &crate::db::Db,
root: &Path,
manifest: &Manifest,
staged: &Path,
snapshot: &dyn Fn() -> Result<String>,
baseline: Option<&crate::character_start_check::Baseline>,
) -> Result<ApplyReport> {
let realms = crate::realms::state(root)?;
let modes = realms.modes();
// Reject a broken history in either realm before changing the first one.
for (index, mode) in modes.iter().enumerate() {
let list: Vec<_> = manifest
.migrations
.iter()
.filter(|m| index == 0 || !crate::migrations::shared_auth(&m.db))
.cloned()
.collect();
crate::migrations::preflight(&db.clone().for_realm(*mode), &list)?;
}
let contract = manifest
.files
.iter()
.find(|file| file.path == crate::schema_check::CONTRACT)
.map(|file| file.sha256.as_str());
let mut result = ApplyReport {
applied: vec![],
failed: None,
snapshot: None,
};
if contract.is_some() {
result.snapshot = Some(snapshot()?);
}
for (index, mode) in modes.into_iter().enumerate() {
let db = db.clone().for_realm(mode);
let list: Vec<_> = manifest
.migrations
.iter()
.filter(|m| index == 0 || !crate::migrations::shared_auth(&m.db))
.cloned()
.collect();
crate::schema_check::repair_missing_defaults(&db, root, contract)?;
let extra = crate::migrations::apply_pending(&db, &list, staged, &|| {
if let Some(id) = &result.snapshot {
Ok(id.clone())
} else {
snapshot()
}
})?;
result.applied.extend(extra.applied);
result.failed = extra.failed;
if result.snapshot.is_none() {
result.snapshot = extra.snapshot;
}
if result.failed.is_some() {
return Ok(result);
}
crate::schema_check::repair_missing_defaults(&db, root, contract)?;
if let Some(p) = crate::schema_check::check_update_with_report(&db, root, baseline)?.first()
{
return Err(Error::Invalid(format!(
"Database validation failed on {}: {}.{}: {}",
mode.name(),
p.table,
p.column,
p.detail
)));
}
}
Ok(result)
}
fn database_identities(
db: &crate::db::Db,
) -> Result<BTreeMap<String, std::collections::BTreeSet<String>>> {
let db = db.clone().for_realm(crate::realms::Mode::Coa);
let mut identities = BTreeMap::new();
for (schema, table, columns) in [
("acore_characters", "characters", "guid,account,HEX(name)"),
(
"acore_characters_wildcard",
"characters",
"guid,account,HEX(name)",
),
(
"acore_characters_reborn",
"characters",
"guid,account,HEX(name)",
),
("acore_auth", "account", "id,HEX(username)"),
] {
if !db.schema_exists(schema)? || !db.tables(schema)?.iter().any(|name| name == table) {
continue;
}
let rows = db.query(&format!("SELECT {columns} FROM `{schema}`.`{table}`;"))?;
identities.insert(schema.into(), rows.lines().map(str::to_string).collect());
}
Ok(identities)
}
fn verify_database_identities(
db: &crate::db::Db,
before: &BTreeMap<String, std::collections::BTreeSet<String>>,
) -> Result<()> {
let after = database_identities(db)?;
for (schema, expected) in before {
if after
.get(schema)
.is_none_or(|actual| !expected.is_subset(actual))
{
return Err(Error::Invalid(format!("The update changed or removed existing character or account identities in {schema}.")));
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::package::{build, BuildOptions};
use crate::registry::{InstallKind, InstallMeta};
use base64::Engine;
use ed25519_dalek::{Signer, SigningKey};
use std::cell::{Cell, RefCell};
struct Fake {
character_baseline: RefCell<Option<crate::character_start_check::Baseline>>,
baseline_failed: Cell<bool>,
activation_expected: RefCell<Option<(PathBuf, String)>>,
activation_failed: Cell<bool>,
activated: Cell<bool>,
automatic_rollback: Cell<bool>,
recovery_healthy: Cell<bool>,
stopped: Cell<bool>,
healthy: Cell<bool>,
snapshot_ok: Cell<bool>,
calls: RefCell<Vec<&'static str>>,
migrate_fail: Cell<bool>,
preflight_fail: Cell<bool>,
restore_fail: Cell<bool>,
}
impl Fake {
fn ok() -> Fake {
Fake {
character_baseline: RefCell::new(None),
baseline_failed: Cell::new(false),
activation_expected: RefCell::new(None),
activation_failed: Cell::new(false),
activated: Cell::new(false),
automatic_rollback: Cell::new(false),
recovery_healthy: Cell::new(true),
stopped: Cell::new(true),
healthy: Cell::new(true),
snapshot_ok: Cell::new(true),
calls: Default::default(),
migrate_fail: Cell::new(false),
preflight_fail: Cell::new(false),
restore_fail: Cell::new(false),
}
}
}
impl Env for Fake {
fn character_start_baseline(
&self,
) -> Result<Option<crate::character_start_check::Baseline>> {
if self.baseline_failed.get() {
return Err(Error::Invalid("fixture baseline unavailable".into()));
}
Ok(self.character_baseline.borrow().clone())
}
fn activate(&self) -> Result<()> {
if let Some((meta, version)) = self.activation_expected.borrow().as_ref() {
ensure_recovered(meta)?;
assert_eq!(MetaDir::open(meta)?.1.core.version.as_ref(), Some(version));
}
self.activated.set(true);
if self.activation_failed.get() {
Err(Error::Invalid("Public startup failed".into()))
} else {
Ok(())
}
}
fn automatic_rollback(&self) -> bool {
self.automatic_rollback.get()
}
fn validate_recovery(&self) -> Result<()> {
self.calls.borrow_mut().push("validate-recovery");
if self.recovery_healthy.get() {
Ok(())
} else {
Err(Error::Invalid("Restored server is unhealthy".into()))
}
}
fn preflight(&self, _: &Manifest) -> Result<()> {
if self.preflight_fail.get() {
Err(Error::Invalid("Conflicting migration history".into()))
} else {
Ok(())
}
}
fn ensure_stopped(&self) -> Result<()> {
self.calls.borrow_mut().push("stop");
if self.stopped.get() {
Ok(())
} else {
Err(Error::Invalid("The server is running.".into()))
}
}
fn snapshot(&self) -> Result<String> {
self.calls.borrow_mut().push("snapshot");
if self.snapshot_ok.get() {
Ok("rp-1".into())
} else {
Err(Error::Invalid("disk full".into()))
}
}
fn migrate(&self, _m: &Manifest, _d: &Path) -> Result<ApplyReport> {
self.calls.borrow_mut().push("migrate");
Ok(ApplyReport {
applied: vec![],
failed: self
.migrate_fail
.get()
.then(|| ("m1".to_string(), "syntax".to_string())),
snapshot: None,
})
}
fn restore_snapshot(&self, _id: &str) -> Result<()> {
self.calls.borrow_mut().push("restore-databases");
if self.restore_fail.get() {
Err(Error::Invalid("recovery disk unavailable".into()))
} else {
Ok(())
}
}
fn validate(&self) -> Result<()> {
self.calls.borrow_mut().push("validate");
if self.healthy.get() {
Ok(())
} else {
Err(Error::Invalid("worldserver exited".into()))
}
}
}
struct World {
_d: tempfile::TempDir,
root: PathBuf,
meta: PathBuf,
pkg: PathBuf,
key: String,
}
fn write(root: &Path, rel: &str, content: &[u8]) {
let p = root.join(rel);
fs::create_dir_all(p.parent().unwrap()).unwrap();
fs::write(p, content).unwrap();
}
/// An installation at version 1 (files recorded as pristine) and a signed update package.
fn world(extra_update_files: &[(&str, &[u8])], migrations: bool) -> World {
let d = tempfile::tempdir().unwrap();
let root = d.path().join("srv");
let meta_dir = d.path().join("srv.manager");
let pkg = d.path().join("pkg");
let src = d.path().join("upd");
write(&root, "Core/worldserver.exe", b"world-v1");
write(&root, "Core/authserver.exe", b"auth-v1");
write(
&root,
"Settings/worldserver.conf.template",
b"[worldserver]\nRate.XP.Kill = 3\n",
);
write(&root, "user-notes.txt", b"mine");
fs::create_dir_all(&meta_dir).unwrap();
let mut meta = InstallMeta::new(InstallKind::New, &root);
meta.core.version = Some("1.0.0".into());
for f in ["Core/worldserver.exe", "Core/authserver.exe"] {
meta.original_hashes
.insert(f.into(), fsx::sha256_file(&root.join(f)).unwrap());
}
for sub in ["manifests", "backups", "updates", "staging"] {
fs::create_dir_all(meta_dir.join(sub)).unwrap();
}
fsx::atomic_write_json(&meta_dir.join("install.json"), &meta).unwrap();
write(&src, "Core/worldserver.exe", b"world-v2");
write(
&src,
"Settings/worldserver.conf.template",
b"[worldserver]\nRate.XP.Kill = 1\nNew.Setting = 5\n",
);
write(&src, "Core/newfile.dll", b"dll");
for (p, c) in extra_update_files {
write(&src, p, c);
}
if migrations {
write(&src, "_migrations/world/m1.sql", b"SELECT 1;");
}
let mut m = build(
&src,
&pkg,
&BuildOptions {
kind: Kind::Update,
version: "2.0.0".into(),
core_commit: None,
built_at: "x".into(),
part_size: 1 << 20,
bots_commit: None,
migrations: vec![],
},
&|_| {},
)
.unwrap();
// Settings/* are merge-config by the packager; make the migration entry visible to the runner
if migrations {
m.migrations.push(crate::manifest::Migration {
compatible_sha256: vec![],
id: "m1".into(),
db: "world".into(),
sha256: fsx::sha256_bytes(b"SELECT 1;"),
destructive: false,
});
fs::write(
pkg.join("manifest.json"),
serde_json::to_vec_pretty(&m).unwrap(),
)
.unwrap();
}
let sk = SigningKey::generate(&mut rand_core::OsRng);
let bytes = fs::read(pkg.join("manifest.json")).unwrap();
fs::write(
pkg.join("manifest.json.sig"),
base64::engine::general_purpose::STANDARD.encode(sk.sign(&bytes).to_bytes()),
)
.unwrap();
World {
_d: d,
root,
meta: meta_dir,
pkg,
key: base64::engine::general_purpose::STANDARD.encode(sk.verifying_key().to_bytes()),
}
}
const LEGACY_LAUNCHER: &str = "import sys\nROOT = Path(__file__).resolve().parents[1]\nfrom squid_playerbots import validate_bots\n(\"WorldDatabaseInfo\", \"acore_world\")\n(\"CharacterDatabaseInfo\", \"acore_characters\")\nSET name='AzerothCore',address=\nWHERE id=1;\nmysql(\"UPDATE acore_auth.realmlist SET flag=0\nif __name__ == \"__main__\":\n";
fn legacy_launcher_world(import_patch: bool) -> World {
let w = world(&[("Scripts/manage.py", b"new release launcher")], false);
let mut source = crate::legacy_launcher::patch_launcher(LEGACY_LAUNCHER).unwrap();
if import_patch {
source = crate::legacy_launcher::patch_launcher_imports(&source).unwrap();
}
write(&w.root, "Scripts/manage.py", source.as_bytes());
let (_, mut meta) = MetaDir::open(&w.meta).unwrap();
// Older Managers retained the signed original hash after adding realm profiles.
meta.original_hashes.insert(
"Scripts/manage.py".into(),
fsx::sha256_bytes(LEGACY_LAUNCHER.as_bytes()),
);
fsx::atomic_write_json(&w.meta.join("install.json"), &meta).unwrap();
w
}
#[test]
fn startup_waits_for_an_update_check_but_not_for_active_maintenance() {
let temp = tempfile::tempdir().unwrap();
let checker = operation_lock_for(temp.path(), "checking updates", false).unwrap();
let root = temp.path().to_path_buf();
let release = std::thread::spawn(move || {
std::thread::sleep(std::time::Duration::from_millis(150));
drop(checker);
});
let start = operation_lock_for(&root, "starting server", true).unwrap();
release.join().unwrap();
let error = operation_lock(&root).unwrap_err().to_string();
assert!(error.contains("starting server"));
assert!(error.contains(&std::process::id().to_string()));
drop(start);
// Stale owner metadata is harmless once the OS lock is released.
operation_lock(&root).unwrap();
}
#[test]
fn legacy_manager_realm_launcher_is_replaced_during_update() {
let w = legacy_launcher_world(false);
let outcome = run(&w, &Fake::ok(), BTreeMap::new(), None).unwrap();
assert_eq!(outcome.txn.state, State::Committed);
assert_eq!(read(&w, "Scripts/manage.py"), b"new release launcher");
}
#[test]
fn legacy_realm_and_import_repairs_are_replaced_during_update() {
let w = legacy_launcher_world(true);
let outcome = run(&w, &Fake::ok(), BTreeMap::new(), None).unwrap();
assert_eq!(outcome.txn.state, State::Committed);
assert_eq!(read(&w, "Scripts/manage.py"), b"new release launcher");
}
#[test]
fn genuine_launcher_edits_still_require_a_decision_and_can_be_kept() {
let w = legacy_launcher_world(true);
let mut custom = read(&w, "Scripts/manage.py");
custom.extend_from_slice(b"\n# owner's custom integration\n");
write(&w.root, "Scripts/manage.py", &custom);
let (_, meta) = MetaDir::open(&w.meta).unwrap();
let manifest = Manifest::parse(&fs::read(w.pkg.join("manifest.json")).unwrap()).unwrap();
let items = plan(&w.root, &meta, &manifest, &BTreeMap::new(), None).unwrap();
assert_eq!(
items
.iter()
.find(|item| item.path == "Scripts/manage.py")
.unwrap()
.action,
Action::Conflict
);
let resolutions = BTreeMap::from([("Scripts/manage.py".into(), Resolution::Keep)]);
let outcome = run(&w, &Fake::ok(), resolutions, None).unwrap();
assert_eq!(outcome.txn.state, State::Committed);
assert_eq!(read(&w, "Scripts/manage.py"), custom);
}
fn run(
w: &World,
env: &Fake,
res: BTreeMap<String, Resolution>,
fail_after: Option<usize>,
) -> Result<Outcome> {
apply(
&Params {
root: &w.root,
meta_dir: &w.meta,
source: Source::Dir(w.pkg.clone()),
trusted_key: &w.key,
cancel: Cancel::default(),
resolutions: res,
env,
fail_after_ops: fail_after,
},
&|_, _| {},
)
}
fn read(w: &World, rel: &str) -> Vec<u8> {
fs::read(w.root.join(rel)).unwrap()
}
#[test]
fn imported_squid_repack_requires_a_decision_even_for_pristine_worldserver() {
let w = world(&[], false);
write(&w.root, "CoA-Bots/release.json", b"{}");
let (_, mut meta) = MetaDir::open(&w.meta).unwrap();
meta.kind = InstallKind::Imported;
let manifest: Manifest =
serde_json::from_slice(&fs::read(w.pkg.join("manifest.json")).unwrap()).unwrap();
let action = |resolutions: BTreeMap<String, Resolution>| {
plan(&w.root, &meta, &manifest, &resolutions, None)
.unwrap()
.into_iter()
.find(|item| item.path == "Core/worldserver.exe")
.unwrap()
.action
};
assert_eq!(action(BTreeMap::new()), Action::Conflict);
assert_eq!(
action(BTreeMap::from([(
"Core/worldserver.exe".into(),
Resolution::Keep
)])),
Action::Skip
);
assert_eq!(
action(BTreeMap::from([(
"Core/worldserver.exe".into(),
Resolution::Replace
)])),
Action::Replace
);
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
}
#[test]
fn a_docker_server_is_never_given_the_repack_files() {
// Found by trying the installer: the update check of a Docker server read the Windows channel and offered its files.
let w = world(&[], false);
write(&w.root, "Settings/docker.json", br#"{"project":"t1"}"#);
let before = read(&w, "Core/worldserver.exe");
let meta = InstallMeta::new(InstallKind::New, &w.root);
let err = preview(
&w.root,
&meta,
&Source::Dir(w.pkg.clone()),
&w.key,
&BTreeMap::new(),
)
.unwrap_err();
assert!(err.to_string().contains("Docker"), "{err}");
let err = run(&w, &Fake::ok(), BTreeMap::new(), None).unwrap_err();
assert!(err.to_string().contains("Docker"), "{err}");
assert!(rollback(&w.root, &w.meta, "any", &Fake::ok()).is_err());
assert_eq!(
read(&w, "Core/worldserver.exe"),
before,
"nothing was touched"
);
assert!(!w.root.join("Core/newfile.dll").exists());
// The same package is applied to the same folder once it is not a Docker server.
fs::remove_file(w.root.join("Settings/docker.json")).unwrap();
assert_eq!(
run(&w, &Fake::ok(), BTreeMap::new(), None)
.unwrap()
.txn
.state,
State::Committed
);
}
#[test]
fn happy_path_replaces_creates_merges_and_records_ownership() {
let w = world(&[], false);
let env = Fake::ok();
let out = run(&w, &env, BTreeMap::new(), None).unwrap();
assert_eq!(out.txn.state, State::Committed);
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v2");
assert_eq!(
read(&w, "Core/authserver.exe"),
b"auth-v1",
"files not in the update are untouched"
);
assert_eq!(read(&w, "Core/newfile.dll"), b"dll");
assert_eq!(read(&w, "user-notes.txt"), b"mine");
let tpl = String::from_utf8(read(&w, "Settings/worldserver.conf.template")).unwrap();
assert!(
tpl.contains("Rate.XP.Kill = 3"),
"the user's value survives the merge: {tpl}"
);
assert!(tpl.contains("New.Setting = 5"), "new keys are added");
let (_, meta) = MetaDir::open(&w.meta).unwrap();
assert_eq!(meta.core.version.as_deref(), Some("2.0.0"));
assert_eq!(
meta.original_hashes["Core/worldserver.exe"],
fsx::sha256_bytes(b"world-v2")
);
assert_eq!(*env.calls.borrow(), ["stop", "snapshot", "validate"]);
assert!(!w.root.join("Core/worldserver.exe.coa-new").exists());
}
#[test]
fn public_startup_requires_a_completed_transaction_and_saved_version() {
let w = world(&[], false);
let env = Fake::ok();
*env.activation_expected.borrow_mut() = Some((w.meta.clone(), "2.0.0".into()));
run(&w, &env, BTreeMap::new(), None).unwrap();
assert!(env.activated.get());
}
#[test]
fn startup_failure_after_commit_does_not_restore_a_live_database() {
let w = world(&[], true);
let env = Fake::ok();
env.activation_failed.set(true);
assert!(run(&w, &env, BTreeMap::new(), None).is_err());
assert!(ensure_recovered(&w.meta).is_ok());
assert_eq!(
MetaDir::open(&w.meta).unwrap().1.core.version.as_deref(),
Some("2.0.0")
);
assert!(!env.calls.borrow().contains(&"restore-databases"));
}
#[test]
fn an_integrated_launcher_is_current_but_user_edits_and_new_package_bytes_are_not() {
let source = b"import sys\nfrom pathlib import Path\nfrom squid_playerbots import configure\nROOT = Path(__file__).resolve().parents[1]\n";
let w = world(&[("Scripts/manage.py", source)], false);
run(&w, &Fake::ok(), BTreeMap::new(), None).unwrap();
let integrated =
crate::legacy_launcher::patch_launcher_imports(std::str::from_utf8(source).unwrap()).unwrap();
write(&w.root, "Scripts/manage.py", integrated.as_bytes());
let (_, mut meta) = MetaDir::open(&w.meta).unwrap();
meta.original_hashes.insert(
"Scripts/manage.py".into(),
fsx::sha256_bytes(integrated.as_bytes()),
);
fsx::atomic_write_json(&w.meta.join("install.json"), &meta).unwrap();
let original = fetch_manifest(&Source::Dir(w.pkg.clone()), &w.key)
.unwrap()
.0;
for part in &original.archive.as_ref().unwrap().parts {
fs::remove_file(w.pkg.join(&part.name)).unwrap();
}
let p = preview(
&w.root,
&meta,
&Source::Dir(w.pkg.clone()),
&w.key,
&BTreeMap::new(),
)
.unwrap();
assert_eq!(
p.items
.iter()
.find(|item| item.path == "Scripts/manage.py")
.unwrap()
.action,
Action::Skip
);
let manifest = fetch_manifest(&Source::Dir(w.pkg.clone()), &w.key)
.unwrap()
.0;
let applied_plan = plan(
&w.root,
&meta,
&manifest,
&BTreeMap::new(),
Some(&w._d.path().join("upd")),
)
.unwrap();
assert_eq!(
applied_plan
.iter()
.find(|item| item.path == "Scripts/manage.py")
.unwrap()
.action,
Action::Skip
);
let mut changed = fetch_manifest(&Source::Dir(w.pkg.clone()), &w.key)
.unwrap()
.0;
changed
.files
.iter_mut()
.find(|file| file.path == "Scripts/manage.py")
.unwrap()
.sha256 = fsx::sha256_bytes(b"new launcher");
assert!(!launcher_already_integrated(&w.root, &meta, &changed).unwrap());
write(
&w.root,
"Scripts/manage.py",
format!("{integrated}\n# user edit\n").as_bytes(),
);
// Same version: the owner's edit is not an update (Repair lists and restores it).
let p = preview(
&w.root,
&meta,
&Source::Dir(w.pkg.clone()),
&w.key,
&BTreeMap::new(),
)
.unwrap();
assert!(p.items.iter().all(|item| item.action == Action::Skip) && p.conflicts.is_empty());
// An older installed build with the same edit does need a decision.
meta.core.version = Some("1.0.0".into());
let p = preview(
&w.root,
&meta,
&Source::Dir(w.pkg.clone()),
&w.key,
&BTreeMap::new(),
)
.unwrap();
assert_eq!(
p.items
.iter()
.find(|item| item.path == "Scripts/manage.py")
.unwrap()
.action,
Action::Conflict
);
meta.original_hashes.insert(
"Scripts/manage.py".into(),
fsx::sha256_file(&w.root.join("Scripts/manage.py")).unwrap(),
);
let p = preview(
&w.root,
&meta,
&Source::Dir(w.pkg.clone()),
&w.key,
&BTreeMap::new(),
)
.unwrap();
assert_eq!(
p.items
.iter()
.find(|item| item.path == "Scripts/manage.py")
.unwrap()
.action,
Action::Replace,
"Recorded user content must not be mistaken for a recognized Manager integration"
);
}
#[test]
fn older_packages_are_rejected_before_preview_or_application() {
let w = world(&[], false);
let (_, mut installed) = MetaDir::open(&w.meta).unwrap();
installed.core.version = Some("3.0.0".into());
fsx::atomic_write_json(&w.meta.join("install.json"), &installed).unwrap();
let env = Fake::ok();
assert!(run(&w, &env, BTreeMap::new(), None)
.unwrap_err()
.to_string()
.contains("newer than package"));
assert!(preview(
&w.root,
&installed,
&Source::Dir(w.pkg.clone()),
&w.key,
&BTreeMap::new()
)
.unwrap_err()
.to_string()
.contains("newer than package"));
assert!(env.calls.borrow().is_empty());
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
assert!(pending_checked(&w.meta).unwrap().is_none());
}
#[test]
fn a_file_modified_by_the_user_is_a_conflict_until_resolved() {
let w = world(&[], false);
write(&w.root, "Core/worldserver.exe", b"my-custom-build");
let env = Fake::ok();
let e = run(&w, &env, BTreeMap::new(), None).unwrap_err();
assert!(e.to_string().contains("need your decision"));
assert_eq!(
read(&w, "Core/worldserver.exe"),
b"my-custom-build",
"nothing changed"
);
assert!(
env.calls.borrow().is_empty(),
"the server was never touched or stopped"
);
let mut keep = BTreeMap::new();
keep.insert("Core/worldserver.exe".to_string(), Resolution::Keep);
run(&w, &env, keep, None).unwrap();
assert_eq!(read(&w, "Core/worldserver.exe"), b"my-custom-build");
assert_eq!(
read(&w, "Core/newfile.dll"),
b"dll",
"the rest of the update still applied"
);
let w2 = world(&[], false);
write(&w2.root, "Core/worldserver.exe", b"my-custom-build");
let mut rep = BTreeMap::new();
rep.insert("Core/worldserver.exe".to_string(), Resolution::Replace);
run(&w2, &Fake::ok(), rep, None).unwrap();
assert_eq!(read(&w2, "Core/worldserver.exe"), b"world-v2");
let t = unfinished(&w2.meta);
assert!(t.is_none());
let saved = fs::read_dir(w2.meta.join("updates"))
.unwrap()
.flatten()
.next()
.unwrap()
.path()
.join("before/Core/worldserver.exe");
assert_eq!(
fs::read(saved).unwrap(),
b"my-custom-build",
"the replaced custom build is kept for rollback"
);
}
#[test]
fn power_loss_during_bulk_files_restores_written_and_unwritten_files() {
let d = tempfile::tempdir().unwrap();
let root = d.path().join("root");
let meta = d.path().join("meta");
let tree = d.path().join("tree");
let before = meta.join("updates/bulk/before");
let mut files = Vec::new();
let mut ops = Vec::new();
for (path, previous) in [
("Data/maps/first.map", true),
("Data/maps/new.map", false),
("Data/maps/last.map", true),
] {
if previous {
write(&root, path, b"old");
}
write(&tree, path, b"new");
let hash = fsx::sha256_file(&tree.join(path)).unwrap();
files.push(FileEntry {
path: path.into(),
sha256: hash.clone(),
size: 3,
policy: ReplacePolicy::Replace,
owner: crate::manifest::Owner::Core,
});
ops.push(Op {
path: path.into(),
action: if previous {
Action::Replace
} else {
Action::Create
},
reason: None,
new_sha256: hash,
had_previous: previous,
started: false,
done: false,
});
}
let mut txn = Txn {
id: "bulk".into(),
state: State::Applying,
from_version: Some("1".into()),
to_version: "2".into(),
recovery_point: None,
databases_started: false,
ops,
message: None,
recovery_hashes: BTreeMap::new(),
};
fs::create_dir_all(before.parent().unwrap()).unwrap();
assert!(apply_ops(&root, &tree, &before, &files, &mut txn, &meta, Some(2)).is_err());
// A power loss sees the pre-write checkpoint, not the in-memory completed flags.
let mut durable = load(&meta, "bulk").unwrap();
assert!(durable.ops.iter().all(|op| op.started && !op.done));
assert_eq!(fs::read(root.join("Data/maps/last.map")).unwrap(), b"old");
restore_files(&root, &before, &mut durable).unwrap();
assert_eq!(fs::read(root.join("Data/maps/first.map")).unwrap(), b"old");
assert_eq!(fs::read(root.join("Data/maps/last.map")).unwrap(), b"old");
assert!(!root.join("Data/maps/new.map").exists());
// If preparing any recovery copy fails, no destination may be changed.
for op in &mut durable.ops {
op.started = false;
op.done = false;
}
durable.recovery_hashes.clear();
save(&meta, &durable).unwrap();
fs::remove_file(root.join("Data/maps/last.map")).unwrap();
assert!(apply_ops(&root, &tree, &before, &files, &mut durable, &meta, None).is_err());
assert_eq!(fs::read(root.join("Data/maps/first.map")).unwrap(), b"old");
assert!(!root.join("Data/maps/new.map").exists());
assert!(load(&meta, "bulk")
.unwrap()
.ops
.iter()
.all(|op| !op.started));
}
#[test]
fn failure_in_the_middle_of_applying_restores_every_file_byte_for_byte() {
for fail_after in [0usize, 1, 2] {
let w = world(&[], false);
let snap: Vec<(String, Vec<u8>)> = [
"Core/worldserver.exe",
"Core/authserver.exe",
"Settings/worldserver.conf.template",
"user-notes.txt",
]
.iter()
.map(|p| (p.to_string(), read(&w, p)))
.collect();
let e = run(&w, &Fake::ok(), BTreeMap::new(), Some(fail_after)).unwrap_err();
assert!(e.to_string().contains("simulated"));
for (p, b) in &snap {
assert_eq!(&read(&w, p), b, "{p} after failure at op {fail_after}");
}
assert!(
!w.root.join("Core/newfile.dll").exists(),
"files created by the update are removed again"
);
let (_, meta) = MetaDir::open(&w.meta).unwrap();
assert_eq!(
meta.core.version.as_deref(),
Some("1.0.0"),
"version not bumped"
);
}
}
#[test]
fn unhealthy_new_build_is_kept_until_the_owner_rolls_back() {
let w = world(&[], false);
let env = Fake::ok();
env.healthy.set(false);
let out = run(&w, &env, BTreeMap::new(), None).unwrap();
assert_eq!(out.txn.state, State::NeedsDecision);
assert_eq!(
read(&w, "Core/worldserver.exe"),
b"world-v2",
"not undone automatically"
);
assert_eq!(unfinished(&w.meta).unwrap().id, out.txn.id);
let (_, meta) = MetaDir::open(&w.meta).unwrap();
assert_eq!(meta.core.version.as_deref(), Some("1.0.0"), "not committed");
rollback(&w.root, &w.meta, &out.txn.id, &env).unwrap();
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
assert!(!w.root.join("Core/newfile.dll").exists());
assert!(unfinished(&w.meta).is_none());
assert!(
rollback(&w.root, &w.meta, &out.txn.id, &env).is_err(),
"already rolled back"
);
}
#[test]
fn automatic_health_failure_restores_databases_files_and_checks_recovery() {
let w = world(&[], true);
let env = Fake::ok();
env.automatic_rollback.set(true);
env.healthy.set(false);
assert!(run(&w, &env, BTreeMap::new(), None)
.unwrap_err()
.to_string()
.contains("restored"));
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
assert!(!w.root.join("Core/newfile.dll").exists());
assert!(env.calls.borrow().contains(&"restore-databases"));
assert!(env.calls.borrow().contains(&"validate-recovery"));
assert!(unfinished(&w.meta).is_none());
}
#[test]
fn unlisted_source_is_allowed_but_unknown_versions_and_other_platforms_are_rejected() {
let w = world(&[], false);
let (_, meta) = MetaDir::open(&w.meta).unwrap();
let mut manifest =
Manifest::parse(&fs::read(w.pkg.join("manifest.json")).unwrap()).unwrap();
manifest.min_manager_version = "0.6.13".into();
manifest.core.commit = Some("a".repeat(40));
manifest.compatibility = Some(crate::manifest::Compatibility {
schema: 1,
platform: if cfg!(windows) {
"windows-x86_64"
} else {
"linux-x86_64"
}
.into(),
core_commit: "a".repeat(40),
module_commits: [("squid".into(), "b".repeat(40))].into(),
source_databases: Default::default(),
client_patch_version: "1.5.1".into(),
source_versions: vec!["1.0.0".into()],
});
manifest.validate().unwrap();
validate_candidate(&meta, &manifest).unwrap();
manifest.compatibility.as_mut().unwrap().source_versions = vec!["0.9.0".into()];
validate_candidate(&meta, &manifest).unwrap();
let mut unknown = meta.clone();
unknown.core.version = None;
assert!(validate_candidate(&unknown, &manifest)
.unwrap_err()
.to_string()
.contains("unknown"));
unknown.core.version = Some("unverified-repack".into());
assert!(validate_candidate(&unknown, &manifest).is_err());
let mut already_updated = meta.clone();
already_updated.core.version = Some(manifest.version.clone());
validate_candidate(&already_updated, &manifest).unwrap();
manifest.compatibility.as_mut().unwrap().source_versions = vec!["1.0.0".into()];
manifest.compatibility.as_mut().unwrap().platform = if cfg!(windows) {
"linux-x86_64"
} else {
"windows-x86_64"
}
.into();
assert!(validate_candidate(&meta, &manifest)
.unwrap_err()
.to_string()
.contains("targets"));
assert!(validate_candidate(&already_updated, &manifest)
.unwrap_err()
.to_string()
.contains("targets"));
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
assert!(unfinished(&w.meta).is_none());
}
#[test]
fn changed_installed_schema_contract_blocks_before_database_access() {
let w = world(&[], false);
write(
&w.root,
"Scripts/database-schema.json",
b"modified schema contract",
);
let mut manifest =
Manifest::parse(&fs::read(w.pkg.join("manifest.json")).unwrap()).unwrap();
manifest.compatibility = Some(crate::manifest::Compatibility {
schema: 1,
platform: "windows-x86_64".into(),
core_commit: "a".repeat(40),
module_commits: [("squid".into(), "b".repeat(40))].into(),
client_patch_version: "1.5.1".into(),
source_versions: vec!["1.0.0".into()],
source_databases: [(
"1.0.0".into(),
crate::manifest::SourceDatabase {
manifest_sha256: "a".repeat(64),
schema_sha256: Some("b".repeat(64)),
},
)]
.into(),
});
let env = RepackEnv {
root: &w.root,
meta_dir: &w.meta,
};
let error = env.preflight(&manifest).unwrap_err().to_string();
assert!(error.contains("schema contract differs"), "{error}");
assert!(!w.root.join("Runtime/python/python.exe").exists());
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
assert!(unfinished(&w.meta).is_none());
}
#[test]
fn unhealthy_restoration_preserves_recovery_and_blocks_startup() {
let w = world(&[], true);
let env = Fake::ok();
env.automatic_rollback.set(true);
env.healthy.set(false);
env.recovery_healthy.set(false);
assert!(run(&w, &env, BTreeMap::new(), None)
.unwrap_err()
.to_string()
.contains("Recovery failed"));
let pending = unfinished(&w.meta).unwrap();
assert_eq!(pending.state, State::Failed);
assert!(txn_dir(&w.meta, &pending.id)
.unwrap()
.join("before")
.exists());
assert!(ensure_recovered(&w.meta).is_err());
}
#[test]
fn retrying_startup_commits_without_reapplying_sql_or_restoring_databases() {
let w = world(&[], true);
let env = Fake::ok();
env.healthy.set(false);
let out = run(&w, &env, BTreeMap::new(), None).unwrap();
let calls = env.calls.borrow().len();
env.healthy.set(true);
let done = retry_validation(
&w.root,
&w.meta,
&out.txn.id,
&Source::Dir(w.pkg.clone()),
&w.key,
&env,
)
.unwrap();
assert_eq!(done.state, State::Committed);
assert_eq!(done.recovery_point, out.txn.recovery_point);
assert_eq!(&env.calls.borrow()[calls..], &["stop", "validate"]);
assert!(unfinished(&w.meta).is_none());
assert_eq!(
MetaDir::open(&w.meta).unwrap().1.core.version.as_deref(),
Some("2.0.0")
);
}
#[test]
fn legacy_retry_uses_the_exact_signed_release_and_preserves_failure() {
let w = world(&[], false);
let env = Fake::ok();
env.healthy.set(false);
let out = run(&w, &env, BTreeMap::new(), None).unwrap();
let dir = txn_dir(&w.meta, &out.txn.id).unwrap();
fs::remove_file(dir.join("manifest.json")).unwrap();
fs::remove_file(dir.join("manifest.json.sig")).unwrap();
let pending = retry_validation(
&w.root,
&w.meta,
&out.txn.id,
&Source::Dir(w.pkg.clone()),
&w.key,
&env,
)
.unwrap();
assert_eq!(pending.state, State::NeedsDecision);
assert_eq!(pending.recovery_point, out.txn.recovery_point);
assert!(pending.message.unwrap().contains("worldserver exited"));
rollback(&w.root, &w.meta, &out.txn.id, &env).unwrap();
assert!(retry_validation(
&w.root,
&w.meta,
&out.txn.id,
&Source::Dir(w.pkg.clone()),
&w.key,
&env
)
.is_err());
}
#[test]
fn retry_rejects_modified_binaries_and_unsigned_manifests() {
let w = world(&[], false);
let env = Fake::ok();
env.healthy.set(false);
let out = run(&w, &env, BTreeMap::new(), None).unwrap();
write(&w.root, "Core/worldserver.exe", b"unexpected binary");
assert!(retry_validation(
&w.root,
&w.meta,
&out.txn.id,
&Source::Dir(w.pkg.clone()),
&w.key,
&env
)
.is_err());
write(&w.root, "Core/worldserver.exe", b"world-v2");
fs::write(
txn_dir(&w.meta, &out.txn.id)
.unwrap()
.join("manifest.json.sig"),
"invalid",
)
.unwrap();
assert!(retry_validation(
&w.root,
&w.meta,
&out.txn.id,
&Source::Dir(w.pkg.clone()),
&w.key,
&env
)
.is_err());
assert_eq!(unfinished(&w.meta).unwrap().state, State::NeedsDecision);
}
#[test]
fn crash_recovery_uses_the_journal() {
let w = world(&[], false);
// simulate a crash after two operations: run to failure, then reset the journal to a non-terminal state
run(&w, &Fake::ok(), BTreeMap::new(), Some(2)).unwrap_err();
let id = fs::read_dir(w.meta.join("updates"))
.unwrap()
.flatten()
.next()
.unwrap()
.file_name()
.to_string_lossy()
.into_owned();
// pretend the process died mid-apply: files are in the half-applied state again
write(&w.root, "Core/worldserver.exe", b"world-v2");
let mut t = load(&w.meta, &id).unwrap();
t.state = State::Applying;
for op in t.ops.iter_mut() {
op.started = op.path == "Core/worldserver.exe";
op.done &= op.started;
}
save(&w.meta, &t).unwrap();
assert_eq!(unfinished(&w.meta).unwrap().id, id);
rollback(&w.root, &w.meta, &id, &Fake::ok()).unwrap();
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
}
#[test]
fn a_running_server_or_failed_backup_blocks_the_update_before_any_change() {
let w = world(&[], false);
let env = Fake::ok();
env.stopped.set(false);
assert!(run(&w, &env, BTreeMap::new(), None).is_err());
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
let env = Fake::ok();
env.snapshot_ok.set(false);
let e = run(&w, &env, BTreeMap::new(), None).unwrap_err();
assert!(e.to_string().contains("safety backup failed"));
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
}
#[test]
fn a_failed_migration_undoes_the_files_and_reports_it() {
let w = world(&[], true);
let env = Fake::ok();
env.migrate_fail.set(true);
let e = run(&w, &env, BTreeMap::new(), None).unwrap_err();
assert!(e.to_string().contains("Database update m1 failed"));
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
assert!(env.calls.borrow().contains(&"restore-databases"));
assert!(
!env.calls.borrow().contains(&"validate"),
"the new build is never started after a failed migration"
);
let ok = Fake::ok();
let out = run(&w, &ok, BTreeMap::new(), None).unwrap();
assert_eq!(out.txn.state, State::Committed);
assert_eq!(
*ok.calls.borrow(),
["stop", "snapshot", "migrate", "validate"]
);
}
#[test]
fn failed_database_recovery_keeps_new_files_and_blocks_retry_until_recovered() {
let w = world(&[], true);
let env = Fake::ok();
env.migrate_fail.set(true);
env.restore_fail.set(true);
let error = run(&w, &env, BTreeMap::new(), None).unwrap_err();
assert!(error.to_string().contains("Recovery failed"));
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v2");
let pending = unfinished(&w.meta).unwrap();
assert_eq!(pending.state, State::Failed);
assert!(pending.databases_started);
assert!(txn_dir(&w.meta, &pending.id).unwrap().join("tree").exists());
assert!(run(&w, &Fake::ok(), BTreeMap::new(), None)
.unwrap_err()
.to_string()
.contains("unfinished"));
rollback(&w.root, &w.meta, &pending.id, &Fake::ok()).unwrap();
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
assert!(unfinished(&w.meta).is_none());
}
#[test]
fn interrupted_migration_is_restored_before_files_and_never_replayed() {
let w = world(&[], true);
let env = Fake::ok();
env.healthy.set(false);
let out = run(&w, &env, BTreeMap::new(), None).unwrap();
let recovery = Fake::ok();
rollback(&w.root, &w.meta, &out.txn.id, &recovery).unwrap();
assert_eq!(*recovery.calls.borrow(), ["stop", "restore-databases"]);
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
}
#[test]
fn concurrent_updates_are_rejected_without_changes() {
let w = world(&[], false);
let _lock = operation_lock(&w.meta).unwrap();
assert!(run(&w, &Fake::ok(), BTreeMap::new(), None)
.unwrap_err()
.to_string()
.contains("in progress"));
assert!(crate::driver::run(&w.root, crate::driver::Verb::StartAll)
.unwrap_err()
.to_string()
.contains("in progress"));
assert!(
crate::modules::set_enabled(&w.root, &w.meta, "companions", true)
.unwrap_err()
.to_string()
.contains("in progress")
);
assert!(
crate::realms::select(&w.root, crate::realms::Mode::Wildcard)
.unwrap_err()
.to_string()
.contains("in progress")
);
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
}
#[test]
fn legacy_completed_repair_is_accepted_only_with_verified_repaired_files() {
let w = world(&[], false);
let files = vec![FileEntry {
path: "Core/worldserver.exe".into(),
sha256: fsx::sha256_bytes(b"repaired"),
size: 8,
owner: crate::manifest::Owner::Core,
policy: ReplacePolicy::Replace,
}];
let mut txn = begin_repair(&w.root, &w.meta, "1.0.0", "full-backup", &files).unwrap();
write(&w.root, "Core/worldserver.exe", b"repaired");
repair_migrating(&w.meta, &mut txn).unwrap();
txn.state = State::Committed;
save(&w.meta, &txn).unwrap();
let original = fs::read(txn_dir(&w.meta, &txn.id).unwrap().join("txn.json")).unwrap();
write(&w.root, "Core/worldserver.exe", b"changed");
assert!(ensure_recovered(&w.meta).is_err());
write(&w.root, "Core/worldserver.exe", b"repaired");
ensure_recovered(&w.meta).unwrap();
assert!(load(&w.meta, &txn.id).unwrap().ops[0].done);
assert_eq!(
fs::read(
txn_dir(&w.meta, &txn.id)
.unwrap()
.join("txn-before-repair-completion.json")
)
.unwrap(),
original
);
write(
&w.root,
"Core/worldserver.exe",
b"a later legitimate update",
);
ensure_recovered(&w.meta).unwrap();
txn.ops[0].started = false;
save(&w.meta, &txn).unwrap();
assert!(ensure_recovered(&w.meta).is_err());
}
#[test]
fn changed_repair_backup_inventory_blocks_recovery_before_stopping_or_restoring() {
let w = world(&[], false);
let point = crate::backup::point_json(&w.meta, "full-backup").unwrap();
fsx::atomic_write(&point, b"original recovery inventory").unwrap();
let files = vec![FileEntry {
path: "Core/worldserver.exe".into(),
sha256: fsx::sha256_bytes(b"repaired"),
size: 8,
owner: crate::manifest::Owner::Core,
policy: ReplacePolicy::Replace,
}];
let mut txn = begin_repair(&w.root, &w.meta, "1.0.0", "full-backup", &files).unwrap();
write(&w.root, "Core/worldserver.exe", b"repaired");
repair_migrating(&w.meta, &mut txn).unwrap();
fsx::atomic_write(&point, b"changed recovery inventory").unwrap();
let env = Fake::ok();
assert!(finish_repair(&w.root, &w.meta, &mut txn, false, &env).is_err());
assert!(env.calls.borrow().is_empty());
assert_eq!(read(&w, "Core/worldserver.exe"), b"repaired");
assert!(ensure_recovered(&w.meta).is_err());
}
#[test]
fn failed_repair_recovery_keeps_a_failed_journal_and_its_reason() {
let w = world(&[], false);
let files = vec![FileEntry {
path: "Core/worldserver.exe".into(),
sha256: fsx::sha256_bytes(b"repaired"),
size: 8,
owner: crate::manifest::Owner::Core,
policy: ReplacePolicy::Replace,
}];
let mut txn = begin_repair(&w.root, &w.meta, "1.0.0", "full-backup", &files).unwrap();
write(&w.root, "Core/worldserver.exe", b"repaired");
repair_migrating(&w.meta, &mut txn).unwrap();
let env = Fake::ok();
env.restore_fail.set(true);
assert!(finish_repair(&w.root, &w.meta, &mut txn, false, &env).is_err());
let saved = load(&w.meta, &txn.id).unwrap();
assert_eq!(saved.state, State::Failed);
assert!(saved.message.unwrap().contains("Repair recovery failed"));
assert_eq!(saved.recovery_point.as_deref(), Some("full-backup"));
assert!(ensure_recovered(&w.meta).is_err());
}
#[test]
fn repair_cannot_commit_unverified_files() {
let w = world(&[], false);
let files = vec![FileEntry {
path: "Core/worldserver.exe".into(),
sha256: fsx::sha256_bytes(b"repaired"),
size: 8,
owner: crate::manifest::Owner::Core,
policy: ReplacePolicy::Replace,
}];
let mut txn = begin_repair(&w.root, &w.meta, "1.0.0", "full-backup", &files).unwrap();
assert!(finish_repair(&w.root, &w.meta, &mut txn, true, &Fake::ok()).is_err());
assert_eq!(load(&w.meta, &txn.id).unwrap().state, State::Applying);
assert_eq!(pending_checked(&w.meta).unwrap().unwrap().id, txn.id);
}
#[test]
fn successful_repair_leaves_a_readable_journal_and_allows_next_operation() {
let w = world(&[], false);
let files = vec![FileEntry {
path: "Core/worldserver.exe".into(),
sha256: fsx::sha256_bytes(b"repaired"),
size: 8,
owner: crate::manifest::Owner::Core,
policy: ReplacePolicy::Replace,
}];
let mut txn = begin_repair(&w.root, &w.meta, "1.0.0", "full-backup", &files).unwrap();
write(&w.root, "Core/worldserver.exe", b"repaired");
repair_migrating(&w.meta, &mut txn).unwrap();
finish_repair(&w.root, &w.meta, &mut txn, true, &Fake::ok()).unwrap();
let saved = load(&w.meta, &txn.id).unwrap();
assert_eq!(saved.state, State::Committed);
assert!(saved.ops.iter().all(|op| op.started && op.done));
ensure_recovered(&w.meta).unwrap();
assert_eq!(read(&w, "Core/worldserver.exe"), b"repaired");
}
#[test]
fn interrupted_repair_restores_files_databases_and_ownership_metadata() {
let w = world(&[], false);
let files = vec![
FileEntry {
path: "Core/worldserver.exe".into(),
sha256: fsx::sha256_bytes(b"repaired"),
size: 8,
owner: crate::manifest::Owner::Core,
policy: ReplacePolicy::Replace,
},
FileEntry {
path: "Core/repair-created.dll".into(),
sha256: fsx::sha256_bytes(b"created"),
size: 7,
owner: crate::manifest::Owner::Core,
policy: ReplacePolicy::Replace,
},
];
let mut txn = begin_repair(&w.root, &w.meta, "1.0.0", "full-backup", &files).unwrap();
write(&w.root, "Core/worldserver.exe", b"repaired");
write(&w.root, "Core/repair-created.dll", b"created");
repair_migrating(&w.meta, &mut txn).unwrap();
assert_eq!(unfinished(&w.meta).unwrap().id, txn.id);
let env = Fake::ok();
rollback(&w.root, &w.meta, &txn.id, &env).unwrap();
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
assert!(!w.root.join("Core/repair-created.dll").exists());
assert_eq!(*env.calls.borrow(), ["stop", "restore-databases"]);
assert!(unfinished(&w.meta).is_none());
}
#[test]
fn sql_manifest_mismatch_is_rejected_before_snapshot_or_replacement() {
let w = world(&[], true);
let manifest_path = w.pkg.join("manifest.json");
let mut manifest: Manifest = fsx::read_json(&manifest_path).unwrap();
manifest.migrations[0].sha256 = "a".repeat(64);
let bytes = serde_json::to_vec_pretty(&manifest).unwrap();
// A publisher mistake: valid signed archive bytes disagree with the SQL metadata.
let key = SigningKey::generate(&mut rand_core::OsRng);
let trusted =
base64::engine::general_purpose::STANDARD.encode(key.verifying_key().to_bytes());
fs::write(&manifest_path, &bytes).unwrap();
fs::write(
w.pkg.join("manifest.json.sig"),
base64::engine::general_purpose::STANDARD.encode(key.sign(&bytes).to_bytes()),
)
.unwrap();
let env = Fake::ok();
let error = apply(
&Params {
root: &w.root,
meta_dir: &w.meta,
source: Source::Dir(w.pkg.clone()),
trusted_key: &trusted,
cancel: Default::default(),
resolutions: Default::default(),
env: &env,
fail_after_ops: None,
},
&|_, _| {},
)
.unwrap_err();
assert!(
matches!(error, Error::HashMismatch { .. }),
"Expected SQL metadata mismatch, received {error}"
);
assert!(env.calls.borrow().is_empty());
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
assert!(pending_checked(&w.meta).unwrap().is_none());
}
#[test]
fn preflight_rejection_precedes_snapshot_and_file_changes() {
let w = world(&[], true);
let env = Fake::ok();
env.preflight_fail.set(true);
let original = fsx::sha256_file(&w.meta.join("install.json")).unwrap();
assert!(run(&w, &env, BTreeMap::new(), None)
.unwrap_err()
.to_string()
.contains("Conflicting migration history"));
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
assert_eq!(
fsx::sha256_file(&w.meta.join("install.json")).unwrap(),
original
);
assert!(env.calls.borrow().is_empty());
assert!(fs::read_dir(w.meta.join("updates"))
.unwrap()
.next()
.is_none());
}
#[test]
fn update_saves_recovery_then_migrates_and_validates_once() {
let w = world(&[], true);
let env = Fake::ok();
let result = run(&w, &env, BTreeMap::new(), None).unwrap();
assert_eq!(result.txn.state, State::Committed);
let calls = env.calls.borrow();
assert_eq!(calls.iter().filter(|call| **call == "snapshot").count(), 1);
assert_eq!(calls.iter().filter(|call| **call == "migrate").count(), 1);
assert_eq!(calls.iter().filter(|call| **call == "validate").count(), 1);
assert!(
calls.iter().position(|call| *call == "snapshot")
< calls.iter().position(|call| *call == "migrate")
);
assert!(!w.meta.join("rehearsals").exists());
}
#[test]
fn missing_and_semantically_corrupt_journals_block_operations() {
let w = world(&[], false);
let txn = run(&w, &Fake::ok(), BTreeMap::new(), None).unwrap().txn;
let path = txn_dir(&w.meta, &txn.id).unwrap().join("txn.json");
let mut bad = txn.clone();
bad.id = "another-update".into();
fsx::atomic_write_json(&path, &bad).unwrap();
assert!(pending_checked(&w.meta).is_err());
bad = txn.clone();
bad.ops[0].path = "../outside".into();
fsx::atomic_write_json(&path, &bad).unwrap();
assert!(ensure_recovered(&w.meta).is_err());
bad = txn.clone();
bad.ops[0].started = false;
fsx::atomic_write_json(&path, &bad).unwrap();
assert!(ensure_recovered(&w.meta).is_err());
fs::remove_file(&path).unwrap();
assert!(pending_checked(&w.meta).is_err());
let marker = cleanup_marker(&w.meta, &txn.id).unwrap();
fsx::atomic_write_json(
&marker,
&CleanupMarker {
id: txn.id,
state: State::Committed,
},
)
.unwrap();
assert!(pending_checked(&w.meta).unwrap().is_none());
}
#[test]
fn damaged_saved_file_blocks_restore_before_any_environment_action() {
let w = world(&[], false);
let env = Fake::ok();
env.healthy.set(false);
let txn = run(&w, &env, BTreeMap::new(), None).unwrap().txn;
let before = txn_dir(&w.meta, &txn.id).unwrap().join("before");
write(&before, "Core/worldserver.exe", b"damaged original");
env.calls.borrow_mut().clear();
assert!(rollback(&w.root, &w.meta, &txn.id, &env)
.unwrap_err()
.to_string()
.contains("damaged"));
assert!(env.calls.borrow().is_empty());
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v2");
assert_eq!(
pending_checked(&w.meta).unwrap().unwrap().state,
State::NeedsDecision
);
}
#[test]
fn unreadable_update_journal_blocks_changes_and_startup() {
let w = world(&[], false);
write(&w.meta, "updates/broken/txn.json", b"{truncated");
assert!(run(&w, &Fake::ok(), BTreeMap::new(), None)
.unwrap_err()
.to_string()
.contains("cannot be read"));
assert!(crate::driver::run(&w.root, crate::driver::Verb::StartAll)
.unwrap_err()
.to_string()
.contains("cannot be read"));
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
}
#[test]
fn crash_during_commit_restores_the_original_installation_metadata() {
let w = world(&[], false);
let env = Fake::ok();
env.healthy.set(false);
let out = run(&w, &env, BTreeMap::new(), None).unwrap();
let (_, mut meta) = MetaDir::open(&w.meta).unwrap();
meta.core.version = Some("2.0.0".into());
meta.core.commit = Some("a".repeat(40));
fsx::atomic_write_json(&w.meta.join("install.json"), &meta).unwrap();
rollback(&w.root, &w.meta, &out.txn.id, &Fake::ok()).unwrap();
let (_, restored) = MetaDir::open(&w.meta).unwrap();
assert_eq!(restored.core.version.as_deref(), Some("1.0.0"));
assert_eq!(restored.core.commit, None);
}
#[test]
fn bad_signature_and_wrong_package_kind_change_nothing() {
let w = world(&[], false);
let other = SigningKey::generate(&mut rand_core::OsRng);
let wrong_key =
base64::engine::general_purpose::STANDARD.encode(other.verifying_key().to_bytes());
let env = Fake::ok();
let r = apply(
&Params {
root: &w.root,
meta_dir: &w.meta,
source: Source::Dir(w.pkg.clone()),
trusted_key: &wrong_key,
cancel: Cancel::default(),
resolutions: BTreeMap::new(),
env: &env,
fail_after_ops: None,
},
&|_, _| {},
);
assert!(r.is_err());
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
assert!(env.calls.borrow().is_empty());
let (_, meta) = MetaDir::open(&w.meta).unwrap();
let p = preview(
&w.root,
&meta,
&Source::Dir(w.pkg.clone()),
&w.key,
&BTreeMap::new(),
)
.unwrap();
assert_eq!(p.to_version, "2.0.0");
assert!(p
.items
.iter()
.any(|i| i.path == "Core/newfile.dll" && i.action == Action::Create));
}
fn baseline_fixture() -> crate::character_start_check::Baseline {
crate::character_start_check::Baseline {
schema: 1,
realms: BTreeMap::from([(
"coa".into(),
crate::character_start_check::parse_missing("1\t44\t14\n2\t44\t14\n3\t44\t14")
.unwrap(),
)]),
}
}
#[test]
fn character_baseline_is_captured_once_persisted_and_verified_for_retry() {
let w = world(&[], true);
let env = Fake::ok();
*env.character_baseline.borrow_mut() = Some(baseline_fixture());
env.healthy.set(false);
let out = run(&w, &env, BTreeMap::new(), None).unwrap();
assert_eq!(out.txn.state, State::NeedsDecision);
assert_eq!(out.preexisting_character_count, 3);
let baseline_path = txn_dir(&w.meta, &out.txn.id)
.unwrap()
.join(CHARACTER_BASELINE);
let original = fs::read(&baseline_path).unwrap();
assert_eq!(
read_character_baseline(&w.meta, &out.txn)
.unwrap()
.unwrap()
.realms["coa"]
.len(),
3
);
// A retry may not learn new gaps from an already modified database.
*env.character_baseline.borrow_mut() = None;
env.healthy.set(true);
fs::write(&baseline_path, b"{}").unwrap();
assert!(retry_validation(
&w.root,
&w.meta,
&out.txn.id,
&Source::Dir(w.pkg.clone()),
&w.key,
&env
)
.is_err());
fs::write(&baseline_path, original).unwrap();
let done = retry_validation(
&w.root,
&w.meta,
&out.txn.id,
&Source::Dir(w.pkg.clone()),
&w.key,
&env,
)
.unwrap();
assert_eq!(done.state, State::Committed);
}
#[test]
fn corrupt_character_baseline_does_not_prevent_safe_rollback() {
let w = world(&[], true);
let env = Fake::ok();
*env.character_baseline.borrow_mut() = Some(baseline_fixture());
env.healthy.set(false);
let out = run(&w, &env, BTreeMap::new(), None).unwrap();
fs::write(
txn_dir(&w.meta, &out.txn.id)
.unwrap()
.join(CHARACTER_BASELINE),
b"bad",
)
.unwrap();
let restored = rollback(&w.root, &w.meta, &out.txn.id, &env).unwrap();
assert_eq!(restored.state, State::RolledBack);
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
}
#[test]
fn missing_or_unverified_character_baselines_fail_closed() {
let w = world(&[], true);
let env = Fake::ok();
env.healthy.set(false);
let out = run(&w, &env, BTreeMap::new(), None).unwrap();
assert!(read_character_baseline(&w.meta, &out.txn)
.unwrap()
.is_none());
let path = txn_dir(&w.meta, &out.txn.id)
.unwrap()
.join(CHARACTER_BASELINE);
fsx::atomic_write_json(&path, &baseline_fixture()).unwrap();
assert!(read_character_baseline(&w.meta, &out.txn).is_err());
let mut txn = out.txn;
txn.recovery_hashes.insert(
CHARACTER_BASELINE_HASH.into(),
fsx::sha256_file(&path).unwrap(),
);
fs::remove_file(path).unwrap();
assert!(read_character_baseline(&w.meta, &txn).is_err());
}
#[test]
fn baseline_capture_failure_precedes_file_and_database_changes() {
let w = world(&[], true);
let env = Fake::ok();
env.baseline_failed.set(true);
assert!(run(&w, &env, BTreeMap::new(), None).is_err());
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
assert!(!env.calls.borrow().contains(&"migrate"));
assert!(!env.calls.borrow().contains(&"validate"));
assert!(unfinished(&w.meta).is_none());
}
}