mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-22 03:25:56 +00:00
Merge origin/master into feat/portable-characters
This commit is contained in:
commit
65ace578f7
60 files changed
+1563
-112
No files matched your search
@@ -27,7 +27,18 @@ const LIST_SQL: &str = "SELECT a.id, a.username, \
|
||||
a.online, IFNULL(a.last_login, ''), \
|
||||
(SELECT COUNT(*) FROM acore_characters.characters c WHERE c.account = a.id) \
|
||||
FROM acore_auth.account a \
|
||||
WHERE a.username NOT LIKE 'COABOTHOST%' AND a.username <> 'COAMANAGER' ORDER BY a.id;";
|
||||
WHERE a.username NOT LIKE 'COABOTHOST%' AND a.username <> 'COAMANAGER' AND a.username NOT LIKE '{SQUID}%' ORDER BY a.id;";
|
||||
|
||||
/// The accounts of SQUID's random bots share a name prefix (`AiPlayerbot.RandomBotAccountPrefix`, default `rndbot`).
|
||||
/// They belong to the bot system like the companions' accounts and are never listed or touched here.
|
||||
pub fn squid_bot_prefix(root: &Path) -> String {
|
||||
std::fs::read(root.join("Core/configs/modules/playerbots.conf"))
|
||||
.ok()
|
||||
.and_then(|bytes| crate::config::parser::ConfFile::parse_bytes(&bytes).ok())
|
||||
.and_then(|conf| conf.get("AiPlayerbot.RandomBotAccountPrefix").map(|v| crate::config::parser::unquote(v).to_string()))
|
||||
.filter(|prefix| !prefix.is_empty() && prefix.len() <= 32 && prefix.chars().all(|c| c.is_ascii_alphanumeric()))
|
||||
.unwrap_or_else(|| "rndbot".into())
|
||||
}
|
||||
|
||||
/// Rows of tab-separated columns as the `mysql` client prints them.
|
||||
pub fn parse_list(out: &str) -> Vec<AccountInfo> {
|
||||
@@ -51,7 +62,7 @@ pub fn parse_list(out: &str) -> Vec<AccountInfo> {
|
||||
|
||||
pub fn list(root: &Path) -> Result<Vec<AccountInfo>> {
|
||||
let db = Db::from_repack(root, Account::Admin)?;
|
||||
Ok(parse_list(&db.query(LIST_SQL)?))
|
||||
Ok(parse_list(&db.query(&LIST_SQL.replace("{SQUID}", &squid_bot_prefix(root).to_ascii_uppercase()))?))
|
||||
}
|
||||
|
||||
fn upper(name: &str) -> Result<String> {
|
||||
@@ -64,6 +75,9 @@ fn upper(name: &str) -> Result<String> {
|
||||
pub fn rename(root: &Path, ra: &mut Ra, old: &str, new: &str, password: &str) -> Result<()> {
|
||||
let (old, new) = (upper(old)?, upper(new)?);
|
||||
validate_account(&new, password)?;
|
||||
if is_reserved(&old) || old.starts_with(&squid_bot_prefix(root).to_ascii_uppercase()) {
|
||||
return Err(Error::Invalid("This account belongs to the Manager or the bots and cannot be renamed.".into()));
|
||||
}
|
||||
if old == new {
|
||||
return Err(Error::Invalid("That is already the name of this account.".into()));
|
||||
}
|
||||
@@ -93,8 +107,8 @@ fn is_reserved(upper_name: &str) -> bool {
|
||||
/// companions' own accounts, an account that is not there and one that is logged in right now.
|
||||
pub fn delete(root: &Path, ra: &mut Ra, name: &str) -> Result<()> {
|
||||
let name = upper(name)?;
|
||||
if is_reserved(&name) {
|
||||
return Err(Error::Invalid("This account belongs to the Manager or the companions and cannot be deleted.".into()));
|
||||
if is_reserved(&name) || name.starts_with(&squid_bot_prefix(root).to_ascii_uppercase()) {
|
||||
return Err(Error::Invalid("This account belongs to the Manager or the bots and cannot be deleted.".into()));
|
||||
}
|
||||
let db = Db::from_repack(root, Account::Admin)?;
|
||||
match db.query(&format!("SELECT online FROM acore_auth.account WHERE username = '{name}';"))?.trim() {
|
||||
@@ -125,7 +139,19 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn the_internal_accounts_are_filtered_out_by_the_query() {
|
||||
assert!(LIST_SQL.contains("COABOTHOST%") && LIST_SQL.contains("COAMANAGER"));
|
||||
assert!(LIST_SQL.contains("COABOTHOST%") && LIST_SQL.contains("COAMANAGER") && LIST_SQL.contains("{SQUID}%"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_squid_bot_prefix_comes_from_the_bot_settings_and_defaults_to_rndbot() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
assert_eq!(squid_bot_prefix(root.path()), "rndbot");
|
||||
let conf = root.path().join("Core/configs/modules/playerbots.conf");
|
||||
std::fs::create_dir_all(conf.parent().unwrap()).unwrap();
|
||||
std::fs::write(&conf, "AiPlayerbot.RandomBotAccountPrefix = \"MyBots\"\n").unwrap();
|
||||
assert_eq!(squid_bot_prefix(root.path()), "MyBots");
|
||||
std::fs::write(&conf, "AiPlayerbot.RandomBotAccountPrefix = \"x' OR 1=1 --\"\n").unwrap();
|
||||
assert_eq!(squid_bot_prefix(root.path()), "rndbot", "an unsafe prefix is ignored");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -69,10 +69,82 @@ pub struct RecoveryPoint {
|
||||
pub realm: crate::realms::Mode,
|
||||
}
|
||||
|
||||
fn backups_dir(meta: &Path) -> PathBuf {
|
||||
const LOCATION_FILE: &str = "backup-location.json";
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct StoredLocation {
|
||||
path: String,
|
||||
}
|
||||
|
||||
fn default_dir(meta: &Path) -> PathBuf {
|
||||
meta.join("backups")
|
||||
}
|
||||
|
||||
/// The folder the owner chose for backups (for example on another drive), if any.
|
||||
fn custom_dir(meta: &Path) -> Option<PathBuf> {
|
||||
let stored: StoredLocation = fsx::read_json(&meta.join(LOCATION_FILE)).ok()?;
|
||||
let path = PathBuf::from(stored.path.trim());
|
||||
path.is_absolute().then_some(path)
|
||||
}
|
||||
|
||||
/// Where new backups go.
|
||||
fn backups_dir(meta: &Path) -> PathBuf {
|
||||
custom_dir(meta).unwrap_or_else(|| default_dir(meta))
|
||||
}
|
||||
|
||||
/// Every folder that may hold backups: the chosen one first, then the default one, so backups made before the
|
||||
/// folder was changed stay visible and restorable.
|
||||
fn backup_roots(meta: &Path) -> Vec<PathBuf> {
|
||||
let mut roots: Vec<PathBuf> = custom_dir(meta).into_iter().collect();
|
||||
let default = default_dir(meta);
|
||||
if !roots.contains(&default) { roots.push(default); }
|
||||
roots
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub struct BackupLocation {
|
||||
pub path: String,
|
||||
pub default_path: String,
|
||||
pub is_default: bool,
|
||||
}
|
||||
|
||||
pub fn location(meta: &Path) -> BackupLocation {
|
||||
let default = default_dir(meta);
|
||||
let current = backups_dir(meta);
|
||||
BackupLocation { is_default: current == default, path: current.to_string_lossy().into_owned(), default_path: default.to_string_lossy().into_owned() }
|
||||
}
|
||||
|
||||
/// Choose where new backups are stored (`None` = the default folder next to the server). Existing backups stay where
|
||||
/// they are and remain listed.
|
||||
pub fn set_location(root: &Path, meta: &Path, path: Option<&str>) -> Result<BackupLocation> {
|
||||
let _lock = crate::update::operation_lock(meta)?;
|
||||
crate::update::ensure_recovered(meta)?;
|
||||
match path.map(str::trim).filter(|p| !p.is_empty()) {
|
||||
None => {
|
||||
let file = meta.join(LOCATION_FILE);
|
||||
if file.exists() { fs::remove_file(file)?; }
|
||||
}
|
||||
Some(chosen) => {
|
||||
let dir = PathBuf::from(chosen);
|
||||
if !dir.is_absolute() { return Err(Error::Invalid("Choose a full folder path, for example D:\\CoA backups.".into())); }
|
||||
if fsx::ensure_within(root, &dir).is_ok() {
|
||||
return Err(Error::Invalid("Backups cannot be stored inside the server folder: they would be part of what is being backed up.".into()));
|
||||
}
|
||||
fs::create_dir_all(&dir).map_err(|e| Error::Invalid(format!("The folder cannot be created: {e}")))?;
|
||||
let probe = dir.join(format!(".coa-write-test-{}", uuid::Uuid::new_v4().simple()));
|
||||
fs::write(&probe, b"x").map_err(|e| Error::Invalid(format!("The folder is not writable: {e}")))?;
|
||||
let _ = fs::remove_file(&probe);
|
||||
fsx::atomic_write_json(&meta.join(LOCATION_FILE), &StoredLocation { path: dir.to_string_lossy().into_owned() })?;
|
||||
}
|
||||
}
|
||||
Ok(location(meta))
|
||||
}
|
||||
|
||||
/// The `backup.json` of a recovery point, wherever its folder is.
|
||||
pub(crate) fn point_json(meta: &Path, id: &str) -> Result<PathBuf> {
|
||||
Ok(point_dir(meta, id)?.join("backup.json"))
|
||||
}
|
||||
|
||||
fn id_ok(id: &str) -> bool {
|
||||
!id.is_empty() && id.len() < 100 && id.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '.')) && !id.contains("..")
|
||||
}
|
||||
@@ -81,19 +153,32 @@ fn point_dir(meta: &Path, id: &str) -> Result<PathBuf> {
|
||||
if !id_ok(id) {
|
||||
return Err(Error::PathRejected(format!("bad backup id {id:?}")));
|
||||
}
|
||||
if let Some(found) = backup_roots(meta).into_iter().map(|root| root.join(id)).find(|dir| dir.is_dir()) {
|
||||
return Ok(found);
|
||||
}
|
||||
Ok(backups_dir(meta).join(id))
|
||||
}
|
||||
|
||||
pub fn list(meta: &Path) -> Vec<RecoveryPoint> {
|
||||
let mut out: Vec<RecoveryPoint> = fs::read_dir(backups_dir(meta))
|
||||
.map(|rd| rd.filter_map(|e| e.ok()).filter_map(|e| fsx::read_json(&e.path().join("backup.json")).ok()).collect())
|
||||
.unwrap_or_default();
|
||||
let mut out: Vec<RecoveryPoint> = Vec::new();
|
||||
for root in backup_roots(meta) {
|
||||
let found: Vec<RecoveryPoint> = fs::read_dir(&root)
|
||||
.map(|rd| rd.filter_map(|e| e.ok()).filter_map(|e| fsx::read_json(&e.path().join("backup.json")).ok()).collect())
|
||||
.unwrap_or_default();
|
||||
for point in found {
|
||||
if !out.iter().any(|p| p.id == point.id) { out.push(point); }
|
||||
}
|
||||
}
|
||||
out.sort_by(|a, b| b.id.cmp(&a.id));
|
||||
out
|
||||
}
|
||||
|
||||
pub fn get(meta: &Path, id: &str) -> Result<RecoveryPoint> {
|
||||
let point: RecoveryPoint = fsx::read_json(&fsx::ensure_within(meta, &point_dir(meta, id)?.join("backup.json"))?).map_err(|_| Error::Invalid(format!("backup {id} was not found or its metadata is damaged")))?;
|
||||
let dir = point_dir(meta, id)?;
|
||||
// The folder holding the backups may itself be a junction or symlink to another drive (the owner moved it there);
|
||||
// what must hold is that the recovery point stays inside that folder.
|
||||
let holder = dir.parent().ok_or_else(|| Error::PathRejected(format!("bad backup folder for {id}")))?;
|
||||
let point: RecoveryPoint = fsx::read_json(&fsx::ensure_within(holder, &dir.join("backup.json"))?).map_err(|_| Error::Invalid(format!("backup {id} was not found or its metadata is damaged")))?;
|
||||
if point.id != id || point.schema != 1 { return Err(Error::Invalid(format!("Backup {id} has inconsistent identity or an unsupported schema."))); }
|
||||
Ok(point)
|
||||
}
|
||||
@@ -163,7 +248,8 @@ pub fn with_database<T>(root: &Path, f: impl FnOnce(&Db) -> Result<T>) -> Result
|
||||
if !mysql_was_up {
|
||||
let out = driver::run(root, Verb::StartMysql)?;
|
||||
if !out.ok {
|
||||
return Err(Error::Invalid(out.human.map(|h| h.title.to_string()).unwrap_or_else(|| "The database could not be started.".into())));
|
||||
// Keep the launcher's own last lines: the title alone ("Something went wrong") hides the cause.
|
||||
return Err(Error::Invalid(format!("The database could not be started. {}", driver::startup_failure(root, &out))));
|
||||
}
|
||||
}
|
||||
let result = f(&db);
|
||||
@@ -176,6 +262,14 @@ pub fn with_database<T>(root: &Path, f: impl FnOnce(&Db) -> Result<T>) -> Result
|
||||
result
|
||||
}
|
||||
|
||||
/// Run `f` only if the database is already up; `None` (and nothing started) otherwise.
|
||||
pub fn with_running_database<T>(root: &Path, f: impl FnOnce(&Db) -> Result<T>) -> Result<Option<T>> {
|
||||
let db = Db::from_repack(root, Account::Admin)?;
|
||||
let observed = process::observe(root, &read_ports(root));
|
||||
if observed.mysql.state != ServiceState::Running || !db.ping() { return Ok(None); }
|
||||
f(&db).map(Some)
|
||||
}
|
||||
|
||||
fn wanted_databases(kind: Kind) -> &'static [&'static str] {
|
||||
match kind {
|
||||
Kind::Quick | Kind::Database => &["characters", "auth"],
|
||||
@@ -490,6 +584,34 @@ mod tests {
|
||||
assert!(list(&meta).len() >= 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn backups_can_live_in_a_chosen_folder_and_old_ones_stay_visible() {
|
||||
let (d, root, meta) = setup();
|
||||
let before = create(&root, &meta, Kind::Config, Trigger::Manual, Some("default folder".into()), &|_| {}).unwrap();
|
||||
assert!(location(&meta).is_default);
|
||||
|
||||
// inside the server folder is refused, a relative path is refused
|
||||
assert!(set_location(&root, &meta, Some(root.join("backups").to_str().unwrap())).is_err());
|
||||
assert!(set_location(&root, &meta, Some("backups")).is_err());
|
||||
|
||||
let elsewhere = d.path().join("other drive").join("CoA backups");
|
||||
let loc = set_location(&root, &meta, Some(elsewhere.to_str().unwrap())).unwrap();
|
||||
assert!(!loc.is_default && elsewhere.is_dir());
|
||||
let after = create(&root, &meta, Kind::Config, Trigger::Manual, Some("chosen folder".into()), &|_| {}).unwrap();
|
||||
assert!(elsewhere.join(&after.id).join("backup.json").is_file(), "new backups go to the chosen folder");
|
||||
assert!(!default_dir(&meta).join(&after.id).exists());
|
||||
let ids: Vec<_> = list(&meta).into_iter().map(|p| p.id).collect();
|
||||
assert!(ids.contains(&before.id) && ids.contains(&after.id), "the old backup is still listed");
|
||||
assert!(verify(&meta, &before.id).unwrap().ok && verify(&meta, &after.id).unwrap().ok);
|
||||
assert_eq!(point_json(&meta, &after.id).unwrap(), elsewhere.join(&after.id).join("backup.json"));
|
||||
restore_configs(&root, &meta, &after.id).unwrap();
|
||||
delete(&meta, &after.id).unwrap();
|
||||
assert!(!elsewhere.join(&after.id).exists());
|
||||
|
||||
assert!(set_location(&root, &meta, None).unwrap().is_default);
|
||||
assert!(list(&meta).iter().any(|p| p.id == before.id));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn verify_detects_tampering_and_restore_refuses_damaged_backup() {
|
||||
let (_d, root, meta) = setup();
|
||||
|
||||
@@ -0,0 +1,382 @@
|
||||
//! SQUID's bot dashboard (<https://github.com/Zyth45/squidbots-dashboard>): a small web page, written in Python with
|
||||
//! no dependencies, that shows where the bots are and what they do. It is kept in `Extras/SquidDashboard` of the server
|
||||
//! folder and always comes from the release that matches the installed SQUID bots (same major and minor version), so the
|
||||
//! page and the bots agree on what the database and the logs contain.
|
||||
//!
|
||||
//! The dashboard finds the repack by itself (`Settings/database.json` and `Settings/repack.json` two folders up), so the
|
||||
//! Manager only has to download it and start it on a free port. Only the process the Manager started and recorded is ever
|
||||
//! stopped, identified by PID and creation time.
|
||||
|
||||
use std::io::Read;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::error::{Error, Result};
|
||||
use crate::fsx;
|
||||
use crate::process::{self, ProcessIdentity};
|
||||
|
||||
const REPO: &str = "Zyth45/squidbots-dashboard";
|
||||
const DIR: &str = "Extras/SquidDashboard";
|
||||
const MARKER: &str = ".manager-dashboard.json";
|
||||
const PROCESS: &str = ".manager-dashboard-process.json";
|
||||
const FIRST_PORT: u16 = 8088;
|
||||
const MAX_ARCHIVE: u64 = 60 * 1024 * 1024;
|
||||
const MAX_UNPACKED: u64 = 150 * 1024 * 1024;
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
struct Marker {
|
||||
/// The dashboard release that is installed.
|
||||
tag: String,
|
||||
/// The SQUID release it was chosen for.
|
||||
squid_tag: String,
|
||||
port: u16,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub struct Status {
|
||||
pub installed: bool,
|
||||
/// Dashboard release installed.
|
||||
pub tag: Option<String>,
|
||||
/// SQUID bots release found in the server.
|
||||
pub squid_tag: Option<String>,
|
||||
/// The installed dashboard belongs to the installed bots' release series.
|
||||
pub matches: bool,
|
||||
pub running: bool,
|
||||
pub port: u16,
|
||||
pub url: String,
|
||||
}
|
||||
|
||||
fn dir(root: &Path) -> PathBuf {
|
||||
root.join(DIR)
|
||||
}
|
||||
|
||||
fn read_marker(root: &Path) -> Option<Marker> {
|
||||
fsx::read_json(&dir(root).join(MARKER)).ok()
|
||||
}
|
||||
|
||||
/// `v1.9.1` -> `[1, 9, 1]`.
|
||||
fn parse_tag(tag: &str) -> Option<Vec<u32>> {
|
||||
let parts: Vec<u32> = tag.trim().trim_start_matches('v').split('.').map(|p| p.parse().ok()).collect::<Option<_>>()?;
|
||||
(parts.len() >= 2).then_some(parts)
|
||||
}
|
||||
|
||||
/// Same major and minor version.
|
||||
fn same_series(a: &str, b: &str) -> bool {
|
||||
matches!((parse_tag(a), parse_tag(b)), (Some(a), Some(b)) if a[..2] == b[..2])
|
||||
}
|
||||
|
||||
/// The newest dashboard release of the bots' series (`v1.9` serves bots `v1.9` and `v1.9.1`).
|
||||
fn pick_tag(squid_tag: &str, available: &[String]) -> Option<String> {
|
||||
available.iter()
|
||||
.filter(|tag| same_series(tag, squid_tag))
|
||||
.max_by_key(|tag| parse_tag(tag).unwrap_or_default())
|
||||
.cloned()
|
||||
}
|
||||
|
||||
fn safe_tag(tag: &str) -> bool {
|
||||
!tag.is_empty() && tag.len() <= 40 && tag.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '-'))
|
||||
}
|
||||
|
||||
fn squid_tag(root: &Path) -> Option<String> {
|
||||
crate::squid::release(root).and_then(|r| r.tag).filter(|t| safe_tag(t))
|
||||
}
|
||||
|
||||
fn record_alive(root: &Path) -> Option<ProcessIdentity> {
|
||||
let record: ProcessIdentity = fsx::read_json(&dir(root).join(PROCESS)).ok()?;
|
||||
let inside = Path::new(&record.exe).starts_with(root);
|
||||
(inside && process::is_alive(&record)).then_some(record)
|
||||
}
|
||||
|
||||
pub fn status(root: &Path) -> Status {
|
||||
let marker = read_marker(root);
|
||||
let installed = dir(root).join("squidbots.py").is_file() && marker.is_some();
|
||||
let squid = squid_tag(root);
|
||||
let port = marker.as_ref().map(|m| m.port).unwrap_or(FIRST_PORT);
|
||||
let running = installed && record_alive(root).is_some_and(|r| process::listeners().iter().any(|(p, pid)| *p == port && *pid == r.pid));
|
||||
Status {
|
||||
installed,
|
||||
matches: matches!((&marker, &squid), (Some(m), Some(s)) if same_series(&m.tag, s)),
|
||||
tag: marker.map(|m| m.tag),
|
||||
squid_tag: squid,
|
||||
running,
|
||||
port,
|
||||
url: format!("http://127.0.0.1:{port}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn http() -> Result<reqwest::blocking::Client> {
|
||||
reqwest::blocking::Client::builder()
|
||||
.user_agent(concat!("CoA-Server-Manager/", env!("CARGO_PKG_VERSION")))
|
||||
.timeout(std::time::Duration::from_secs(120))
|
||||
.build()
|
||||
.map_err(|e| Error::Invalid(format!("Cannot prepare the download: {e}")))
|
||||
}
|
||||
|
||||
fn download_error(e: impl std::fmt::Display) -> Error {
|
||||
Error::NetworkUnreachable(e.to_string())
|
||||
}
|
||||
|
||||
fn available_tags(client: &reqwest::blocking::Client) -> Result<Vec<String>> {
|
||||
#[derive(Deserialize)]
|
||||
struct Tag { name: String }
|
||||
let response = client.get(format!("https://api.github.com/repos/{REPO}/tags?per_page=100")).send().map_err(download_error)?;
|
||||
if !response.status().is_success() { return Err(download_error(format!("GitHub answered {}", response.status()))); }
|
||||
let tags: Vec<Tag> = serde_json::from_str(&response.text().map_err(download_error)?).map_err(download_error)?;
|
||||
Ok(tags.into_iter().map(|t| t.name).filter(|t| safe_tag(t)).collect())
|
||||
}
|
||||
|
||||
/// Download the dashboard release that matches the installed bots and unpack it. A running dashboard is stopped first;
|
||||
/// maps the owner extracted and other files of theirs are left alone.
|
||||
pub fn install(root: &Path, report: &dyn Fn(&str)) -> Result<Status> {
|
||||
let squid = squid_tag(root).ok_or_else(|| Error::Invalid("The version of the SQUID bots could not be read, so the matching dashboard cannot be chosen.".into()))?;
|
||||
report("Looking for the matching dashboard");
|
||||
let client = http()?;
|
||||
let tag = pick_tag(&squid, &available_tags(&client)?)
|
||||
.ok_or_else(|| Error::Invalid(format!("There is no dashboard release for SQUID bots {squid} yet.")))?;
|
||||
report("Downloading the dashboard");
|
||||
let response = client.get(format!("https://codeload.github.com/{REPO}/zip/refs/tags/{tag}")).send().map_err(download_error)?;
|
||||
if !response.status().is_success() { return Err(download_error(format!("GitHub answered {}", response.status()))); }
|
||||
let mut bytes = Vec::new();
|
||||
response.take(MAX_ARCHIVE + 1).read_to_end(&mut bytes).map_err(download_error)?;
|
||||
if bytes.len() as u64 > MAX_ARCHIVE { return Err(Error::Invalid("The dashboard download is larger than expected and was rejected.".into())); }
|
||||
|
||||
stop(root)?;
|
||||
report("Unpacking the dashboard");
|
||||
let target = dir(root);
|
||||
std::fs::create_dir_all(&target)?;
|
||||
let mut archive = zip::ZipArchive::new(std::io::Cursor::new(bytes)).map_err(|e| Error::Invalid(format!("The dashboard download is damaged: {e}")))?;
|
||||
let mut total = 0u64;
|
||||
let mut wrote_main = false;
|
||||
for index in 0..archive.len() {
|
||||
let mut file = archive.by_index(index).map_err(|e| Error::Invalid(format!("The dashboard download is damaged: {e}")))?;
|
||||
if file.is_dir() { continue; }
|
||||
// GitHub wraps everything in one folder named after the repository and release.
|
||||
let Some(relative) = file.name().split_once('/').map(|(_, rest)| rest.to_string()) else { continue; };
|
||||
if relative.is_empty() || relative.starts_with(".github/") || relative.starts_with("docs/") { continue; }
|
||||
total += file.size();
|
||||
if total > MAX_UNPACKED { return Err(Error::Invalid("The dashboard download unpacks to more than expected and was rejected.".into())); }
|
||||
let destination = fsx::safe_join(&target, &relative)?;
|
||||
let mut content = Vec::with_capacity(file.size() as usize);
|
||||
file.read_to_end(&mut content)?;
|
||||
fsx::atomic_write(&destination, &content)?;
|
||||
wrote_main |= relative == "squidbots.py";
|
||||
}
|
||||
if !wrote_main { return Err(Error::Invalid("The dashboard download did not contain the dashboard.".into())); }
|
||||
let port = read_marker(root).map(|m| m.port).unwrap_or(FIRST_PORT);
|
||||
fsx::atomic_write_json(&target.join(MARKER), &Marker { tag, squid_tag: squid, port })?;
|
||||
Ok(status(root))
|
||||
}
|
||||
|
||||
fn free_port(preferred: u16) -> Result<u16> {
|
||||
let used: Vec<u16> = process::listeners().into_iter().map(|(port, _)| port).collect();
|
||||
std::iter::once(preferred).chain(FIRST_PORT..FIRST_PORT + 40).find(|p| !used.contains(p))
|
||||
.ok_or_else(|| Error::Invalid("No free port was found for the dashboard.".into()))
|
||||
}
|
||||
|
||||
/// A crash or power loss while the dashboard saves its history can leave a file of the right length that holds only
|
||||
/// zero bytes, and the dashboard then fails to start on it. Those files carry nothing, and the dashboard recreates them,
|
||||
/// so they are removed. The files that come with the release are never touched here (reinstalling restores them).
|
||||
fn discard_damaged_data(folder: &Path) -> Vec<String> {
|
||||
const SHIPPED: &[&str] = &["worldmap.json", "dashboard.example.json"];
|
||||
let mut removed = Vec::new();
|
||||
let Ok(entries) = std::fs::read_dir(folder) else { return removed; };
|
||||
for entry in entries.flatten() {
|
||||
let name = entry.file_name().to_string_lossy().into_owned();
|
||||
let path = entry.path();
|
||||
if !name.ends_with(".json") || name.starts_with('.') || SHIPPED.contains(&name.as_str()) || !path.is_file() { continue; }
|
||||
let Ok(bytes) = std::fs::read(&path) else { continue; };
|
||||
if !bytes.is_empty() && bytes.iter().all(|b| *b == 0) && std::fs::remove_file(&path).is_ok() {
|
||||
tracing::warn!(file = %path.display(), "dashboard: removed a data file damaged by an interrupted write");
|
||||
removed.push(name);
|
||||
}
|
||||
}
|
||||
removed
|
||||
}
|
||||
|
||||
/// The dashboard reads `coa-level-builds.json` (class and specialization names) from its own folder; the CoA Bots repack
|
||||
/// ships it, the GitHub release does not. The server's own reference file has the same content and shape.
|
||||
fn ensure_builds_file(root: &Path) {
|
||||
let target = dir(root).join("coa-level-builds.json");
|
||||
if target.is_file() { return; }
|
||||
let reference = root.join("Core/reference/ascensionsidekick-level-builds.json");
|
||||
let content = std::fs::read(&reference).ok().filter(|bytes| serde_json::from_slice::<serde_json::Value>(bytes).is_ok_and(|v| v.is_object()));
|
||||
let _ = fsx::atomic_write(&target, content.as_deref().unwrap_or(b"{}"));
|
||||
}
|
||||
|
||||
/// Python's HTTP server closes each connection with `shutdown(SHUT_WR)` straight after the answer. On Windows that can
|
||||
/// throw away what is still queued: any answer above about 64 KB (the dashboard's statistics are 400 KB) arrives cut
|
||||
/// off, and the page fails to load. This small launcher waits for the client to finish reading and close instead, queues
|
||||
/// more waiting connections than Python's five, and then runs the dashboard unchanged.
|
||||
const LAUNCHER: &str = r#"import runpy, socketserver, sys, http.server
|
||||
|
||||
http.server.ThreadingHTTPServer.request_queue_size = 256
|
||||
|
||||
|
||||
def shutdown_request(self, request):
|
||||
try:
|
||||
request.settimeout(5)
|
||||
while request.recv(4096):
|
||||
pass
|
||||
except OSError:
|
||||
pass
|
||||
self.close_request(request)
|
||||
|
||||
|
||||
socketserver.TCPServer.shutdown_request = shutdown_request
|
||||
script = sys.argv[1]
|
||||
sys.argv = [script]
|
||||
runpy.run_path(script, run_name="__main__")
|
||||
"#;
|
||||
|
||||
/// Start the dashboard with the repack's own Python. Returns when it answers on its port.
|
||||
pub fn start(root: &Path) -> Result<Status> {
|
||||
let current = status(root);
|
||||
if !current.installed { return Err(Error::Invalid("The dashboard is not installed.".into())); }
|
||||
if current.running { return Ok(current); }
|
||||
let python = root.join("Runtime/python/python.exe");
|
||||
if !python.is_file() { return Err(Error::Invalid("This server has no bundled Python, so the dashboard cannot run.".into())); }
|
||||
let folder = dir(root);
|
||||
let mut marker = read_marker(root).ok_or_else(|| Error::Invalid("The dashboard installation is incomplete.".into()))?;
|
||||
marker.port = free_port(marker.port)?;
|
||||
fsx::atomic_write_json(&folder.join(MARKER), &marker)?;
|
||||
|
||||
let log_path = folder.join("dashboard.log");
|
||||
let log = std::fs::File::create(&log_path)?;
|
||||
let mut command = std::process::Command::new(&python);
|
||||
ensure_builds_file(root);
|
||||
discard_damaged_data(&folder);
|
||||
let script = folder.join("squidbots.py");
|
||||
let launcher = folder.join("manager_launch.py");
|
||||
fsx::atomic_write(&launcher, LAUNCHER.as_bytes())?;
|
||||
command.arg("-B").arg(&launcher).arg(&script).current_dir(&folder).env("COA_DASHBOARD_PORT", marker.port.to_string())
|
||||
.stdin(std::process::Stdio::null()).stdout(log.try_clone()?).stderr(log);
|
||||
#[cfg(windows)]
|
||||
{
|
||||
use std::os::windows::process::CommandExt;
|
||||
command.creation_flags(0x0800_0000); // CREATE_NO_WINDOW
|
||||
}
|
||||
let mut child = command.spawn()?;
|
||||
let identity = process::identity(child.id()).ok_or_else(|| Error::Invalid("The dashboard exited at once.".into()))?;
|
||||
fsx::atomic_write_json(&folder.join(PROCESS), &identity)?;
|
||||
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(20);
|
||||
loop {
|
||||
if process::listeners().iter().any(|(port, pid)| *port == marker.port && *pid == identity.pid) { return Ok(status(root)); }
|
||||
if let Ok(Some(_)) = child.try_wait() {
|
||||
let _ = std::fs::remove_file(folder.join(PROCESS));
|
||||
let tail = std::fs::read_to_string(&log_path).unwrap_or_default();
|
||||
let lines: Vec<&str> = tail.lines().rev().take(8).collect();
|
||||
return Err(Error::Invalid(format!("The dashboard stopped right after starting. {}", lines.into_iter().rev().collect::<Vec<_>>().join("\n"))));
|
||||
}
|
||||
if std::time::Instant::now() > deadline {
|
||||
let _ = stop(root);
|
||||
return Err(Error::Invalid("The dashboard did not start in time. See Extras/SquidDashboard/dashboard.log.".into()));
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(300));
|
||||
}
|
||||
}
|
||||
|
||||
/// Stop the dashboard this Manager started (by recorded PID and creation time, never by name).
|
||||
pub fn stop(root: &Path) -> Result<()> {
|
||||
let record_file = dir(root).join(PROCESS);
|
||||
if let Some(record) = record_alive(root) {
|
||||
let mut command = std::process::Command::new("taskkill");
|
||||
command.args(["/PID", &record.pid.to_string(), "/T", "/F"]).stdout(std::process::Stdio::null()).stderr(std::process::Stdio::null());
|
||||
#[cfg(windows)]
|
||||
{
|
||||
use std::os::windows::process::CommandExt;
|
||||
command.creation_flags(0x0800_0000);
|
||||
}
|
||||
let _ = command.status();
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
|
||||
while process::is_alive(&record) && std::time::Instant::now() < deadline {
|
||||
std::thread::sleep(std::time::Duration::from_millis(200));
|
||||
}
|
||||
if process::is_alive(&record) { return Err(Error::Invalid("The dashboard could not be stopped.".into())); }
|
||||
}
|
||||
let _ = std::fs::remove_file(record_file);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn tags(list: &[&str]) -> Vec<String> { list.iter().map(|s| s.to_string()).collect() }
|
||||
|
||||
#[test]
|
||||
fn the_dashboard_follows_the_bots_release_series() {
|
||||
let available = tags(&["v1.8", "v1.9", "v1.9.2", "v2.0"]);
|
||||
assert_eq!(pick_tag("v1.9", &available).as_deref(), Some("v1.9.2"), "the newest of the same series");
|
||||
assert_eq!(pick_tag("v1.9.1", &tags(&["v1.8", "v1.9"])).as_deref(), Some("v1.9"), "bots 1.9.1 use dashboard 1.9");
|
||||
assert_eq!(pick_tag("v1.8.1", &available).as_deref(), Some("v1.8"));
|
||||
assert_eq!(pick_tag("v1.10", &available), None, "a later series has none yet");
|
||||
assert_eq!(pick_tag("main", &available), None);
|
||||
assert!(same_series("v1.9", "v1.9.1") && !same_series("v1.9", "v1.8.9"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zero_filled_history_files_are_removed_but_shipped_and_valid_files_stay() {
|
||||
let folder = tempfile::tempdir().unwrap();
|
||||
std::fs::write(folder.path().join("history.json"), vec![0u8; 358]).unwrap();
|
||||
std::fs::write(folder.path().join("levels.json"), vec![0u8; 100]).unwrap();
|
||||
std::fs::write(folder.path().join("xp-history.json"), "[1, 2]").unwrap();
|
||||
std::fs::write(folder.path().join("worldmap.json"), vec![0u8; 50]).unwrap();
|
||||
std::fs::write(folder.path().join("empty.json"), "").unwrap();
|
||||
let mut removed = discard_damaged_data(folder.path());
|
||||
removed.sort();
|
||||
assert_eq!(removed, ["history.json", "levels.json"]);
|
||||
assert!(folder.path().join("xp-history.json").exists() && folder.path().join("worldmap.json").exists() && folder.path().join("empty.json").exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tags_are_checked_before_they_reach_a_url() {
|
||||
assert!(safe_tag("v1.9.1") && !safe_tag("v1.9/../x") && !safe_tag("") && !safe_tag("a b"));
|
||||
}
|
||||
|
||||
/// Needs the network: `cargo test -p coa-core dashboard -- --ignored`.
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn the_matching_release_is_downloaded_and_unpacked() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
let settings = root.path().join("Core/configs/modules/playerbots.conf.settings.json");
|
||||
fsx::atomic_write(&settings, br#"{"format":1,"tag":"v1.9.1","settings":[]}"#).unwrap();
|
||||
let installed = install(root.path(), &|step| println!("{step}")).unwrap();
|
||||
assert!(installed.installed && installed.matches);
|
||||
assert_eq!(installed.tag.as_deref(), Some("v1.9"));
|
||||
assert!(root.path().join("Extras/SquidDashboard/squidbots.py").is_file());
|
||||
assert!(!installed.running);
|
||||
}
|
||||
|
||||
/// Needs a real server folder (`COA_TEST_ROOT`) whose bots are installed and whose database runs:
|
||||
/// `COA_TEST_ROOT=... cargo test -p coa-core dashboard -- --ignored --nocapture`.
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn the_started_dashboard_delivers_its_large_statistics() {
|
||||
let root = PathBuf::from(std::env::var("COA_TEST_ROOT").expect("COA_TEST_ROOT"));
|
||||
let started = start(&root).unwrap();
|
||||
assert!(started.running, "{started:?}");
|
||||
let client = reqwest::blocking::Client::builder().timeout(std::time::Duration::from_secs(90)).build().unwrap();
|
||||
let body = client.get(format!("{}/api/stats", started.url)).send().unwrap().bytes().unwrap();
|
||||
println!("stats: {} bytes: {}", body.len(), String::from_utf8_lossy(&body[..body.len().min(300)]));
|
||||
let live = client.get(format!("{}/api/live", started.url)).send().unwrap().bytes().unwrap();
|
||||
stop(&root).unwrap();
|
||||
assert!(!status(&root).running);
|
||||
if String::from_utf8_lossy(&body).starts_with("{\"error\"") {
|
||||
println!("the database of this server is not running, so the large answer could not be checked");
|
||||
} else {
|
||||
assert!(body.len() > 100_000, "the statistics must arrive whole, got {} bytes", body.len());
|
||||
}
|
||||
assert!(!live.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_folder_without_the_dashboard_is_not_installed_or_running() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
let s = status(root.path());
|
||||
assert!(!s.installed && !s.running && !s.matches);
|
||||
assert!(start(root.path()).is_err());
|
||||
assert!(stop(root.path()).is_ok());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
//! The disposable database a release is validated against, on a Linux computer.
|
||||
//!
|
||||
//! A release is checked by applying its database changes to the database of the signed base package. The base carries the
|
||||
//! MySQL data directory of a Windows repack, and a MySQL 8.4 server in Docker opens it as it is (with the repack's table
|
||||
//! name setting). So the fixture is a Docker server folder whose database container uses that directory in place of a
|
||||
//! volume; everything else (start, SQL, schema capture, dumps) is the code of a Docker installation.
|
||||
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
|
||||
use super::{Config, Docker, MARKER, MYSQL_IMAGE};
|
||||
use crate::driver::{self, Verb};
|
||||
use crate::error::{Error, Result};
|
||||
use crate::{fsx, install, package};
|
||||
|
||||
/// Turn an extracted base package (`mysql/data`, `Settings/`) into a Docker server folder and start its database.
|
||||
pub fn prepare(root: &Path) -> Result<()> {
|
||||
prepare_with(&super::SystemDocker, root)
|
||||
}
|
||||
|
||||
pub(crate) fn prepare_with(d: &dyn Docker, root: &Path) -> Result<()> {
|
||||
let boot = root.join(package::BOOTSTRAP_CREDENTIALS);
|
||||
if !boot.is_file() {
|
||||
return Err(Error::Invalid("The package has no database bootstrap information.".into()));
|
||||
}
|
||||
let secrets: serde_json::Value = fsx::read_json(&boot)?;
|
||||
let root_pw = secrets["rootPassword"].as_str().filter(|p| p.chars().all(|c| c.is_ascii_hexdigit()) && !p.is_empty())
|
||||
.ok_or_else(|| Error::Invalid("The database bootstrap information is not usable.".into()))?.to_string();
|
||||
fs::copy(&boot, root.join("Settings/database.json"))?;
|
||||
let data = fs::canonicalize(root.join("mysql/data"))
|
||||
.map_err(|_| Error::Invalid("The package has no database data directory.".into()))?;
|
||||
let cfg = Config {
|
||||
project: format!("schema-{}", install::random_hex(8)),
|
||||
bind_address: "127.0.0.1".into(),
|
||||
mysql_image: MYSQL_IMAGE.into(),
|
||||
data_dir: None,
|
||||
mysql_data: Some(data.to_string_lossy().into_owned()),
|
||||
};
|
||||
fsx::atomic_write_json(&root.join(MARKER), &cfg)?;
|
||||
|
||||
let started = driver::run(root, Verb::StartMysql)?;
|
||||
if !started.ok {
|
||||
return Err(Error::Invalid(started.human.map(|h| h.message.to_string()).unwrap_or_else(|| "The database could not be started.".into())));
|
||||
}
|
||||
// The repack's administrator account only exists for connections from the server itself (the socket); the Manager
|
||||
// connects over TCP. The fixture is thrown away, so the account is simply added.
|
||||
let sql = format!("CREATE USER IF NOT EXISTS 'root'@'127.0.0.1' IDENTIFIED BY '{root_pw}'; GRANT ALL ON *.* TO 'root'@'127.0.0.1' WITH GRANT OPTION;");
|
||||
let mut call = super::Call::new(&["exec", "-i", "-e", "MYSQL_PWD", &cfg.names().db, "mysql", "--user=root"], std::time::Duration::from_secs(60));
|
||||
call.env = vec![("MYSQL_PWD".into(), root_pw)];
|
||||
call.stdin = Some(sql.as_bytes());
|
||||
let o = d.run(&call)?;
|
||||
if !o.ok() {
|
||||
return Err(Error::Invalid(format!("The fixture database could not be opened to the Manager: {}", o.text())));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn a_package_without_bootstrap_information_is_refused_before_anything_starts() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let err = prepare(dir.path()).unwrap_err();
|
||||
assert!(err.to_string().contains("bootstrap"), "{err}");
|
||||
assert!(!dir.path().join(MARKER).exists());
|
||||
}
|
||||
}
|
||||
@@ -146,7 +146,7 @@ fn write_settings(root: &Path, data_dir: &Path) -> Result<Settings> {
|
||||
let (auth, world, ra) = (pick_port(DEFAULT_PORTS.0)?, pick_port(DEFAULT_PORTS.1)?, pick_port(DEFAULT_PORTS.2)?);
|
||||
let (root_password, app_password) = (random_hex(48), random_hex(48));
|
||||
fs::create_dir_all(root.join("Settings"))?;
|
||||
let docker = Config { project, bind_address: "127.0.0.1".into(), mysql_image: super::MYSQL_IMAGE.into(), data_dir: Some(data_dir.to_string_lossy().into_owned()) };
|
||||
let docker = Config { project, bind_address: "127.0.0.1".into(), mysql_image: super::MYSQL_IMAGE.into(), data_dir: Some(data_dir.to_string_lossy().into_owned()), mysql_data: None };
|
||||
fsx::atomic_write_json(&root.join(MARKER), &docker)?;
|
||||
// Same file and keys as a repack, so the console, the ports and the settings screens work unchanged. The database is
|
||||
// not published on the host; its port is only there to fill the key.
|
||||
|
||||
@@ -210,7 +210,7 @@ fn start(d: &dyn Docker, root: &Path, cfg: &Config, with_game: bool, log: &mut L
|
||||
if !state.get(&n.db).is_some_and(Container::running) {
|
||||
remove(d, &n.db);
|
||||
let mut call = Call::new(&[], Duration::from_secs(120));
|
||||
call.args = db_args(cfg, &n);
|
||||
call.args = db_args(cfg, &n, owner_of(root).as_deref());
|
||||
call.env = vec![("MYSQL_ROOT_PASSWORD".into(), secrets.root.clone())];
|
||||
let o = d.run(&call).or_else(|e| fail(ErrorCode::DockerUnavailable, e.to_string()))?;
|
||||
if !o.ok() {
|
||||
@@ -333,12 +333,22 @@ fn connect_ip(cfg: &Config) -> IpAddr {
|
||||
|
||||
// ------------------------------------------------------------------------------------------------- argument lists
|
||||
|
||||
fn db_args(cfg: &Config, n: &Names) -> Vec<String> {
|
||||
fn db_args(cfg: &Config, n: &Names, owner: Option<&str>) -> Vec<String> {
|
||||
let mut a: Vec<String> = ["run", "--detach", "--name"].iter().map(|s| s.to_string()).collect();
|
||||
a.push(n.db.clone());
|
||||
a.extend(["--network".into(), n.network.clone(), "--network-alias".into(), "db".into()]);
|
||||
a.extend(["--label".into(), format!("coa.project={}", cfg.project)]);
|
||||
a.extend(["--volume".into(), format!("{}:/var/lib/mysql", n.volume)]);
|
||||
match &cfg.mysql_data {
|
||||
Some(dir) => {
|
||||
// A data directory from a Windows repack: it is written by the person who owns the folder, and its table names
|
||||
// were folded to lower case (the repack's setting), which the server must be told because a Linux one does not.
|
||||
a.extend(["--volume".into(), format!("{dir}:/var/lib/mysql")]);
|
||||
if let Some(o) = owner {
|
||||
a.extend(["--user".into(), o.into()]);
|
||||
}
|
||||
}
|
||||
None => a.extend(["--volume".into(), format!("{}:/var/lib/mysql", n.volume)]),
|
||||
}
|
||||
// The password comes from the environment of the docker client, not from this command line.
|
||||
a.extend(["--env".into(), "MYSQL_ROOT_PASSWORD".into()]);
|
||||
// "mysqladmin ping" succeeds as soon as the server answers, with or without a login. It must go over TCP, like
|
||||
@@ -349,6 +359,9 @@ fn db_args(cfg: &Config, n: &Names) -> Vec<String> {
|
||||
a.extend(["--health-interval".into(), "5s".into(), "--health-timeout".into(), "5s".into(), "--health-retries".into(), "40".into()]);
|
||||
a.extend(["--stop-timeout".into(), "60".into()]);
|
||||
a.push(cfg.mysql_image.clone());
|
||||
if cfg.mysql_data.is_some() {
|
||||
a.push("--lower-case-table-names=1".into());
|
||||
}
|
||||
a
|
||||
}
|
||||
|
||||
@@ -698,6 +711,28 @@ mod tests {
|
||||
assert!(runs[1].args.windows(2).any(|w| w == ["--env", "AC_WORLD_DATABASE_INFO"]), "name only, the value is in the environment");
|
||||
}
|
||||
|
||||
// Unix only: the folder is a Linux path (a Windows path has a colon, which a Docker folder may not).
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_release_fixture_runs_its_database_on_the_package_data_directory_not_on_a_volume() {
|
||||
let (_d, root) = server("t1");
|
||||
fs::write(root.join("Settings/docker.json"), r#"{"project":"t1","mysqlData":"/work/fixture/mysql/data"}"#).unwrap();
|
||||
let sim = Sim::new();
|
||||
assert!(run_with(&sim, &root, Verb::StartMysql).unwrap().ok);
|
||||
let db = &sim.calls_of("run")[0].args;
|
||||
assert!(db.windows(2).any(|w| w == ["--volume", "/work/fixture/mysql/data:/var/lib/mysql"]), "{db:?}");
|
||||
assert!(!db.iter().any(|a| a.starts_with("coa-t1-db:")), "no named volume: {db:?}");
|
||||
assert!(db.iter().any(|a| a == "--user"), "the folder is written by its owner");
|
||||
assert_eq!(db.last().map(String::as_str), Some("--lower-case-table-names=1"), "a server option, so after the image name");
|
||||
// An installation never gets any of it.
|
||||
let (_d2, root2) = server("t2");
|
||||
let sim2 = Sim::new();
|
||||
assert!(run_with(&sim2, &root2, Verb::StartMysql).unwrap().ok);
|
||||
let plain = &sim2.calls_of("run")[0].args;
|
||||
assert!(plain.windows(2).any(|w| w == ["--volume", "coa-t2-db:/var/lib/mysql"]), "{plain:?}");
|
||||
assert!(!plain.iter().any(|a| a == "--lower-case-table-names=1" || a == "--user"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_database_is_only_healthy_once_it_takes_tcp_connections() {
|
||||
let (_d, root) = server("t1");
|
||||
|
||||
@@ -15,6 +15,7 @@
|
||||
//! ```
|
||||
|
||||
mod cli;
|
||||
pub mod fixture;
|
||||
pub mod install;
|
||||
mod lifecycle;
|
||||
|
||||
@@ -63,6 +64,10 @@ pub struct Config {
|
||||
/// mounted read-only, so one copy can serve several servers.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub data_dir: Option<String>,
|
||||
/// A MySQL data directory the database container uses in place of its volume. Only for the disposable fixture that
|
||||
/// validates a release (the data directory of the signed base package); an installation never sets it.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub mysql_data: Option<String>,
|
||||
}
|
||||
|
||||
pub(crate) struct Names {
|
||||
@@ -96,10 +101,10 @@ impl Config {
|
||||
if self.bind_address.parse::<IpAddr>().is_err() {
|
||||
return Err(Error::Invalid(format!("{} is not an IP address.", self.bind_address)));
|
||||
}
|
||||
if let Some(d) = &self.data_dir {
|
||||
// The folder goes into a `--volume host:container:ro` option, where a colon would be read as a separator.
|
||||
for d in [&self.data_dir, &self.mysql_data].into_iter().flatten() {
|
||||
// The folder goes into a `--volume host:container` option, where a colon would be read as a separator.
|
||||
if !Path::new(d).is_absolute() || d.contains(':') {
|
||||
return Err(Error::Invalid("The game data folder must be a full path without a colon.".into()));
|
||||
return Err(Error::Invalid("A Docker folder must be a full path without a colon.".into()));
|
||||
}
|
||||
}
|
||||
let image_ok = !self.mysql_image.is_empty() && self.mysql_image.chars().all(|c| c.is_ascii_alphanumeric() || "._/:@-".contains(c));
|
||||
|
||||
@@ -136,6 +136,7 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
|
||||
}
|
||||
}
|
||||
}
|
||||
discard_damaged_launcher_state(&root);
|
||||
let mut cmd = Command::new(&python);
|
||||
cmd.arg("-B").arg("-c").arg(LAUNCH_SCRIPT).arg(&script).arg(verb.arg())
|
||||
.current_dir(&root).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped());
|
||||
@@ -188,10 +189,34 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
|
||||
}
|
||||
};
|
||||
tracing::info!(?verb, ok, ?code, "driver: launcher verb finished");
|
||||
if !ok && !output.is_empty() {
|
||||
let redacted = crate::diag::redact(&output);
|
||||
let tail: Vec<_> = redacted.lines().rev().take(12).collect();
|
||||
tracing::warn!(?verb, exit_code, output = %tail.into_iter().rev().collect::<Vec<_>>().join("\n"), "driver: launcher verb failed");
|
||||
}
|
||||
if ok && verb == Verb::StartAll { crate::multiworld::start(&root)?; }
|
||||
Ok(DriverOutcome { ok, exit_code, code, human: code.map(ErrorCode::human), output })
|
||||
}
|
||||
|
||||
/// The launcher keeps one JSON record per service in `.state`. A crash or power loss while it writes one can leave
|
||||
/// a file of the right length that holds only zero bytes (NTFS keeps the length but not the data), and the launcher
|
||||
/// then dies on every start with an unreadable record. Such a file carries no information, so remove it: the
|
||||
/// launcher treats a missing record as "not running". Only empty or all-zero `*.json` files are touched.
|
||||
pub(crate) fn discard_damaged_launcher_state(root: &Path) -> Vec<PathBuf> {
|
||||
let mut removed = Vec::new();
|
||||
let Ok(entries) = std::fs::read_dir(root.join(".state")) else { return removed; };
|
||||
for entry in entries.flatten() {
|
||||
let path = entry.path();
|
||||
if path.extension().is_none_or(|e| !e.eq_ignore_ascii_case("json")) || !path.is_file() { continue; }
|
||||
let Ok(bytes) = std::fs::read(&path) else { continue; };
|
||||
if bytes.iter().all(|b| *b == 0) && std::fs::remove_file(&path).is_ok() {
|
||||
tracing::warn!(file = %path.display(), bytes = bytes.len(), "driver: removed a launcher state file damaged by an interrupted write");
|
||||
removed.push(path);
|
||||
}
|
||||
}
|
||||
removed
|
||||
}
|
||||
|
||||
const LAUNCH_SCRIPT: &str = "import runpy,sys;from pathlib import Path;script=sys.argv[1];sys.path.insert(0,str(Path(script).resolve().parent));sys.argv=sys.argv[1:];runpy.run_path(script,run_name='__main__')";
|
||||
|
||||
pub(crate) fn patch_launcher_imports(text: &str) -> Result<String> {
|
||||
@@ -251,6 +276,24 @@ mod tests {
|
||||
assert_eq!(Verb::StartWorld.timeout(folder.path()), Duration::from_secs(420));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zero_filled_launcher_state_is_discarded_and_valid_state_is_kept() {
|
||||
let folder = tempfile::tempdir().unwrap();
|
||||
let state = folder.path().join(".state");
|
||||
std::fs::create_dir_all(&state).unwrap();
|
||||
std::fs::write(state.join("mysql.json"), vec![0u8; 116]).unwrap();
|
||||
std::fs::write(state.join("configuration.json"), Vec::<u8>::new()).unwrap();
|
||||
std::fs::write(state.join("world.json"), "{\"pid\": 4}\n").unwrap();
|
||||
std::fs::write(state.join("stop-relay"), Vec::<u8>::new()).unwrap();
|
||||
std::fs::write(state.join("auth.json"), "{\"pid\": 0}").unwrap();
|
||||
let mut removed: Vec<_> = discard_damaged_launcher_state(folder.path()).iter().map(|p| p.file_name().unwrap().to_string_lossy().into_owned()).collect();
|
||||
removed.sort();
|
||||
assert_eq!(removed, ["configuration.json", "mysql.json"]);
|
||||
assert!(state.join("world.json").exists() && state.join("auth.json").exists() && state.join("stop-relay").exists());
|
||||
assert!(discard_damaged_launcher_state(folder.path()).is_empty());
|
||||
assert!(discard_damaged_launcher_state(&folder.path().join("missing")).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn translates_known_launcher_messages() {
|
||||
assert_eq!(translate("RuntimeError: Port 8085 is already used. Stop the other server"), ErrorCode::PortInUse);
|
||||
|
||||
@@ -183,7 +183,7 @@ fn bootstrap_database_inner(root: &Path) -> Result<()> {
|
||||
|
||||
let started = driver::run(root, Verb::StartMysql)?;
|
||||
if !started.ok {
|
||||
return Err(Error::Invalid(started.human.map(|h| h.message.to_string()).unwrap_or_else(|| "The database could not be started.".into())));
|
||||
return Err(Error::Invalid(format!("The database could not be started. {}", driver::startup_failure(root, &started))));
|
||||
}
|
||||
let result = (|| -> Result<()> {
|
||||
let db = Db::from_repack(root, Account::Admin)?;
|
||||
@@ -210,8 +210,14 @@ fn bootstrap_database_inner(root: &Path) -> Result<()> {
|
||||
}
|
||||
Ok(())
|
||||
})();
|
||||
let _ = driver::run(root, Verb::StopAll);
|
||||
let stopped = driver::run(root, Verb::StopAll);
|
||||
result?;
|
||||
// A database that keeps running locks its files, and the folder could not be moved into place afterwards.
|
||||
match stopped {
|
||||
Ok(out) if out.ok => {}
|
||||
Ok(out) => return Err(Error::Invalid(format!("The database could not be stopped after preparing it. {}", driver::startup_failure(root, &out)))),
|
||||
Err(e) => return Err(e),
|
||||
}
|
||||
fs::remove_file(&boot)?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -250,7 +256,7 @@ pub fn install_base(p: &Params, report: &dyn Fn(Step)) -> Result<Installed> {
|
||||
if staging_root.join(MARKER).is_file() {
|
||||
fs::remove_dir_all(&staging_root)?; // leftover of an earlier failed attempt that we created
|
||||
} else {
|
||||
return Err(Error::Invalid(format!("{} already exists and was not created by the Manager.", staging_root.display())));
|
||||
return Err(Error::Invalid(format!("{} is left over from an earlier installation that did not finish, and the Manager cannot tell whether it may be deleted. Delete that folder yourself, then try again.", staging_root.display())));
|
||||
}
|
||||
}
|
||||
fs::create_dir_all(&staging_root)?;
|
||||
@@ -268,9 +274,8 @@ pub fn install_base(p: &Params, report: &dyn Fn(Step)) -> Result<Installed> {
|
||||
}
|
||||
Ok(())
|
||||
})?;
|
||||
fs::remove_file(staging_root.join(MARKER))?;
|
||||
|
||||
// 4. Commit: the only moment the destination changes.
|
||||
// 4. Commit: the only moment the destination changes. The marker stays until everything is done, so an
|
||||
// unfinished install can always be recognised as ours (and cleaned up), wherever it stopped.
|
||||
say("Finishing", 95, None);
|
||||
if dest.exists() {
|
||||
fs::remove_dir(&dest)?; // only succeeds for an empty folder (preflight verified)
|
||||
@@ -288,15 +293,24 @@ pub fn install_base(p: &Params, report: &dyn Fn(Step)) -> Result<Installed> {
|
||||
}
|
||||
let md = MetaDir::create(&dest, &meta)?;
|
||||
fsx::atomic_write(&md.root.join("manifests").join("base.json"), &manifest_bytes)?;
|
||||
// Complete from here on: the marker goes just before the server is listed.
|
||||
fs::remove_file(dest.join(MARKER))?;
|
||||
p.registry.register(&meta.id, &dest)?;
|
||||
say("Ready", 100, None);
|
||||
Ok(Installed { id: meta.id, path: dest.to_string_lossy().into_owned(), version: m.version.clone() })
|
||||
})();
|
||||
|
||||
if result.is_err() && staging_root.join(MARKER).exists() {
|
||||
// Unfinished work of ours; the destination was never touched.
|
||||
let _ = driver::run(&staging_root, Verb::StopAll);
|
||||
let _ = fs::remove_dir_all(&staging_root);
|
||||
if result.is_err() {
|
||||
if staging_root.join(MARKER).exists() {
|
||||
// Unfinished work of ours; the destination was never touched.
|
||||
let _ = driver::run(&staging_root, Verb::StopAll);
|
||||
let _ = fs::remove_dir_all(&staging_root);
|
||||
} else if dest.join(MARKER).is_file() {
|
||||
// Failed after the folder was moved into place. The destination was empty or absent before (preflight),
|
||||
// so what carries our marker is only our unfinished install.
|
||||
let _ = driver::run(&dest, Verb::StopAll);
|
||||
let _ = fs::remove_dir_all(&dest);
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
@@ -8,6 +8,7 @@ pub mod clientdl;
|
||||
pub mod config;
|
||||
pub mod control;
|
||||
pub mod console;
|
||||
pub mod dashboard;
|
||||
pub mod db;
|
||||
pub mod diag;
|
||||
pub mod docker;
|
||||
|
||||
@@ -154,9 +154,26 @@ fn recorded<'a>(rows: &'a [LedgerRow], m: &Migration) -> Option<&'a LedgerRow> {
|
||||
rows.iter().rev().find(|r| r.db == m.db && r.id == m.id)
|
||||
}
|
||||
|
||||
/// Migrations that were published with different bytes but have the same effect, so a server that applied either
|
||||
/// version accepts the other. The Wildcard table repair went out as `c1d8…` (0.261005.0, 0.261006.1) and as `9e4a…`
|
||||
/// (0.261005.22, 0.261007.24); the packages carry no list of compatible versions, so the Manager knows this pair.
|
||||
const SAME_EFFECT: &[(&str, &[&str])] = &[(
|
||||
"manager_repair__20261005_missing_wildcard_tables",
|
||||
&[
|
||||
"c1d8dbf2271234283a48a39e4b4aea1106b83b70581f1e3c4aa9fff438e8e4d2",
|
||||
"9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638",
|
||||
],
|
||||
)];
|
||||
|
||||
fn same_effect(id: &str, a: &str, b: &str) -> bool {
|
||||
SAME_EFFECT.iter().any(|(known, hashes)| *known == id
|
||||
&& hashes.iter().any(|h| h.eq_ignore_ascii_case(a)) && hashes.iter().any(|h| h.eq_ignore_ascii_case(b)))
|
||||
}
|
||||
|
||||
fn hash_changed(row: &LedgerRow, m: &Migration) -> bool {
|
||||
row.status == Status::Applied && row.sha256 != "0".repeat(64) && !row.sha256.eq_ignore_ascii_case(&m.sha256)
|
||||
&& !m.compatible_sha256.iter().any(|hash| hash.eq_ignore_ascii_case(&row.sha256))
|
||||
&& !same_effect(&m.id, &row.sha256, &m.sha256)
|
||||
}
|
||||
|
||||
/// Inspect recorded history without creating a ledger or executing migrations.
|
||||
@@ -275,6 +292,18 @@ mod tests {
|
||||
use super::*;
|
||||
use std::cell::RefCell;
|
||||
|
||||
#[test]
|
||||
fn the_two_published_versions_of_the_wildcard_table_repair_are_interchangeable() {
|
||||
let (old, new) = ("c1d8dbf2271234283a48a39e4b4aea1106b83b70581f1e3c4aa9fff438e8e4d2", "9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638");
|
||||
let id = "manager_repair__20261005_missing_wildcard_tables";
|
||||
let row = |id: &str, sha: &str| LedgerRow { db: "characters".into(), id: id.into(), sha256: sha.into(), status: Status::Applied, error: None, baseline: false };
|
||||
let migration = |id: &str, sha: &str| Migration { compatible_sha256: vec![], id: id.into(), db: "characters".into(), sha256: sha.into(), destructive: false };
|
||||
assert!(!hash_changed(&row(id, old), &migration(id, new)), "applied as c1d8, offered as 9e4a");
|
||||
assert!(!hash_changed(&row(id, new), &migration(id, old)), "applied as 9e4a, offered as c1d8");
|
||||
assert!(hash_changed(&row(id, &"a".repeat(64)), &migration(id, new)), "an unknown version is still a change");
|
||||
assert!(hash_changed(&row("other_migration", old), &migration("other_migration", new)), "only the known pair is exempt");
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Mem {
|
||||
rows: RefCell<Vec<LedgerRow>>,
|
||||
|
||||
@@ -278,12 +278,24 @@ fn uptime_secs(p: &ProcessIdentity) -> Option<u64> {
|
||||
(now >= p.created).then(|| (now - p.created) / 10_000_000)
|
||||
}
|
||||
|
||||
/// The world server of the `coa-bots` repack folder lives inside the server folder and is started by its own
|
||||
/// launcher (`coa-bots\Core\worldserver.exe`). It serves the same realm, so it counts as this server's world.
|
||||
fn world_alternatives(root: &Path) -> Vec<PathBuf> {
|
||||
vec![root.join("coa-bots").join("Core").join("worldserver.exe")]
|
||||
}
|
||||
|
||||
fn service(root: &Path, name: &'static str, exe: PathBuf, port: u16, listen: &[(u16, u32)]) -> ServiceStatus {
|
||||
service_with(root, name, exe, &[], port, listen)
|
||||
}
|
||||
|
||||
fn service_with(root: &Path, name: &'static str, exe: PathBuf, alternatives: &[PathBuf], port: u16, listen: &[(u16, u32)]) -> ServiceStatus {
|
||||
// Prefer the repack's own record when it still matches a live process; otherwise discover by exact exe path.
|
||||
let norm = |p: &Path| p.to_string_lossy().replace('/', "\\");
|
||||
let expected: Vec<String> = std::iter::once(&exe).chain(alternatives).map(|p| norm(p)).collect();
|
||||
let proc = read_state_record(root, name)
|
||||
.filter(is_alive)
|
||||
.filter(|r| r.exe.eq_ignore_ascii_case(&exe.to_string_lossy().replace('/', "\\")))
|
||||
.or_else(|| find_by_exe(&exe).into_iter().next());
|
||||
.filter(|r| expected.iter().any(|e| r.exe.eq_ignore_ascii_case(e)))
|
||||
.or_else(|| std::iter::once(&exe).chain(alternatives).find_map(|p| find_by_exe(p).into_iter().next()));
|
||||
|
||||
let owner = listen.iter().find(|(p, _)| *p == port).map(|(_, pid)| *pid);
|
||||
let (state, port_ready, conflict) = match (&proc, owner) {
|
||||
@@ -319,7 +331,7 @@ pub fn observe(root: &Path, ports: &Ports) -> Observed {
|
||||
Observed {
|
||||
mysql: service(root, "mysql", mysql, ports.mysql, &listen),
|
||||
auth: service(root, "auth", auth, ports.auth, &listen),
|
||||
world: service(root, "world", world, ports.world, &listen),
|
||||
world: service_with(root, "world", world, &world_alternatives(root), ports.world, &listen),
|
||||
secondary_world,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -38,7 +38,12 @@ pub fn extract_base(source: &Path, fixture: &Path, trusted_key: &str) -> Result<
|
||||
["mysql/", "settings/", "runtime/", "scripts/", "core/", "bugreport/"].iter().any(|prefix| path.starts_with(prefix))
|
||||
}, &|_, _| {})?;
|
||||
fsx::atomic_write(&fixture.join(MARKER), b"disposable release-schema fixture")?;
|
||||
install::bootstrap_database(fixture)
|
||||
// A Linux computer has no Windows database program: the fixture is a Docker server over the package's data directory.
|
||||
if cfg!(windows) {
|
||||
install::bootstrap_database(fixture)
|
||||
} else {
|
||||
crate::docker::fixture::prepare(fixture)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn capture_release(fixture: &Path, tree: &Path, sql: &[SqlFile]) -> Result<()> {
|
||||
|
||||
@@ -44,6 +44,15 @@ pub struct Field {
|
||||
pub default_if_missing: Option<serde_json::Value>,
|
||||
pub min: Option<f64>,
|
||||
pub max: Option<f64>,
|
||||
/// A fixed list of allowed values with their labels (SQUID 1.9+); the editor shows it as a drop-down.
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub choices: Vec<Choice>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
|
||||
pub struct Choice {
|
||||
pub value: serde_json::Value,
|
||||
pub label: String,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
@@ -71,12 +80,20 @@ pub fn fields(root: &Path) -> crate::Result<std::collections::BTreeMap<String, F
|
||||
|| field.min.zip(field.max).is_some_and(|(min,max)| min > max)
|
||||
|| !default_type(&field.kind, &field.default)
|
||||
|| field.default_if_missing.as_ref().is_some_and(|value| !default_type(&field.kind, value))
|
||||
|| !valid_choices(&field)
|
||||
|| fields.contains_key(&field.key) { continue; }
|
||||
fields.insert(field.key.clone(), field);
|
||||
}
|
||||
Ok(fields)
|
||||
}
|
||||
|
||||
/// A list of choices must be small, labelled, free of repeats and made of values of the field's own type.
|
||||
fn valid_choices(field: &Field) -> bool {
|
||||
field.choices.len() <= 64
|
||||
&& field.choices.iter().all(|c| !c.label.trim().is_empty() && c.label.len() <= 80 && default_type(&field.kind, &c.value))
|
||||
&& field.choices.iter().enumerate().all(|(i, c)| field.choices[..i].iter().all(|earlier| scalar(&earlier.value) != scalar(&c.value)))
|
||||
}
|
||||
|
||||
fn default_type(kind: &str, value: &serde_json::Value) -> bool {
|
||||
match kind {
|
||||
"bool" => value.is_boolean(),
|
||||
@@ -104,13 +121,28 @@ pub fn validate(field: &Field, value: &str) -> crate::Result<()> {
|
||||
&& field.min.is_none_or(|min| number >= min) && field.max.is_none_or(|max| number <= max)),
|
||||
"string" => true,
|
||||
_ => false,
|
||||
};
|
||||
} && (field.choices.is_empty() || field.choices.iter().any(|c| scalar(&c.value).as_deref() == Some(value)));
|
||||
if valid { Ok(()) } else { Err(crate::Error::Invalid(format!("{} must match its documented SquidBots type and range.", field.key))) }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn a_setting_with_choices_only_accepts_one_of_them() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
crate::fsx::atomic_write(&root.path().join("Core/configs/modules/playerbots.conf.settings.json"), br#"{"format":1,"settings":[
|
||||
{"key":"AiPlayerbot.BotTextLocale","type":"int","group":"chat","title":"Language","description":"x","default":-1,"min":-1,"max":8,
|
||||
"choices":[{"value":-1,"label":"Auto"},{"value":0,"label":"English"},{"value":8,"label":"Russian"}]},
|
||||
{"key":"AiPlayerbot.Broken","type":"int","group":"chat","title":"b","description":"x","default":0,"choices":[{"value":"a","label":"wrong type"}]}]}"#).unwrap();
|
||||
let fields = fields(root.path()).unwrap();
|
||||
let locale = &fields["AiPlayerbot.BotTextLocale"];
|
||||
assert_eq!(locale.choices.len(), 3);
|
||||
for ok in ["-1", "0", "8"] { assert!(validate(locale, ok).is_ok(), "{ok}"); }
|
||||
for bad in ["1", "7", "x"] { assert!(validate(locale, bad).is_err(), "{bad}"); }
|
||||
assert!(!fields.contains_key("AiPlayerbot.Broken"), "a choice of the wrong type invalidates the setting");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn upstream_settings_preserve_types_ranges_and_distinct_defaults() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -197,8 +197,15 @@ pub struct PlanItem {
|
||||
/// 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) {
|
||||
@@ -259,10 +266,29 @@ pub struct Preview {
|
||||
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,
|
||||
}
|
||||
|
||||
/// 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> {
|
||||
let meta_dir = crate::registry::metadata_dir_for(root)?;
|
||||
let _lock = operation_lock(&meta_dir)?;
|
||||
ensure_recovered(&meta_dir)?;
|
||||
@@ -277,7 +303,16 @@ pub fn preview(root: &Path, meta: &InstallMeta, source: &Source, trusted_key: &s
|
||||
item.reason = Some("already up to date with Manager integration".into());
|
||||
}
|
||||
}
|
||||
let pending_migrations = (RepackEnv { root, meta_dir: &meta_dir }).pending_migrations(&m)?;
|
||||
// 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(),
|
||||
@@ -286,6 +321,8 @@ pub fn preview(root: &Path, meta: &InstallMeta, source: &Source, trusted_key: &s
|
||||
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,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -422,7 +459,7 @@ pub fn apply(p: &Params, report: &dyn Fn(&str, u8)) -> Result<Outcome> {
|
||||
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 = meta_dir.join("backups").join(txn.recovery_point.as_deref().unwrap()).join("backup.json");
|
||||
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)?); }
|
||||
|
||||
txn.ops = items
|
||||
@@ -455,9 +492,13 @@ pub fn apply(p: &Params, report: &dyn Fn(&str, u8)) -> Result<Outcome> {
|
||||
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) => return fail_after_apply(p, &mut txn, &before, &tree, e.to_string(), None),
|
||||
Err(e) => {
|
||||
step(report, "Undoing the update", 76);
|
||||
return fail_after_apply(p, &mut txn, &before, &tree, e.to_string(), None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -565,7 +606,7 @@ fn restore_transaction(root: &Path, meta: &Path, before: &Path, txn: &mut Txn, e
|
||||
for (rel, expected) in &txn.recovery_hashes {
|
||||
let saved = match rel.as_str() {
|
||||
"@install" => before.join("manager-install.json"),
|
||||
"@point" => meta.join("backups").join(txn.recovery_point.as_deref().ok_or_else(|| Error::Invalid("The recovery point identity is missing.".into()))?).join("backup.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."))); }
|
||||
@@ -735,8 +776,13 @@ pub struct RepackEnv<'a> {
|
||||
|
||||
impl RepackEnv<'_> {
|
||||
pub fn pending_migrations(&self, manifest: &Manifest) -> Result<usize> {
|
||||
if manifest.migrations.is_empty() { return Ok(0); }
|
||||
crate::backup::with_database(self.root, |db| {
|
||||
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 realms = crate::realms::state(self.root)?;
|
||||
let mut modes = vec![realms.active];
|
||||
if realms.wildcard_created { modes.push(if realms.active == crate::realms::Mode::Coa { crate::realms::Mode::Wildcard } else { crate::realms::Mode::Coa }); }
|
||||
@@ -746,7 +792,11 @@ impl RepackEnv<'_> {
|
||||
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)) {
|
||||
@@ -1131,6 +1181,11 @@ mod tests {
|
||||
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, &w.meta, &meta, &changed, &Source::Dir(w.pkg.clone())).is_err());
|
||||
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());
|
||||
|
||||
Reference in new issue
Block a user