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:
ДмитрийandClaude Sonnet 5.5 committed 2026-10-08 07:08:09 +05:00
1 parent f920ff8a59
commit 337418afe0
15 files changed
+253 -11

No files matched your search

+118 -5
View File
@@ -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();
+33 -1
View File
@@ -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();
+2 -2
View File
@@ -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."))); }