//! Database access through the MySQL client tools bundled with the repack (`mysql`, `mysqldump`, `mysqladmin`), or, //! for a Docker installation, the same tools run inside the database container with `docker exec`. //! //! Passwords travel only in the child's environment (`MYSQL_PWD`), never on a command line or in a log. use std::fmt; use std::fs::File; use std::io::{BufReader, BufWriter, Read, Seek, SeekFrom, Write}; use std::path::{Path, PathBuf}; use std::process::{Command, Stdio}; use std::time::{Duration, Instant}; use serde::Deserialize; use crate::error::{Error, ErrorCode, Result}; use crate::fsx; use crate::layout::{read_ports, Ports}; /// A credential that never prints itself. #[derive(Clone)] pub struct Secret(String); impl Secret { fn expose(&self) -> &str { &self.0 } } impl fmt::Debug for Secret { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str("Secret(***)") } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum Account { /// Owner of everything in the packaged MySQL (needed for staging schemas and renames). Admin, /// The game servers' own account. App, } #[derive(Debug, Clone)] pub struct Db { bin: PathBuf, port: u16, user: &'static str, password: Secret, realm: crate::realms::Mode, /// Name of the database container of a Docker installation; the client tools then run inside it. container: Option, read_deadline: Option, } #[derive(Deserialize)] #[serde(rename_all = "camelCase")] struct Credentials { root_password: String, app_password: String, } fn no_window(cmd: &mut Command) { #[cfg(windows)] { use std::os::windows::process::CommandExt; cmd.creation_flags(0x0800_0000); } #[cfg(not(windows))] let _ = cmd; } fn bounded_client_output(command: &mut Command, input: &[u8], deadline: Instant) -> Result { let timeout = || Error::Invalid("The database inspection timed out. The Manager stopped its client process; the database server was not stopped. Retry the operation or export diagnostics if this continues.".into()); if Instant::now() >= deadline { return Err(timeout()); } let mut stdin = tempfile::tempfile()?; stdin.write_all(input)?; stdin.seek(SeekFrom::Start(0))?; let mut stdout = tempfile::tempfile()?; let mut stderr = tempfile::tempfile()?; command.stdin(stdin).stdout(stdout.try_clone()?).stderr(stderr.try_clone()?); let mut child = command.spawn()?; let status = loop { match child.try_wait() { Ok(Some(status)) => break status, Ok(None) if Instant::now() < deadline => std::thread::sleep(Duration::from_millis(25)), result => { child.kill().map_err(|error| Error::Invalid(format!( "The database inspection timed out, but its client could not be stopped: {error}" )))?; let _ = child.wait(); return match result { Err(error) => Err(error.into()), _ => Err(timeout()), }; } } }; stdout.seek(SeekFrom::Start(0))?; stderr.seek(SeekFrom::Start(0))?; let mut output = std::process::Output { status, stdout: Vec::new(), stderr: Vec::new() }; stdout.read_to_end(&mut output.stdout)?; stderr.read_to_end(&mut output.stderr)?; Ok(output) } /// Schema names of the three game databases. pub const SCHEMAS: [(&str, &str); 3] = [ ("characters", "acore_characters"), ("auth", "acore_auth"), ("world", "acore_world"), ]; pub fn schema_of(kind: &str) -> Result<&'static str> { if kind == "playerbots" { return Ok("acore_playerbots"); } if let Some(kind) = kind.strip_prefix("wildcard-") { return crate::realms::Mode::Wildcard.schema(kind); } if let Some(kind) = kind.strip_prefix("reborn-") { return crate::realms::Mode::Reborn.schema(kind); } if let Some(kind) = kind.strip_prefix("coa-") { return crate::realms::Mode::Coa.schema(kind); } SCHEMAS .iter() .find(|(k, _)| *k == kind) .map(|(_, s)| *s) .ok_or_else(|| Error::Invalid(format!("unknown database {kind}"))) } fn ident_ok(name: &str) -> bool { !name.is_empty() && name.len() <= 64 && name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') } /// (root password, application password) from `Settings/database.json`. pub(crate) fn credentials(root: &Path) -> Result<(String, String)> { let c: Credentials = fsx::read_json(&root.join("Settings/database.json")).map_err(|_| { Error::Invalid("The database settings of this server could not be read.".into()) })?; Ok((c.root_password, c.app_password)) } impl Db { pub fn from_repack(root: &Path, account: Account) -> Result { let creds: Credentials = fsx::read_json(&root.join("Settings/database.json")).map_err(|_| { Error::Invalid("The database settings of this server could not be read.".into()) })?; let ports: Ports = read_ports(root); if crate::docker::is_docker(root) { return Db::in_container(root, creds, account); } let bin = root.join("mysql/bin"); if !bin.join("mysqldump.exe").is_file() || !bin.join("mysql.exe").is_file() { return Err(Error::Invalid( "The bundled database tools are missing.".into(), )); } let (user, password) = match account { Account::Admin => ("root", creds.root_password), Account::App => ("acore", creds.app_password), }; Ok(Db { bin, port: ports.mysql, user, password: Secret(password), realm: crate::realms::state(root)?.active, container: None, read_deadline: None, }) } /// The database of a Docker installation: the client tools of the database image, run with `docker exec`. The /// database is not published on the host, so nothing about this depends on a port or on tools installed here. fn in_container(root: &Path, creds: Credentials, account: Account) -> Result { let container = crate::docker::Config::load(root)?.database_container(); let (user, password) = match account { Account::Admin => ("root", creds.root_password), Account::App => ("acore", creds.app_password), }; // Inside the container the server listens on its standard port; the commands below connect to it over TCP on // the container's own loopback, exactly like the commands of a repack do on the host. Ok(Db { bin: PathBuf::new(), port: 3306, user, password: Secret(password), realm: crate::realms::state(root)?.active, container: Some(container), read_deadline: None, }) } /// A database reached through explicitly given client tools. Used by tests against a disposable server; the /// installation-based constructors above are what the Manager itself uses. pub fn with_tools( bin: PathBuf, port: u16, user: &'static str, password: &str, realm: crate::realms::Mode, ) -> Db { Db { bin, port, user, password: Secret(password.to_string()), realm, container: None, read_deadline: None, } } pub fn for_realm(mut self, realm: crate::realms::Mode) -> Self { self.realm = realm; self } pub fn realm(&self) -> crate::realms::Mode { self.realm } pub fn realm_schema<'a>(&self, name: &'a str) -> &'a str { if self.realm != crate::realms::Mode::Coa { match name { "acore_world" => self.realm.schema("world").unwrap(), "acore_characters" => self.realm.schema("characters").unwrap(), _ => name, } } else { name } } pub fn clone_structure(&self, source: &str, dest: &str, cache: &Path) -> Result<()> { if !ident_ok(source) || !ident_ok(dest) { return Err(Error::Invalid("Invalid schema name.".into())); } let path = cache.join("characters-structure.sql"); self.dump_structure_to(source, &path)?; self.run_sql_file(dest, &path)?; std::fs::remove_file(path)?; Ok(()) } pub fn dump_structure_to(&self, source: &str, path: &Path) -> Result<()> { if !ident_ok(source) { return Err(Error::Invalid("Invalid schema name.".into())); } let mut c = self.command("mysqldump.exe"); c.args([ "--no-data", "--no-tablespaces", "--skip-comments", "--default-character-set=utf8mb4", source, ]); c.stdout(Stdio::from(File::create(path)?)); let out = c.output()?; if !out.status.success() { return Err(self.fail(&out.stderr)); } Ok(()) } fn command(&self, tool: &str) -> Command { let mut c = match &self.container { None => Command::new(self.bin.join(tool)), Some(name) => { // `-e MYSQL_PWD` without a value takes it from this process's environment: never on a command line. let mut c = Command::new("docker"); c.args([ "exec", "-i", "-e", "MYSQL_PWD", name, tool.trim_end_matches(".exe"), ]); c } }; c.env("MYSQL_PWD", self.password.expose()) .arg("--protocol=tcp") .arg("--host=127.0.0.1") .arg(format!("--port={}", self.port)) .arg(format!("--user={}", self.user)) .stdin(Stdio::null()) .stdout(Stdio::piped()) .stderr(Stdio::piped()); no_window(&mut c); c } fn fail(&self, stderr: &[u8]) -> Error { let text = String::from_utf8_lossy(stderr); // Only the client's own connection errors mean "not running": the number 2003 or the words can also appear inside // the message of an ordinary SQL error (a duplicate entry, a row number) and must not hide it. let down = text.contains("ERROR 2003") || text.contains("ERROR 2002") || text.contains("Can't connect to MySQL server") || text.contains("No such container") || text.contains("is not running"); let code = if down { ErrorCode::DatabaseNotRunning } else { ErrorCode::Unknown }; match code { ErrorCode::DatabaseNotRunning => Error::Invalid(format!( "The database is not running. Start the server first. ({})", text.trim() .lines() .last() .unwrap_or("") .chars() .take(300) .collect::() )), _ => Error::Invalid(format!( "database command failed: {}", text.trim().lines().last().unwrap_or("") )), } } pub fn ping(&self) -> bool { let mut c = self.command("mysqladmin.exe"); c.arg("ping").arg("--connect-timeout=3"); bounded_client_output(&mut c, b"", Instant::now() + Duration::from_secs(5)) .map(|o| o.status.success()).unwrap_or(false) } pub(crate) fn with_read_deadline(mut self, deadline: Instant) -> Self { self.read_deadline = Some(deadline); self } /// Run SQL text (statement(s) supplied on stdin) and return the raw output. pub fn query(&self, sql: &str) -> Result { let mut c = self.command("mysql.exe"); c.args(["--batch", "--skip-column-names", "--connect-timeout=5"]); c.args([ "--default-character-set=utf8mb4", "--max-allowed-packet=128M", ]); if let Some(deadline) = self.read_deadline { let out = bounded_client_output(&mut c, route_sql(sql, self.realm).as_bytes(), deadline)?; if !out.status.success() { return Err(self.fail(&out.stderr)); } return Ok(String::from_utf8_lossy(&out.stdout).trim().to_string()); } c.stdin(Stdio::piped()); let mut child = c.spawn()?; child .stdin .take() .expect("piped") .write_all(route_sql(sql, self.realm).as_bytes())?; let out = child.wait_with_output()?; if !out.status.success() { return Err(self.fail(&out.stderr)); } Ok(String::from_utf8_lossy(&out.stdout).trim().to_string()) } pub fn schema_exists(&self, name: &str) -> Result { let name = self.realm_schema(name); if !ident_ok(name) { return Err(Error::Invalid("bad schema name".into())); } Ok(self.query(&format!( "SELECT COUNT(*) FROM information_schema.schemata WHERE schema_name='{name}';" ))? == "1") } pub fn tables(&self, schema: &str) -> Result> { let schema = self.realm_schema(schema); if !ident_ok(schema) { return Err(Error::Invalid("bad schema name".into())); } let out = self.query(&format!("SELECT table_name FROM information_schema.tables WHERE table_schema='{schema}' AND table_type='BASE TABLE' ORDER BY table_name;"))?; Ok(out .lines() .map(str::to_string) .filter(|s| !s.is_empty()) .collect()) } /// Bytes of data + index the schema occupies (used to estimate backup size). pub fn schema_bytes(&self, schema: &str) -> Result { let schema = self.realm_schema(schema); if !ident_ok(schema) { return Err(Error::Invalid("bad schema name".into())); } let out = self.query(&format!("SELECT COALESCE(SUM(data_length+index_length),0) FROM information_schema.tables WHERE table_schema='{schema}';"))?; out.trim() .parse() .map_err(|_| Error::Invalid("unexpected size reply".into())) } /// Stored routines / triggers / views make a table-level swap unsafe; count them. pub fn extra_objects(&self, schema: &str) -> Result { let schema = self.realm_schema(schema); if !ident_ok(schema) { return Err(Error::Invalid("bad schema name".into())); } let sql = format!( "SELECT (SELECT COUNT(*) FROM information_schema.routines WHERE routine_schema='{schema}') + (SELECT COUNT(*) FROM information_schema.triggers WHERE trigger_schema='{schema}') + (SELECT COUNT(*) FROM information_schema.views WHERE table_schema='{schema}');" ); self.query(&sql)? .trim() .parse() .map_err(|_| Error::Invalid("unexpected reply".into())) } pub fn recovery_objects(&self, schema: &str) -> Result> { let schema = self.realm_schema(schema); if !ident_ok(schema) { return Err(Error::Invalid("bad schema name".into())); } let sql = format!("SELECT routine_type,HEX(routine_name) FROM information_schema.routines WHERE routine_schema='{schema}' UNION ALL SELECT 'TRIGGER',HEX(trigger_name) FROM information_schema.triggers WHERE trigger_schema='{schema}' UNION ALL SELECT 'VIEW',HEX(table_name) FROM information_schema.views WHERE table_schema='{schema}' ORDER BY 1,2;"); parse_recovery_objects(schema, &self.query(&sql)?) } /// Consistent dump of one schema, zstd-compressed to `out`. Returns (compressed bytes, sha256 of the file). pub fn dump_to(&self, schema: &str, out: &Path) -> Result<(u64, String)> { let schema = self.realm_schema(schema); if !ident_ok(schema) { return Err(Error::Invalid("bad schema name".into())); } let mut c = self.command("mysqldump.exe"); c.args([ "--single-transaction", "--quick", "--routines", "--triggers", "--default-character-set=utf8mb4", "--no-tablespaces", "--skip-comments", "--hex-blob", ]); c.arg(schema); let mut child = c.spawn()?; let mut stdout = child.stdout.take().expect("piped"); let mut stderr = child.stderr.take().expect("piped"); let err_thread = std::thread::spawn(move || { let mut b = Vec::new(); let _ = stderr.read_to_end(&mut b); b }); let file = File::create(out)?; let mut enc = zstd::Encoder::new(BufWriter::new(file), 3)?; let copy = std::io::copy(&mut stdout, &mut enc); let finish = enc.finish().and_then(|mut w| w.flush()); let status = child.wait()?; let stderr_bytes = err_thread.join().unwrap_or_default(); if !status.success() { let _ = std::fs::remove_file(out); return Err(self.fail(&stderr_bytes)); } copy?; finish?; let size = std::fs::metadata(out)?.len(); Ok((size, fsx::sha256_file(out)?)) } /// Run a plain SQL file against `schema`; the first error aborts and is returned. pub fn run_sql_file(&self, schema: &str, file: &Path) -> Result<()> { let schema = self.realm_schema(schema); if !ident_ok(schema) { return Err(Error::Invalid("bad schema name".into())); } if self.realm != crate::realms::Mode::Coa { let sql = std::fs::read_to_string(file)?; self.query(&format!( "SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci; USE `{schema}`;\n{sql}" ))?; return Ok(()); } let mut c = self.command("mysql.exe"); c.args([ "--default-character-set=utf8mb4", "--init-command=SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci", "--max-allowed-packet=128M", ]); c.arg(schema); c.stdin(Stdio::from(File::open(file)?)); let out = c.output()?; if !out.status.success() { return Err(self.fail(&out.stderr)); } Ok(()) } /// Import a dump produced by `dump_to` into `schema` (which must already exist and be empty). pub fn import_from(&self, schema: &str, dump: &Path) -> Result<()> { let schema = self.realm_schema(schema); if !ident_ok(schema) { return Err(Error::Invalid("bad schema name".into())); } let mut c = self.command("mysql.exe"); c.args([ "--default-character-set=utf8mb4", "--init-command=SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci", "--max-allowed-packet=128M", ]); c.arg(schema); c.stdin(Stdio::piped()); let mut child = c.spawn()?; let mut stdin = child.stdin.take().expect("piped"); let mut stderr = child.stderr.take().expect("piped"); let err_thread = std::thread::spawn(move || { let mut b = Vec::new(); let _ = stderr.read_to_end(&mut b); b }); let mut dec = zstd::Decoder::new(BufReader::new(File::open(dump)?))?; let copied = std::io::copy(&mut dec, &mut stdin); drop(stdin); let status = child.wait()?; let stderr_bytes = err_thread.join().unwrap_or_default(); if !status.success() { return Err(self.fail(&stderr_bytes)); } copied?; Ok(()) } } fn parse_recovery_objects(schema: &str, text: &str) -> Result> { text.lines() .filter(|line| !line.is_empty()) .map(|line| { let (kind, name) = line .split_once('\t') .ok_or_else(|| Error::Invalid("unexpected database object reply".into()))?; if !matches!(kind, "PROCEDURE" | "FUNCTION" | "TRIGGER" | "VIEW") { return Err(Error::Invalid("unexpected database object type".into())); } let name = hex::decode(name) .ok() .and_then(|bytes| String::from_utf8(bytes).ok()) .filter(|name| !name.is_empty()) .ok_or_else(|| Error::Invalid("unexpected database object name".into()))?; Ok(serde_json::json!({ "database": schema, "kind": kind, "name": name })) }) .collect() } /// Name of the service account the Manager uses for the server console (RA). Accounts are stored upper-case. pub const SERVICE_ACCOUNT: &str = "COAMANAGER"; impl Db { /// Create (or reset) the console service account with a fresh random password and administrator rights on /// all realms, and return that password. The database must be running. pub fn provision_service_account(&self) -> Result { let password = hex::encode(&crate::srp6::new_salt()[..8]); // 16 random hex characters let salt = crate::srp6::new_salt(); let verifier = crate::srp6::verifier(SERVICE_ACCOUNT, &password, &salt); let (s, v) = (hex::encode(salt), hex::encode(verifier)); self.query(&format!( "INSERT INTO acore_auth.account (username, salt, verifier, email, reg_mail) VALUES ('{SERVICE_ACCOUNT}', UNHEX('{s}'), UNHEX('{v}'), '', '') ON DUPLICATE KEY UPDATE salt=UNHEX('{s}'), verifier=UNHEX('{v}'), failed_logins=0, locked=0; INSERT INTO acore_auth.account_access (id, gmlevel, RealmID, comment) SELECT id, 3, -1, 'CoA Server Manager console' FROM acore_auth.account WHERE username='{SERVICE_ACCOUNT}' ON DUPLICATE KEY UPDATE gmlevel=3;" ))?; Ok(password) } } /// Point `Settings/repack.json` at the service account (other keys are preserved). pub fn write_console_credentials(root: &Path, password: &str) -> Result<()> { let path = root.join("Settings/repack.json"); let mut v: serde_json::Value = fsx::read_json(&path)?; let obj = v .as_object_mut() .ok_or_else(|| Error::Invalid("repack.json is not an object".into()))?; obj.insert("raUsername".into(), SERVICE_ACCOUNT.into()); obj.insert("raPassword".into(), password.into()); fsx::atomic_write_json(&path, &v) } pub fn valid_identifier(name: &str) -> bool { ident_ok(name) } // Route only SQL identifiers. User names, values, comments and longer identifiers remain untouched. fn route_sql(sql: &str, realm: crate::realms::Mode) -> String { if realm == crate::realms::Mode::Coa { return sql.into(); } let bytes = sql.as_bytes(); let mut out = String::new(); let mut i = 0; while i < bytes.len() { let start = i; if matches!(bytes[i], b'\'' | b'"') { let quote = bytes[i]; i += 1; while i < bytes.len() { if bytes[i] == b'\\' { i = (i + 2).min(bytes.len()); } else if bytes[i] == quote { i += 1; if i < bytes.len() && bytes[i] == quote { i += 1; } else { break; } } else { i += 1; } } out.push_str(&sql[start..i]); } else if bytes[i] == b'#' || sql[i..].starts_with("--") || sql[i..].starts_with("/*") { if sql[i..].starts_with("/*") { i = sql[i + 2..] .find("*/") .map(|p| i + p + 4) .unwrap_or(bytes.len()); } else { i = sql[i..].find('\n').map(|p| i + p).unwrap_or(bytes.len()); } out.push_str(&sql[start..i]); } else if bytes[i].is_ascii_alphanumeric() || bytes[i] == b'_' { while i < bytes.len() && (bytes[i].is_ascii_alphanumeric() || bytes[i] == b'_') { i += 1; } out.push_str(match &sql[start..i] { "acore_world" => realm.schema("world").unwrap(), "acore_characters" => realm.schema("characters").unwrap(), other => other, }); } else { let c = sql[i..].chars().next().unwrap(); out.push(c); i += c.len_utf8(); } } out } #[cfg(test)] mod realm_tests { use super::*; #[test] fn routes_schema_identifiers_without_rewriting_account_values() { let sql = "SELECT * FROM `acore_characters`.characters WHERE name='acore_world' AND x=\"acore_characters\"; -- acore_world\nSELECT * FROM acore_world.items;"; assert_eq!(route_sql(sql, crate::realms::Mode::Wildcard), "SELECT * FROM `acore_characters_wildcard`.characters WHERE name='acore_world' AND x=\"acore_characters\"; -- acore_world\nSELECT * FROM acore_world_wildcard.items;"); } } #[cfg(test)] mod tests { fn client_fixture(mode: &str) -> std::process::Command { let mut command = std::process::Command::new(std::env::current_exe().unwrap()); command.args(["--exact", "db::tests::bounded_client_fixture", "--nocapture"]) .env("COA_DATABASE_CLIENT_TEST", mode); super::no_window(&mut command); command } #[test] fn bounded_client_fixture() { match std::env::var("COA_DATABASE_CLIENT_TEST").as_deref() { Ok("hang") => std::thread::sleep(std::time::Duration::from_secs(60)), Ok("output") => { use std::io::{Read, Write}; let mut input = Vec::new(); std::io::stdin().read_to_end(&mut input).unwrap(); std::io::stdout().write_all(&input).unwrap(); std::io::stderr().write_all(&vec![b'e'; 256 * 1024]).unwrap(); } Ok("fail") => std::process::exit(17), _ => (), } } #[test] fn bounded_client_captures_large_output_without_pipe_deadlock() { let data = vec![b'x'; 256 * 1024]; let out = super::bounded_client_output(&mut client_fixture("output"), &data, std::time::Instant::now() + std::time::Duration::from_secs(10)).unwrap(); assert!(out.status.success()); assert!(out.stdout.windows(data.len()).any(|part| part == data)); assert_eq!(out.stderr, vec![b'e'; 256 * 1024]); let out = super::bounded_client_output(&mut client_fixture("fail"), b"", std::time::Instant::now() + std::time::Duration::from_secs(10)).unwrap(); assert_eq!(out.status.code(), Some(17)); } #[test] fn bounded_client_timeout_releases_the_update_operation_lock() { let folder = tempfile::tempdir().unwrap(); let start = std::time::Instant::now(); let result = (|| { let _lock = crate::update::operation_lock_for(folder.path(), "checking updates", false)?; super::bounded_client_output(&mut client_fixture("hang"), b"", start + std::time::Duration::from_millis(250)) })(); assert!(result.unwrap_err().to_string().contains("inspection timed out")); assert!(start.elapsed() < std::time::Duration::from_secs(5)); crate::update::operation_lock(folder.path()).unwrap(); } #[cfg(windows)] #[test] #[ignore = "requires COA_MYSQL_TEST_BIN; starts a disposable MySQL server"] fn real_mysql_inspection_timeout_preserves_server_and_releases_lock() { use std::os::windows::process::CommandExt; struct Server(std::process::Child); impl Drop for Server { fn drop(&mut self) { let _ = self.0.kill(); let _ = self.0.wait(); } } let bin = std::path::PathBuf::from(std::env::var("COA_MYSQL_TEST_BIN").unwrap()); let folder = tempfile::tempdir().unwrap(); let data = folder.path().join("data"); let initialized = std::process::Command::new(bin.join("mysqld.exe")) .args(["--no-defaults", "--initialize-insecure"]) .arg(format!("--datadir={}", data.display())) .creation_flags(0x0800_0000).output().unwrap(); assert!(initialized.status.success(), "{}", String::from_utf8_lossy(&initialized.stderr)); let socket = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); let port = socket.local_addr().unwrap().port(); drop(socket); let mut server = Server(std::process::Command::new(bin.join("mysqld.exe")) .args(["--no-defaults", "--bind-address=127.0.0.1", "--mysqlx=0", "--skip-log-bin"]) .arg(format!("--datadir={}", data.display())).arg(format!("--port={port}")) .arg(format!("--log-error={}", folder.path().join("mysql.log").display())) .stdout(std::process::Stdio::null()).stderr(std::process::Stdio::null()) .creation_flags(0x0800_0000).spawn().unwrap()); let db = super::Db::with_tools(bin, port, "root", "", crate::realms::Mode::Coa); let ready = std::time::Instant::now() + std::time::Duration::from_secs(30); while !db.ping() { assert!(std::time::Instant::now() < ready); std::thread::sleep(std::time::Duration::from_millis(100)); } let result = (|| { let _lock = crate::update::operation_lock_for(folder.path(), "checking updates", false)?; db.clone().with_read_deadline(std::time::Instant::now() + std::time::Duration::from_millis(500)) .query("SELECT SLEEP(60);") })(); assert!(result.unwrap_err().to_string().contains("inspection timed out")); assert!(server.0.try_wait().unwrap().is_none()); assert_eq!(db.query("SELECT 42;").unwrap(), "42"); crate::update::operation_lock(folder.path()).unwrap(); } #[test] fn reborn_sql_routes_only_database_identifiers() { use crate::realms::Mode; let sql = "SELECT * FROM `acore_characters`.characters WHERE name='acore_world'; -- acore_world\nSELECT * FROM acore_world.items; SELECT * FROM acore_world_wildcard.items;"; assert_eq!(super::route_sql(sql, Mode::Reborn), "SELECT * FROM `acore_characters_reborn`.characters WHERE name='acore_world'; -- acore_world\nSELECT * FROM acore_world_reborn.items; SELECT * FROM acore_world_wildcard.items;"); assert_eq!( super::schema_of("reborn-characters").unwrap(), "acore_characters_reborn" ); assert_eq!(super::schema_of("reborn-auth").unwrap(), "acore_auth"); } use super::*; use std::ffi::OsStr; const ROOT_PW: &str = "rootpw-ZZ1"; const APP_PW: &str = "apppw-QQ2"; #[test] fn recovery_object_names_preserve_unicode_and_delimiters() { let name = "view\tперсонажи\n"; let text = format!("VIEW\t{}\nTRIGGER\t74726967676572\n", hex::encode(name)); let objects = parse_recovery_objects("acore_characters", &text).unwrap(); assert_eq!(objects.len(), 2); assert_eq!(objects[0]["name"], name); assert_eq!(objects[1]["kind"], "TRIGGER"); assert!(parse_recovery_objects("test", "VIEW\tzz").is_err()); assert!(parse_recovery_objects("test", "UNKNOWN\t61").is_err()); assert!(parse_recovery_objects("test", "VIEW").is_err()); } fn folder(docker: bool) -> (tempfile::TempDir, PathBuf) { let d = tempfile::tempdir().unwrap(); let root = d.path().join("srv"); std::fs::create_dir_all(root.join("Settings")).unwrap(); std::fs::write( root.join("Settings/database.json"), format!(r#"{{"rootPassword":"{ROOT_PW}","appPassword":"{APP_PW}"}}"#), ) .unwrap(); if docker { std::fs::write(root.join("Settings/docker.json"), r#"{"project":"t1"}"#).unwrap(); } (d, root) } fn args(c: &Command) -> Vec { c.get_args() .map(|a| a.to_string_lossy().into_owned()) .collect() } fn env_of(c: &Command, key: &str) -> Option { c.get_envs() .find(|(k, _)| *k == OsStr::new(key)) .and_then(|(_, v)| v.map(|v| v.to_string_lossy().into_owned())) } #[test] fn a_docker_installation_runs_the_client_tools_inside_the_database_container() { let (_d, root) = folder(true); let db = Db::from_repack(&root, Account::Admin).unwrap(); for (tool, program) in [ ("mysql.exe", "mysql"), ("mysqldump.exe", "mysqldump"), ("mysqladmin.exe", "mysqladmin"), ] { let c = db.command(tool); assert_eq!(c.get_program(), "docker"); let a = args(&c); assert_eq!( &a[..6], ["exec", "-i", "-e", "MYSQL_PWD", "coa-t1-db", program] ); assert!( a.contains(&"--protocol=tcp".to_string()) && a.contains(&"--host=127.0.0.1".to_string()) && a.contains(&"--port=3306".to_string()) ); assert!(a.contains(&"--user=root".to_string())); assert!( a.iter().all(|x| !x.contains(ROOT_PW)), "the password must not be on the command line" ); assert_eq!(env_of(&c, "MYSQL_PWD").as_deref(), Some(ROOT_PW)); } let app = Db::from_repack(&root, Account::App) .unwrap() .command("mysql.exe"); assert!(args(&app).contains(&"--user=acore".to_string())); assert_eq!(env_of(&app, "MYSQL_PWD").as_deref(), Some(APP_PW)); } #[test] fn a_repack_still_uses_its_bundled_tools_on_the_host() { let (_d, root) = folder(false); std::fs::create_dir_all(root.join("mysql/bin")).unwrap(); for f in ["mysql.exe", "mysqldump.exe"] { std::fs::write(root.join("mysql/bin").join(f), b"x").unwrap(); } std::fs::write(root.join("Settings/repack.json"), r#"{"mysqlPort":3999}"#).unwrap(); let c = Db::from_repack(&root, Account::Admin) .unwrap() .command("mysql.exe"); assert_eq!( c.get_program(), root.join("mysql/bin").join("mysql.exe").as_os_str() ); let a = args(&c); assert!(!a.contains(&"exec".to_string())); assert!( a.contains(&"--port=3999".to_string()) && a.contains(&"--host=127.0.0.1".to_string()) ); assert_eq!(env_of(&c, "MYSQL_PWD").as_deref(), Some(ROOT_PW)); } #[test] fn a_docker_installation_does_not_need_tools_in_the_server_folder() { let (_d, root) = folder(true); assert!(!root.join("mysql").exists()); assert!(Db::from_repack(&root, Account::Admin).is_ok()); // ...but a broken Docker settings file is reported, not ignored. std::fs::write( root.join("Settings/docker.json"), r#"{"project":"Bad Name"}"#, ) .unwrap(); assert!(Db::from_repack(&root, Account::Admin).is_err()); } #[test] fn a_stopped_database_container_is_reported_as_a_database_that_is_not_running() { let (_d, root) = folder(true); let db = Db::from_repack(&root, Account::Admin).unwrap(); for text in [ "Error response from daemon: container abc is not running", "Error response from daemon: No such container: coa-t1-db", "ERROR 2003 (HY000): Can't connect to MySQL server", ] { assert!( db.fail(text.as_bytes()).to_string().contains("not running"), "{text}" ); } assert!(db .fail(b"ERROR 1045 (28000): Access denied for user 'root'") .to_string() .contains("Access denied")); } }