Project Chimera
Меню

Исходники

496 строк · 23 КиБ

code/crates/chl-wine/src/save_backup.rs

1//! Бэкап сохранений одной игры — то, что реально попросил владелец: «бекап
2//! игровых сейвов … чтобы автоматом по базе тянулся у какой игры где сейвы
3//! лежат … но тоже с возможностью указать свою директорию».
4//!
5//! Собирает вместе три вещи:
6//! - [`crate::save_manifest`] — база ludusavi о том, где какая игра хранит
7//! сохранения;
8//! - [`crate::save_resolver`] — разворот её шаблонов пути в реальные
9//! каталоги для конкретной установки этой игры;
10//! - [`crate::snapshot`] (через [`crate::snapshot::create_any`]) — сам
11//! механизм версионного бэкапа, уже проверенный на снимках префикса.
12//!
13//! **Откуда берутся корни для разворота.** Библиотека этого лаунчера
14//! (`chl_core::library::Game`) не хранит для Steam-игр никакого «своего»
15//! префикса — их фактически запускает сам Steam через собственный Proton
16//! (см. doc-комментарий `Game::is_steam`), и `exe` у такой записи — это уже
17//! каталог установки (`.../steamapps/common/<Игра>`), а не исполняемый
18//! файл. Отсюда и разбор на два непохожих случая:
19//!
20//! - **Steam-игра** (`steam_appid` задан): `<base>` = `exe` напрямую,
21//! `<root>` — библиотека Steam, которой он принадлежит (родитель
22//! `steamapps`), Windows-профиль — `steamapps/compatdata/<appid>/pfx`,
23//! если он есть (Proton-игра); нет — значит игра нативная, и
24//! `<win...>`-плейсхолдеры просто не разворачиваются, а `<home>`/`<xdgData>`
25//! отлично работают и для неё.
26//! - **Своя игра** (добавлена вручную, `chl-wine` сам ведёт префикс):
27//! Windows-профиль — `drive_c/users/steamuser` в префиксе, на который
28//! указывает `Game::prefix`. `<base>`/`<root>` не определены — у ручных
29//! игр в этой библиотеке нет установочного каталога в смысле Steam, и
30//! врать про него незачем.
31//!
32//! Честно про охват: авто-поиск работает только для игр, у которых
33//! ludusavi-manifest вообще что-то знает, и только если хотя бы один из его
34//! путей действительно существует на этой машине. Для всего остального —
35//! ручной override (`chl_core::backups::BackupSettings`), который всегда в
36//! приоритете и никогда не перезаписывается автопоиском.
37
38use std::path::{Path, PathBuf};
39
40use anyhow::{Context, Result, bail};
41use chl_core::library::Game;
42use chl_core::paths::Dirs;
43
44use crate::save_manifest::Manifest;
45use crate::save_resolver::{self, Roots};
46pub use crate::snapshot::{Created, Snapshot};
47
48/// Куда лаунчер по умолчанию складывает бэкапы сохранений, если для игры
49/// не задан свой каталог назначения.
50///
51/// В данных (`Dirs::data`), не в кэше: то же рассуждение, что и у
52/// библиотеки игр — потеря должна быть последствием, а не побочным
53/// эффектом очистки кэша.
54pub fn default_backup_dir(dirs: &Dirs, game: &str) -> PathBuf {
55 dirs.data.join("save_backups").join(slug(game))
56}
57
58fn slug(name: &str) -> String {
59 let s: String = name
60 .chars()
61 .map(|c| if c.is_alphanumeric() { c } else { '_' })
62 .collect();
63 let s = s.trim_matches('_');
64 if s.is_empty() { "игра".to_string() } else { s.to_string() }
65}
66
67/// Основной Steam — где лежит `userdata` и (для этой библиотеки) обычно и
68/// `steamapps/compatdata`. `~/.steam/steam` — символическая ссылка, которую
69/// ставит сам клиент Steam; `~/.local/share/Steam` — путь для установок
70/// без Steam Runtime старого образца. Первый найденный и есть основной.
71pub fn primary_steam_root(home: &Path) -> Option<PathBuf> {
72 [home.join(".steam/steam"), home.join(".local/share/Steam")]
73 .into_iter()
74 .find(|p| p.join("steamapps").is_dir())
75}
76
77/// Единственный аккаунт в `userdata/` — источник `<storeUserId>`.
78///
79/// Если аккаунтов несколько (общий компьютер, несколько профилей), гадать,
80/// какой из них — тот самый, нечестно, и лучше вернуть `None`, чем
81/// подставить чужой ID.
82pub fn steam_user_id(steam_root: &Path) -> Option<String> {
83 let mut entries = std::fs::read_dir(steam_root.join("userdata"))
84 .ok()?
85 .flatten()
86 .filter(|e| e.path().is_dir())
87 .map(|e| e.file_name().to_string_lossy().into_owned());
88 let first = entries.next()?;
89 if entries.next().is_some() {
90 return None;
91 }
92 Some(first)
93}
94
95/// Библиотека Steam, которой принадлежит уже установленная игра — ищется
96/// по пути `exe`, а не предполагается основной: у большой библиотеки игры
97/// нередко стоят на второстепенном диске.
98///
99/// `exe` вида `.../<library>/steamapps/common/<Игра>[/остальное]` —
100/// возвращается `<library>`.
101pub fn steam_library_root(exe: &Path) -> Option<PathBuf> {
102 exe.ancestors().find_map(|a| {
103 if a.file_name()?.to_str()? != "common" {
104 return None;
105 }
106 let steamapps = a.parent()?;
107 if steamapps.file_name()?.to_str()? != "steamapps" {
108 return None;
109 }
110 steamapps.parent().map(Path::to_path_buf)
111 })
112}
113
114/// Корни для разворота шаблонов манифеста под конкретную игру.
115///
116/// `chimera_root` — установка `chl-wine` (`StartWineInstall::root`), нужна
117/// только для игр не из Steam, у которых есть свой префикс.
118pub fn roots_for_game(game: &Game, chimera_root: Option<&Path>) -> Roots {
119 let home = std::env::var_os("HOME").map(PathBuf::from).unwrap_or_else(|| PathBuf::from("/"));
120 let xdg_data = std::env::var_os("XDG_DATA_HOME")
121 .map(PathBuf::from)
122 .unwrap_or_else(|| home.join(".local/share"));
123 let xdg_config = std::env::var_os("XDG_CONFIG_HOME")
124 .map(PathBuf::from)
125 .unwrap_or_else(|| home.join(".config"));
126 let os_user_name = std::env::var("USER").unwrap_or_default();
127
128 let mut roots = Roots {
129 home,
130 xdg_data,
131 xdg_config,
132 os_user_name,
133 ..Default::default()
134 };
135
136 if game.is_steam() {
137 // <base> — сам каталог установки, который Steam уже сообщил
138 // библиотеке как exe (см. doc-комментарий модуля).
139 roots.base = Some(game.exe.clone());
140 if let Some(library) = steam_library_root(&game.exe) {
141 // compatdata лежит в той же библиотеке, что и сама игра — не
142 // обязательно в основной установке Steam.
143 if let Some(appid) = game.steam_appid {
144 let pfx = library.join(format!("steamapps/compatdata/{appid}/pfx"));
145 if pfx.join("drive_c").is_dir() {
146 roots.windows_user = Some(pfx.join("drive_c/users/steamuser"));
147 }
148 }
149 roots.root = Some(library);
150 }
151 if let Some(main) = primary_steam_root(&roots.home) {
152 roots.steam_user_id = steam_user_id(&main);
153 // <root> для userdata-шаблонов — именно основной Steam, а не
154 // второстепенная библиотека: userdata существует только там.
155 if roots.root.is_none() {
156 roots.root = Some(main);
157 }
158 }
159 } else if let Some(chimera_root) = chimera_root {
160 let pfx = chimera_root.join("data/pfx").join(&game.prefix);
161 if pfx.join("drive_c").is_dir() {
162 roots.windows_user = Some(pfx.join("drive_c/users/steamuser"));
163 }
164 }
165
166 roots
167}
168
169/// Ищет запись манифеста для игры: сперва по `steam_appid` (надёжнее
170/// всего — не зависит от разночтений в названии), потом по точному имени,
171/// потом по нормализованному.
172pub fn lookup_entry<'m>(manifest: &'m Manifest, name: &str, game: &Game) -> Option<&'m crate::save_manifest::ManifestEntry> {
173 if let Some(appid) = game.steam_appid
174 && let Some(e) = manifest.by_steam_id(appid)
175 {
176 return Some(e);
177 }
178 manifest
179 .by_exact_name(name)
180 .or_else(|| manifest.by_normalized_name(name))
181}
182
183/// Автоопределённый каталог с сохранениями игры — `None`, если в манифесте
184/// нет записи или ни один из её путей не существует на этой машине.
185pub fn auto_detect(manifest: &Manifest, name: &str, game: &Game, chimera_root: Option<&Path>) -> Option<PathBuf> {
186 let entry = lookup_entry(manifest, name, game)?;
187 let roots = roots_for_game(game, chimera_root);
188 save_resolver::best_save_dir(entry, &roots)
189}
190
191/// Делает бэкап каталога с сохранениями. `save_dir` должен существовать и
192/// быть каталогом — по любой другой причине (игра не найдена в манифесте,
193/// override не задан) решение уже должно быть принято вызывающей стороной.
194pub fn backup_now(save_dir: &Path, backup_dest: &Path, game: &str) -> Result<Created> {
195 if !save_dir.is_dir() {
196 bail!("{} не каталог — бэкапить нечего", save_dir.display());
197 }
198 crate::snapshot::create_any(
199 save_dir,
200 backup_dest,
201 "бэкап",
202 &format!("бэкап сохранений «{game}»"),
203 )
204}
205
206/// Метка автоматического бэкапа — по ней снимок считается автоматическим
207/// (`chl_core::state::AUTOMATIC_LABEL_PREFIXES`) и подпадает под уборку по
208/// числу поколений. Бэкап с кнопки остаётся ручным и не удаляется.
209pub const AUTO_LABEL: &str = "автобэкап сохранений";
210
211/// Каталог с сохранениями игры: ручной путь, если задан, иначе автопоиск
212/// по базе ludusavi. Одно правило для страницы «Бэкапы» и `chl run`.
213pub fn effective_save_dir(
214 name: &str,
215 game: &Game,
216 manifest: Option<&Manifest>,
217 chimera_root: Option<&Path>,
218 overrides: &chl_core::backups::BackupSettings,
219) -> Option<PathBuf> {
220 if let Some(dir) = overrides.get(name).and_then(|o| o.save_dir.clone()) {
221 return Some(dir);
222 }
223 auto_detect(manifest?, name, game, chimera_root)
224}
225
226/// Куда складывать бэкапы игры: ручной путь, если задан, иначе по умолчанию.
227pub fn effective_backup_dir(dirs: &Dirs, name: &str, overrides: &chl_core::backups::BackupSettings) -> PathBuf {
228 overrides
229 .get(name)
230 .and_then(|o| o.backup_dir.clone())
231 .unwrap_or_else(|| default_backup_dir(dirs, name))
232}
233
234/// Нужен ли автобэкап сейчас: `period_days` = 0 — после каждого выхода,
235/// иначе не чаще раза в столько дней от последнего автоматического.
236pub fn auto_backup_due(last_auto: Option<u64>, now: u64, period_days: u64) -> bool {
237 period_days == 0 || last_auto.is_none_or(|t| now.saturating_sub(t) >= period_days * 86_400)
238}
239
240/// Итог автобэкапа.
241#[derive(Debug)]
242pub enum AutoBackup {
243 /// Каталога с сохранениями не нашлось — ни ручного пути, ни записи в базе.
244 NoSaveDir,
245 /// Последний автобэкап ещё свежий.
246 NotDue,
247 Done { created: Created, removed: usize, kept: usize },
248}
249
250/// Бэкап сохранений после выхода из игры, с уборкой лишних поколений.
251///
252/// База ludusavi — только из кэша: выход из игры не должен ждать сеть.
253pub fn auto_backup(
254 dirs: &Dirs,
255 name: &str,
256 game: &Game,
257 chimera_root: Option<&Path>,
258 period_days: u64,
259 keep: usize,
260) -> Result<AutoBackup> {
261 let manifest = crate::save_manifest::load_cached(&dirs.cache).ok().flatten();
262 let overrides = chl_core::backups::BackupSettings::load(&dirs.backup_settings());
263 let Some(save_dir) = effective_save_dir(name, game, manifest.as_ref(), chimera_root, &overrides) else {
264 return Ok(AutoBackup::NoSaveDir);
265 };
266 if !save_dir.is_dir() {
267 return Ok(AutoBackup::NoSaveDir);
268 }
269 let dest = effective_backup_dir(dirs, name, &overrides);
270 let now = std::time::SystemTime::now()
271 .duration_since(std::time::UNIX_EPOCH)
272 .map(|d| d.as_secs())
273 .unwrap_or(0);
274 let last_auto = crate::snapshot::list(&dest)
275 .iter()
276 .filter(|s| s.origin == crate::snapshot::Origin::Automatic)
277 .map(|s| s.taken_at)
278 .max();
279 if !auto_backup_due(last_auto, now, period_days) {
280 return Ok(AutoBackup::NotDue);
281 }
282 let created = crate::snapshot::create_any(&save_dir, &dest, AUTO_LABEL, &format!("{AUTO_LABEL} «{name}»"))?;
283 let removed = crate::snapshot::prune(&dest, &crate::snapshot::Policy { keep: keep.max(1), days: 0 }, now).len();
284 let kept = crate::snapshot::list(&dest).iter().filter(|s| s.origin == crate::snapshot::Origin::Automatic).count();
285 Ok(AutoBackup::Done { created, removed, kept })
286}
287
288/// Все бэкапы игры, новые первыми — как есть у снимков префикса.
289pub fn list_backups(backup_dest: &Path) -> Vec<Snapshot> {
290 crate::snapshot::list(backup_dest)
291}
292
293/// Восстанавливает каталог с сохранениями из бэкапа.
294pub fn restore_backup(snapshot: &Snapshot, save_dir: &Path) -> Result<()> {
295 crate::snapshot::restore_any(snapshot, save_dir)
296 .with_context(|| format!("не восстанавливается {}", save_dir.display()))
297}
298
299#[cfg(test)]
300mod tests {
301 use super::*;
302 use chl_core::library::Source;
303
304 fn tmp(name: &str) -> PathBuf {
305 let d = std::env::temp_dir().join(format!("chl-test-save-backup-{name}"));
306 std::fs::remove_dir_all(&d).ok();
307 std::fs::create_dir_all(&d).unwrap();
308 d
309 }
310
311 fn game(exe: &Path, prefix: &str, steam_appid: Option<u32>) -> Game {
312 Game {
313 exe: exe.to_path_buf(),
314 prefix: prefix.to_string(),
315 source: if steam_appid.is_some() { Source::Store } else { Source::Manual },
316 steam_appid,
317 cover: None,
318 hero: None,
319 hidden: false,
320 kind: chl_core::library::GameKind::default(),
321 }
322 }
323
324 #[test]
325 fn steam_library_root_находит_библиотеку_по_common() {
326 let exe = PathBuf::from("/home/игрок/.steam/steam/steamapps/common/Portal");
327 assert_eq!(
328 steam_library_root(&exe),
329 Some(PathBuf::from("/home/игрок/.steam/steam"))
330 );
331 }
332
333 #[test]
334 fn steam_library_root_работает_и_для_вторичной_библиотеки() {
335 let exe = PathBuf::from("/mnt/ssd2/SteamLibrary/steamapps/common/Игра/game.exe");
336 assert_eq!(
337 steam_library_root(&exe),
338 Some(PathBuf::from("/mnt/ssd2/SteamLibrary"))
339 );
340 }
341
342 #[test]
343 fn steam_library_root_none_для_не_steam_пути() {
344 assert_eq!(steam_library_root(Path::new("/home/игрок/Games/RF/game.exe")), None);
345 }
346
347 #[test]
348 fn steam_user_id_единственный_аккаунт_находится() {
349 let root = tmp("userdata-one");
350 std::fs::create_dir_all(root.join("userdata/12345")).unwrap();
351 assert_eq!(steam_user_id(&root), Some("12345".to_string()));
352 std::fs::remove_dir_all(&root).ok();
353 }
354
355 #[test]
356 fn steam_user_id_несколько_аккаунтов_не_угадывается() {
357 let root = tmp("userdata-many");
358 std::fs::create_dir_all(root.join("userdata/111")).unwrap();
359 std::fs::create_dir_all(root.join("userdata/222")).unwrap();
360 assert_eq!(steam_user_id(&root), None);
361 std::fs::remove_dir_all(&root).ok();
362 }
363
364 #[test]
365 fn roots_for_game_steam_без_compatdata_считается_нативной() {
366 let root = tmp("steam-native");
367 let steamapps = root.join("steam/steamapps");
368 std::fs::create_dir_all(steamapps.join("common/Portal")).unwrap();
369 let exe = steamapps.join("common/Portal");
370 let g = game(&exe, "pfx_default", Some(400));
371
372 let roots = roots_for_game(&g, None);
373 assert_eq!(roots.base, Some(exe));
374 assert_eq!(roots.windows_user, None, "compatdata нет — не Proton");
375 std::fs::remove_dir_all(&root).ok();
376 }
377
378 #[test]
379 fn roots_for_game_steam_с_compatdata_даёт_windows_профиль() {
380 let root = tmp("steam-proton");
381 let steamapps = root.join("steam/steamapps");
382 std::fs::create_dir_all(steamapps.join("common/Игра")).unwrap();
383 std::fs::create_dir_all(steamapps.join("compatdata/12345/pfx/drive_c/users/steamuser"))
384 .unwrap();
385 let exe = steamapps.join("common/Игра");
386 let g = game(&exe, "pfx_default", Some(12345));
387
388 let roots = roots_for_game(&g, None);
389 assert_eq!(
390 roots.windows_user,
391 Some(steamapps.join("compatdata/12345/pfx/drive_c/users/steamuser"))
392 );
393 std::fs::remove_dir_all(&root).ok();
394 }
395
396 #[test]
397 fn roots_for_game_своя_игра_берёт_профиль_из_префикса_chl_wine() {
398 let root = tmp("own-prefix");
399 let chimera = root.join("chimera");
400 std::fs::create_dir_all(chimera.join("data/pfx/pfx_default/drive_c/users/steamuser"))
401 .unwrap();
402 let exe = root.join("Games/RF/game.exe");
403 let g = game(&exe, "pfx_default", None);
404
405 let roots = roots_for_game(&g, Some(&chimera));
406 assert_eq!(
407 roots.windows_user,
408 Some(chimera.join("data/pfx/pfx_default/drive_c/users/steamuser"))
409 );
410 assert_eq!(roots.base, None, "у ручных игр нет каталога установки Steam");
411 std::fs::remove_dir_all(&root).ok();
412 }
413
414 #[test]
415 fn backup_now_отказывает_на_несуществующем_каталоге() {
416 let root = tmp("no-save-dir");
417 let err = backup_now(&root.join("нет"), &root.join("dest"), "Игра")
418 .unwrap_err()
419 .to_string();
420 assert!(err.contains("бэкапить нечего"), "{err}");
421 std::fs::remove_dir_all(&root).ok();
422 }
423
424 #[test]
425 fn backup_now_и_list_backups_работают_вместе() {
426 let root = tmp("roundtrip");
427 let save = root.join("save");
428 std::fs::create_dir_all(&save).unwrap();
429 std::fs::write(save.join("слот.dat"), "прогресс").unwrap();
430
431 let dest = default_backup_dir(
432 &Dirs { config: root.join("config"), data: root.clone(), cache: root.join("cache"), state: root.join("state") },
433 "Моя Игра",
434 );
435 let created = backup_now(&save, &dest, "Моя Игра").unwrap();
436 assert!(created.snapshot.path.join("слот.dat").is_file());
437
438 let listed = list_backups(&dest);
439 assert_eq!(listed.len(), 1);
440 std::fs::remove_dir_all(&root).ok();
441 }
442
443 #[test]
444 fn lookup_entry_предпочитает_steam_appid_имени() {
445 let manifest_yaml = r#"
446"Игра А":
447 steam:
448 id: 1
449 files:
450 "<base>/save": { tags: [save] }
451"Игра Б":
452 files:
453 "<base>/иное": { tags: [save] }
454"#;
455 let m = crate::save_manifest::parse(manifest_yaml).unwrap();
456 // В библиотеке игра называется иначе, чем в манифесте, но appid тот же.
457 let g = game(Path::new("/base"), "pfx_default", Some(1));
458 let found = lookup_entry(&m, "Совсем другое имя", &g).unwrap();
459 assert!(found.files.iter().any(|f| f.template.ends_with("/save")));
460 }
461
462 #[test]
463 fn default_backup_dir_превращает_имя_игры_в_безопасный_путь() {
464 let dirs = Dirs {
465 config: PathBuf::from("/c"),
466 data: PathBuf::from("/d"),
467 cache: PathBuf::from("/ch"),
468 state: PathBuf::from("/s"),
469 };
470 let p = default_backup_dir(&dirs, "A Plague Tale: Innocence");
471 assert_eq!(p, PathBuf::from("/d/save_backups/A_Plague_Tale__Innocence"));
472 }
473}
474
475#[cfg(test)]
476mod auto_tests {
477 use super::*;
478
479 #[test]
480 fn после_каждого_выхода_или_раз_в_n_дней() {
481 let day = 86_400;
482 assert!(auto_backup_due(Some(100), 101, 0));
483 assert!(auto_backup_due(None, 5, 3));
484 assert!(!auto_backup_due(Some(10 * day), 12 * day, 3));
485 assert!(auto_backup_due(Some(10 * day), 13 * day, 3));
486 }
487
488 #[test]
489 fn автобэкап_и_снимок_перед_пакетами_считаются_автоматическими() {
490 assert!(chl_core::state::is_automatic_label(AUTO_LABEL));
491 assert!(chl_core::state::is_automatic_label("до установки пакетов"));
492 assert!(!chl_core::state::is_automatic_label("бэкап"));
493 }
494}
495
496