mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-22 19:25:56 +00:00
Add a configurable backup folder and drop-down bot settings
Backups can be stored in a chosen folder (new backups go there, older ones stay listed), and a backups folder that is a link to another drive no longer fails the update's safety backup check. SQUID settings that declare a fixed list of choices are edited as a drop-down and validated against it. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
f920ff8a59
commit
337418afe0
15 files changed
+253
-11
No files matched your search
@@ -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)
|
||||
}
|
||||
@@ -499,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();
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -452,7 +452,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
|
||||
@@ -595,7 +595,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."))); }
|
||||
|
||||
Reference in new issue
Block a user