Files
coa-server-manager/crates/coa-core/src/squid.rs
T

417 lines
16 KiB
Rust

use serde::{Deserialize, Serialize};
use std::path::Path;
/// SQUID has its own import ledger, outside the signed package migration ledger.
/// Keep this read-only: a pending base import can contain player data and must not
/// be replayed or cleared merely because the normal schema contract passes.
pub(crate) fn database_problems(
root: &Path,
mode: crate::realms::Mode,
query: &impl Fn(&str) -> crate::Result<String>,
) -> crate::Result<Vec<crate::schema_check::Problem>> {
let active = root.join("Core/configs/modules/playerbots.conf");
let config = if active.is_file() {
active
} else {
root.join("Core/configs/modules/playerbots.conf.dist")
};
let enabled = if config.is_file() {
let conf = crate::config::parser::ConfFile::parse_bytes(&std::fs::read(config)?)?;
!matches!(
conf.get("AiPlayerbot.Enabled")
.unwrap_or("1")
.trim()
.trim_matches('"')
.to_ascii_lowercase()
.as_str(),
"0" | "false" | "no" | "off"
)
} else {
false
};
let mut problems = Vec::new();
for schema in [
mode.schema("characters")?,
mode.schema("world")?,
"acore_playerbots",
] {
let tables: std::collections::BTreeSet<_> = query(&format!(
"SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA='{schema}';"
))?
.lines()
.map(str::to_owned)
.collect();
if tables.contains("coa_squid_pending") {
for pending in query(&format!("SELECT path FROM `{schema}`.coa_squid_pending;"))?
.lines()
.filter(|path| !path.is_empty())
{
problems.push(crate::schema_check::Problem { database: schema.into(), table: "coa_squid_pending".into(), column: String::new(), detail: format!("SQUID base import was interrupted: {pending}. File repair and package SQL updates cannot complete this import. Restore a verified database backup from before the import; do not delete the pending record or replay base SQL.") });
}
}
if enabled && schema == mode.schema("characters")? {
for table in [
"playerbots_names",
"playerbots_guild_names",
"playerbots_arena_team_names",
] {
if !tables.contains(table) {
problems.push(crate::schema_check::Problem { database: schema.into(), table: table.into(), column: String::new(), detail: "Required SQUID character table is missing. A normal server start provisions it when no interrupted import is present; an interrupted import requires database recovery first.".into() });
}
}
}
}
Ok(problems)
}
#[derive(Debug, Serialize, PartialEq, Eq)]
pub struct Release {
pub tag: Option<String>,
pub commit: Option<String>,
}
pub fn imported_repack(root: &Path) -> bool {
root.join("CoA-Bots/release.json").is_file()
}
pub fn release(root: &Path) -> Option<Release> {
for name in [
"Extras/SquidPlayerbots/release.json",
"Core/configs/modules/playerbots.conf.settings.json",
"CoA-Bots/release.json",
] {
let Ok(bytes) = std::fs::read(root.join(name)) else {
continue;
};
if bytes.len() > 1024 * 1024 {
continue;
}
let Ok(json) = serde_json::from_slice::<serde_json::Value>(&bytes) else {
continue;
};
let safe = |key: &str| {
json.get(key)
.and_then(|value| value.as_str())
.filter(|value| {
!value.is_empty()
&& value.len() <= 80
&& value
.chars()
.all(|c| c.is_ascii_alphanumeric() || "._-".contains(c))
})
.map(str::to_owned)
};
let tag = safe("tag").or_else(|| safe("version"));
let revision = if name == "CoA-Bots/release.json" {
json.get("botsModuleRevision")
.and_then(|value| value.as_str())
.and_then(|value| value.split_whitespace().next())
.map(str::to_owned)
.or_else(|| safe("commit"))
} else if name.ends_with(".settings.json") {
None
} else {
safe("commit")
};
let commit = revision.filter(|value| {
value.len() >= 7 && value.len() <= 40 && value.chars().all(|c| c.is_ascii_hexdigit())
});
if tag.is_some() || commit.is_some() {
return Some(Release { tag, commit });
}
}
None
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub struct Field {
pub key: String,
#[serde(rename = "type")]
pub kind: String,
pub title: String,
pub description: String,
#[serde(default)]
pub group: String,
#[serde(default)]
pub group_title: Option<String>,
pub default: serde_json::Value,
#[serde(default)]
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)]
struct Settings {
format: u32,
settings: Vec<serde_json::Value>,
#[serde(default)]
groups: std::collections::BTreeMap<String, String>,
}
pub fn fields(root: &Path) -> crate::Result<std::collections::BTreeMap<String, Field>> {
let path = root.join("Core/configs/modules/playerbots.conf.settings.json");
if !path.is_file() {
return Ok(Default::default());
}
let Ok(bytes) = std::fs::read(path) else {
return Ok(Default::default());
};
if bytes.len() > 1024 * 1024 {
return Ok(Default::default());
}
let Ok(settings) = serde_json::from_slice::<Settings>(&bytes) else {
return Ok(Default::default());
};
if settings.format != 1 {
return Ok(Default::default());
}
let mut fields = std::collections::BTreeMap::new();
for value in settings.settings {
let Ok(mut field) = serde_json::from_value::<Field>(value) else {
continue;
};
field.group_title = settings.groups.get(&field.group).cloned();
if !matches!(field.kind.as_str(), "bool" | "int" | "float" | "string")
|| field.key.len() > 200
|| field.key.is_empty()
|| !field
.key
.chars()
.all(|c| c.is_ascii_alphanumeric() || "._".contains(c))
|| 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(),
"int" => value.is_i64() || value.is_u64(),
"float" => value.is_number(),
"string" => value.is_string(),
_ => false,
}
}
pub fn scalar(value: &serde_json::Value) -> Option<String> {
match value {
serde_json::Value::Bool(value) => Some(if *value { "1" } else { "0" }.into()),
serde_json::Value::String(value) => Some(value.clone()),
serde_json::Value::Number(value) => Some(value.to_string()),
_ => None,
}
}
pub fn validate(field: &Field, value: &str) -> crate::Result<()> {
let valid = match field.kind.as_str() {
"bool" => matches!(value, "0" | "1"),
"int" | "float" => value.parse::<f64>().is_ok_and(|number| {
number.is_finite()
&& (field.kind != "int" || number.fract() == 0.0)
&& 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 database_check_reports_pending_squid_imports_in_each_realm_without_writes() {
let root = tempfile::tempdir().unwrap();
for mode in [crate::realms::Mode::Coa, crate::realms::Mode::Wildcard] {
let problems = database_problems(root.path(), mode, &|sql| {
assert!(sql.starts_with("SELECT "));
if sql.contains("information_schema.TABLES") {
Ok("coa_squid_pending".into())
} else {
Ok("playerbots/base/ai_playerbot_texts.sql".into())
}
})
.unwrap();
assert_eq!(problems.len(), 3);
assert_eq!(problems[0].database, mode.schema("characters").unwrap());
assert!(problems.iter().all(|p| p.detail.contains("interrupted")));
}
}
#[test]
fn enabled_squid_requires_character_tables_but_disabled_squid_does_not() {
let root = tempfile::tempdir().unwrap();
let config = root.path().join("Core/configs/modules/playerbots.conf");
crate::fsx::atomic_write(&config, b"AiPlayerbot.Enabled = 1\n").unwrap();
let query = |_: &str| Ok(String::new());
assert_eq!(
database_problems(root.path(), crate::realms::Mode::Wildcard, &query)
.unwrap()
.len(),
3
);
crate::fsx::atomic_write(&config, b"AiPlayerbot.Enabled = 0\n").unwrap();
assert!(
database_problems(root.path(), crate::realms::Mode::Wildcard, &query)
.unwrap()
.is_empty()
);
crate::fsx::atomic_write(&config, b"AiPlayerbot.Enabled = 1\n").unwrap();
assert!(
database_problems(root.path(), crate::realms::Mode::Coa, &|_| Ok(
"playerbots_names\nplayerbots_guild_names\nplayerbots_arena_team_names".into()
))
.unwrap()
.is_empty()
);
}
#[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();
crate::fsx::atomic_write(&root.path().join("Core/configs/modules/playerbots.conf.settings.json"), br#"{"format":1,"settings":[{"key":"AiPlayerbot.MinRandomBots","type":"int","group":"population","title":"Minimum bots","description":"Lower bound","default":500,"default_if_missing":50,"min":0,"max":5000}]}"#).unwrap();
let fields = fields(root.path()).unwrap();
let field = &fields["AiPlayerbot.MinRandomBots"];
assert_eq!(scalar(&field.default).as_deref(), Some("500"));
assert_eq!(
scalar(field.default_if_missing.as_ref().unwrap()).as_deref(),
Some("50")
);
assert!(validate(field, "5000").is_ok());
for value in ["5001", "-1", "0.5", "NaN"] {
assert!(validate(field, value).is_err());
}
}
#[test]
fn unsupported_metadata_falls_back_and_bad_entries_do_not_hide_valid_fields() {
let root = tempfile::tempdir().unwrap();
let path = root
.path()
.join("Core/configs/modules/playerbots.conf.settings.json");
for data in [
r#"{"format":99,"settings":[]}"#,
"invalid json",
r#"{"format":1,"settings":{}}"#,
] {
crate::fsx::atomic_write(&path, data.as_bytes()).unwrap();
assert!(fields(root.path()).unwrap().is_empty());
}
crate::fsx::atomic_write(&path, br#"{"format":1,"settings":[{"key":"Broken","type":"enum","title":"Broken","description":"Unknown type","default":1},{"key":"Malformed"},{"key":"WrongDefault","type":"int","title":"Wrong","description":"Bad default","default":"oops"},{"key":"Good","type":"bool","title":"Good","description":"Good field","default":true}]}"#).unwrap();
let parsed = fields(root.path()).unwrap();
assert_eq!(parsed.len(), 1);
assert!(parsed.contains_key("Good"));
}
#[test]
fn imported_revision_uses_its_first_word_and_empty_tags_are_hidden() {
let root = tempfile::tempdir().unwrap();
crate::fsx::atomic_write(&root.path().join("CoA-Bots/release.json"), br#"{"tag":"","botsModuleRevision":"48c4786a 2026-10-01 (coa branch)","commit":"abcdef01"}"#).unwrap();
assert_eq!(
release(root.path()).unwrap(),
Release {
tag: None,
commit: Some("48c4786a".into())
}
);
crate::fsx::atomic_write(
&root
.path()
.join("Core/configs/modules/playerbots.conf.settings.json"),
br#"{"tag":"v1.8.1","commit":"11111111"}"#,
)
.unwrap();
assert_eq!(
release(root.path()).unwrap(),
Release {
tag: Some("v1.8.1".into()),
commit: None
}
);
}
#[test]
fn diagnostics_only_expose_release_identifiers() {
let root = tempfile::tempdir().unwrap();
crate::fsx::atomic_write(
&root.path().join("CoA-Bots/release.json"),
br#"{"tag":"v1.8","commit":"48c4786a","password":"secret"}"#,
)
.unwrap();
assert!(imported_repack(root.path()));
assert_eq!(
release(root.path()).unwrap(),
Release {
tag: Some("v1.8".into()),
commit: Some("48c4786a".into())
}
);
}
}