Project Chimera
Меню

Исходники

1006 строк · 48 КиБ

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

1//! Контентно-адресуемое хранилище — но только для установленных сборок
2//! Wine/Proton (`data/wine/*`), не для префиксов и не для их снимков.
3//!
4//! Это осознанное сужение scope из `CAS-DESIGN.md`, утверждённое владельцем:
5//! сборки Wine — read-only референсные данные, которые в любой момент можно
6//! перекачать заново, если что-то пойдёт не так. Живые префиксы
7//! (`data/pfx/*`) и их версионные снимки (`data/pfx_snapshots/*`) держат
8//! незаменяемые данные игрока (сохранения, конфиги) и этим модулем не
9//! затрагиваются вообще — ни на чтение, ни тем более на запись. Расширение
10//! на эту ось — решение для отдельного, отдельно согласованного прохода.
11//!
12//! ## Устройство
13//!
14//! ```text
15//! data/cas/
16//! objects/<первые 2 hex sha256>/<остальные 62 hex> # файл, неизменяемый
17//! manifests/wine/<имя сборки>/manifest.json # что сборка содержит
18//! ```
19//!
20//! Объект пишется через staging (временный файл рядом) и `rename` на
21//! финальное имя — тот же приём, что уже применяют `snapshot::create()` и
22//! `chl_core::paths::write_atomically`: читатель либо видит целый файл под
23//! конечным именем, либо не видит имени вообще. После записи объект
24//! переводится в `0o444` — не полная защита от `rm`, но защита от случайной
25//! перезаписи содержимого, на которое может ссылаться не одна сборка.
26//!
27//! ## Три операции
28//!
29//! - [`adopt`] — принять уже установленную сборку в пул: хэширует каждый её
30//! файл, кладёт отсутствующие объекты в пул, пишет манифест. Каталог
31//! сборки при этом не трогается вообще (ни на запись, ни на удаление) —
32//! операция чисто аддитивная, поэтому безопасна и на живой установке.
33//! - [`materialize`] — обратное: по манифесту собрать рабочий каталог
34//! сборки из объектов пула reflink-копиями. Сегодня ничем не вызывается
35//! из `chl wine install` — это отдельный, более поздний шаг (см.
36//! `CAS-DESIGN.md`, «слоями проще откатываться»).
37//! - [`plan_gc`] / [`delete_candidates`] — сборка мусора mark-and-sweep:
38//! живые хэши — это объединение хэшей всех манифестов сборок Wine,
39//! которые сегодня зарегистрированы; всё остальное в пуле — кандидат.
40//! `plan_gc` **никогда** ничего не удаляет — это и есть dry-run, он же
41//! единственное поведение без явного `--delete` на уровне CLI.
42//!
43//! ## Символические ссылки
44//!
45//! В отличие от [`crate::dedup`] и [`crate::integrity`] (где симлинк —
46//! шум, который надо не засчитать дважды), здесь симлинк — часть того, что
47//! реально нужно для рабочей сборки: `libwine.so -> libwine.so.1` и
48//! аналоги встречаются массово. Манифест поэтому хранит их отдельным
49//! списком `(путь, цель)`, не как объект пула — у симлинка нет "содержимого"
50//! в смысле whole-file-хэша, есть только текст цели. Пропустить их значило
51//! бы восстанавливать из пула сборку, которая выглядит полной, но не
52//! запускается.
53//!
54//! ## Что сюда сознательно не входит
55//!
56//! Блокировка каталога `data/cas/` на время `plan_gc`+`delete_candidates`
57//! (упомянутая в `CAS-DESIGN.md` как обязательная для *общего* CAS) здесь не
58//! реализована: при однопользовательском CLI и данных, которые можно
59//! перекачать заново, риск гонки между `adopt` и `gc --delete` заметно ниже,
60//! чем для префиксов. Тем не менее не запускай `chl cas gc --delete`
61//! параллельно с `chl cas adopt` — короткий зазор между построением плана и
62//! удалением кандидатов гонку не исключает полностью.
63
64use std::collections::{BTreeMap, HashSet};
65use std::os::unix::fs::PermissionsExt;
66use std::path::{Path, PathBuf};
67
68use anyhow::{Context, Result, bail};
69
70use crate::dedup::hash_file;
71
72const MANIFEST_FILE: &str = "manifest.json";
73
74/// Запись об одном обычном файле сборки в манифесте.
75#[derive(Debug, Clone, PartialEq, Eq)]
76pub struct FileEntry {
77 /// Права доступа (последние 9 бит, `chmod`-стиль) — материализация
78 /// восстанавливает именно их, а не то, что решит сам `cp`.
79 pub mode: u32,
80 /// sha256 содержимого — тем же алгоритмом, что [`crate::dedup`] и
81 /// [`crate::integrity`].
82 pub hash: String,
83 pub size: u64,
84}
85
86/// Манифест одной принятой в пул сборки Wine — что в ней должно быть.
87#[derive(Debug, Clone, PartialEq, Eq)]
88pub struct WineManifest {
89 pub build: String,
90 /// Секунды эпохи Unix, когда манифест был (пере)построен.
91 pub adopted_at: u64,
92 /// Относительный путь → запись об обычном файле.
93 pub files: BTreeMap<PathBuf, FileEntry>,
94 /// Относительный путь → цель символической ссылки (как её вернул
95 /// `read_link`, без разрешения — может быть относительной).
96 pub symlinks: BTreeMap<PathBuf, PathBuf>,
97}
98
99impl WineManifest {
100 /// Сколько байт займёт материализованная из этого манифеста сборка —
101 /// сумма размеров обычных файлов (симлинки на диске занимают величины,
102 /// которыми можно пренебречь).
103 pub fn logical_bytes(&self) -> u64 {
104 self.files.values().map(|f| f.size).sum()
105 }
106}
107
108/// Итог [`adopt`].
109#[derive(Debug, Clone, Default)]
110pub struct AdoptStats {
111 pub build: String,
112 pub files: usize,
113 pub symlinks: usize,
114 /// Суммарный размер всех обычных файлов сборки (не только новых).
115 pub scanned_bytes: u64,
116 /// Сколько объектов реально дописано в пул этим проходом.
117 pub new_objects: usize,
118 pub new_object_bytes: u64,
119 /// Сколько файлов сборки совпало с уже имевшимся в пуле объектом —
120 /// собственно и есть дедупликация.
121 pub reused_objects: usize,
122}
123
124/// Итог [`materialize`].
125#[derive(Debug, Clone, Default)]
126pub struct MaterializeStats {
127 pub files: usize,
128 pub symlinks: usize,
129 pub bytes: u64,
130}
131
132/// Один кандидат на удаление сборкой мусора: объект пула, на который не
133/// ссылается ни один манифест.
134#[derive(Debug, Clone)]
135pub struct GcCandidate {
136 pub hash: String,
137 pub size: u64,
138}
139
140/// Результат прохода mark-and-sweep. Само по себе построение плана ничего
141/// не удаляет — это и есть dry-run; удаление — отдельный шаг,
142/// [`delete_candidates`].
143#[derive(Debug, Clone, Default)]
144pub struct GcPlan {
145 /// Сколько уникальных хэшей помечены живыми (объединение по всем
146 /// манифестам принятых сборок).
147 pub live_hashes: usize,
148 pub total_objects: usize,
149 pub total_bytes: u64,
150 /// Отсортированы по убыванию размера — крупные кандидаты важнее.
151 pub candidates: Vec<GcCandidate>,
152}
153
154impl GcPlan {
155 pub fn reclaimable_bytes(&self) -> u64 {
156 self.candidates.iter().map(|c| c.size).sum()
157 }
158}
159
160/// Корень хранилища CAS — рядом с `data/wine`, не вместо него.
161pub fn cas_root(install_root: &Path) -> PathBuf {
162 install_root.join("data/cas")
163}
164
165fn objects_dir(cas_root: &Path) -> PathBuf {
166 cas_root.join("objects")
167}
168
169fn wine_manifests_dir(cas_root: &Path) -> PathBuf {
170 cas_root.join("manifests/wine")
171}
172
173fn manifest_path(cas_root: &Path, build: &str) -> PathBuf {
174 wine_manifests_dir(cas_root).join(build).join(MANIFEST_FILE)
175}
176
177fn object_path(cas_root: &Path, hash: &str) -> PathBuf {
178 // sha256 — всегда 64 hex-символа; при повреждённом хэше (не должно
179 // случиться, но проверка дешёвая) лучше явная паника на программной
180 // ошибке, чем тихо неверный путь.
181 debug_assert!(hash.len() == 64, "хэш неверной длины: {hash:?}");
182 objects_dir(cas_root).join(&hash[..2]).join(&hash[2..])
183}
184
185// ─── Объектный пул ──────────────────────────────────────────────────────────
186
187/// Кладёт файл в пул, если объекта с таким содержимым там ещё нет.
188///
189/// Возвращает `(hash, добавлен_ли_новый_объект)`. Копия делается через
190/// `cp --reflink=auto` (честный запасной путь на файловых системах без
191/// reflink — тот же приём, что у `snapshot::create`), пишется во временное
192/// имя рядом с финальным, и хэш переписанного объекта перепроверяется
193/// заново перед `rename` — так же, как этого требует `CAS-DESIGN.md`:
194/// «запись объекта не считается завершённой, пока переписанное содержимое
195/// не подтверждено собственным хэшем ещё раз».
196fn put_object(cas_root: &Path, src: &Path) -> Result<(String, bool)> {
197 let hash = hash_file(src).with_context(|| format!("не хэшируется {}", src.display()))?;
198 let target = object_path(cas_root, &hash);
199 if target.is_file() {
200 return Ok((hash, false));
201 }
202
203 let parent = target.parent().context("у объекта нет родительского каталога")?;
204 std::fs::create_dir_all(parent)
205 .with_context(|| format!("не создаётся {}", parent.display()))?;
206
207 let staging = parent.join(format!(".tmp-{}-{}", std::process::id(), hash));
208 let _ = std::fs::remove_file(&staging);
209
210 let status = std::process::Command::new("cp")
211 .args(["--reflink=auto"])
212 .arg(src)
213 .arg(&staging)
214 .status()
215 .context("не запускается cp — он нужен для записи в пул CAS")?;
216 if !status.success() {
217 std::fs::remove_file(&staging).ok();
218 bail!("копирование {} в пул не удалось", src.display());
219 }
220
221 let verify = hash_file(&staging)
222 .with_context(|| format!("не перепроверяется хэш записанного объекта {hash}"))?;
223 if verify != hash {
224 std::fs::remove_file(&staging).ok();
225 bail!(
226 "хэш записанного в пул объекта не совпал: ожидался {hash}, получился {verify} \
227 (источник: {})",
228 src.display()
229 );
230 }
231
232 // Неизменяемость: снять права на запись у объекта, на который может
233 // ссылаться не одна сборка.
234 let mut perms = std::fs::metadata(&staging)?.permissions();
235 perms.set_mode(0o444);
236 std::fs::set_permissions(&staging, perms)
237 .with_context(|| format!("не выставляются права {}", staging.display()))?;
238
239 if target.exists() {
240 // Кто-то параллельно уже положил объект с тем же хэшем — по
241 // определению content-addressing это то же самое содержимое,
242 // ошибки здесь нет.
243 std::fs::remove_file(&staging).ok();
244 return Ok((hash, false));
245 }
246 std::fs::rename(&staging, &target)
247 .with_context(|| format!("не переносится в {}", target.display()))?;
248 Ok((hash, true))
249}
250
251// ─── Adopt ──────────────────────────────────────────────────────────────────
252
253/// Принимает установленную сборку Wine в пул объектов.
254///
255/// Только читает `build_dir` — ничего в нём не создаётся, не переименовывается
256/// и не удаляется. Безопасно запускать повторно (идемпотентно: файлы, чьи
257/// объекты уже в пуле, просто засчитываются как `reused_objects`) и на живой
258/// установке, которой кто-то в этот момент пользуется — сборки Wine на
259/// чтение во время игры не меняются.
260pub fn adopt(cas_root: &Path, build_dir: &Path, build: &str) -> Result<AdoptStats> {
261 if !build_dir.is_dir() {
262 bail!("{} не похож на каталог сборки Wine", build_dir.display());
263 }
264
265 let mut files = BTreeMap::new();
266 let mut symlinks = BTreeMap::new();
267 let mut stats = AdoptStats { build: build.to_string(), ..Default::default() };
268
269 let mut stack = vec![build_dir.to_path_buf()];
270 while let Some(dir) = stack.pop() {
271 let Ok(entries) = std::fs::read_dir(&dir) else {
272 continue;
273 };
274 for entry in entries.flatten() {
275 let Ok(file_type) = entry.file_type() else {
276 continue;
277 };
278 let path = entry.path();
279 let Ok(rel) = path.strip_prefix(build_dir) else {
280 continue;
281 };
282
283 // file_type() у DirEntry не идёт по ссылке (как в chl_wine::dedup)
284 // — именно это позволяет отличить симлинк от обычного файла.
285 if file_type.is_symlink() {
286 if let Ok(target) = std::fs::read_link(&path) {
287 symlinks.insert(rel.to_path_buf(), target);
288 stats.symlinks += 1;
289 }
290 continue;
291 }
292 if file_type.is_dir() {
293 stack.push(path);
294 continue;
295 }
296 if !file_type.is_file() {
297 continue;
298 }
299 let Ok(meta) = entry.metadata() else {
300 continue;
301 };
302
303 let size = meta.len();
304 let mode = meta.permissions().mode() & 0o777;
305 stats.files += 1;
306 stats.scanned_bytes += size;
307
308 let (hash, is_new) = put_object(cas_root, &path)?;
309 if is_new {
310 stats.new_objects += 1;
311 stats.new_object_bytes += size;
312 } else {
313 stats.reused_objects += 1;
314 }
315 files.insert(rel.to_path_buf(), FileEntry { mode, hash, size });
316 }
317 }
318
319 let manifest = WineManifest { build: build.to_string(), adopted_at: now(), files, symlinks };
320 write_manifest(cas_root, &manifest)?;
321 Ok(stats)
322}
323
324fn write_manifest(cas_root: &Path, manifest: &WineManifest) -> Result<()> {
325 let dir = wine_manifests_dir(cas_root).join(&manifest.build);
326 std::fs::create_dir_all(&dir).with_context(|| format!("не создаётся {}", dir.display()))?;
327
328 let files: Vec<serde_json::Value> = manifest
329 .files
330 .iter()
331 .map(|(path, e)| {
332 serde_json::json!({
333 "path": path.to_string_lossy(),
334 "mode": e.mode,
335 "hash": e.hash,
336 "size": e.size,
337 })
338 })
339 .collect();
340 let symlinks: Vec<serde_json::Value> = manifest
341 .symlinks
342 .iter()
343 .map(|(path, target)| {
344 serde_json::json!({
345 "path": path.to_string_lossy(),
346 "target": target.to_string_lossy(),
347 })
348 })
349 .collect();
350 let value = serde_json::json!({
351 "build": manifest.build,
352 "adopted_at": manifest.adopted_at,
353 "files": files,
354 "symlinks": symlinks,
355 });
356 let text =
357 serde_json::to_string_pretty(&value).context("не сериализуется манифест CAS")?;
358
359 let target = dir.join(MANIFEST_FILE);
360 let staging = dir.join(format!(".{MANIFEST_FILE}.новый"));
361 std::fs::write(&staging, &text)
362 .with_context(|| format!("не пишется {}", staging.display()))?;
363 std::fs::rename(&staging, &target)
364 .with_context(|| format!("не переносится в {}", target.display()))
365}
366
367/// Читает манифест принятой сборки, если он есть.
368pub fn read_manifest(cas_root: &Path, build: &str) -> Option<WineManifest> {
369 read_manifest_file(&manifest_path(cas_root, build)).ok()
370}
371
372fn read_manifest_file(path: &Path) -> Result<WineManifest> {
373 let text = std::fs::read_to_string(path)
374 .with_context(|| format!("не читается {}", path.display()))?;
375 let value: serde_json::Value =
376 serde_json::from_str(&text).with_context(|| format!("манифест {} повреждён", path.display()))?;
377
378 let build = value.get("build").and_then(|v| v.as_str()).unwrap_or_default().to_string();
379 let adopted_at = value.get("adopted_at").and_then(|v| v.as_u64()).unwrap_or(0);
380
381 let mut files = BTreeMap::new();
382 for f in value.get("files").and_then(|v| v.as_array()).into_iter().flatten() {
383 let (Some(path), Some(mode), Some(hash), Some(size)) = (
384 f.get("path").and_then(|v| v.as_str()),
385 f.get("mode").and_then(|v| v.as_u64()),
386 f.get("hash").and_then(|v| v.as_str()),
387 f.get("size").and_then(|v| v.as_u64()),
388 ) else {
389 continue;
390 };
391 // Хэш неверной длины в манифесте на диске — повреждение, а не
392 // валидный объект; лучше пропустить запись, чем построить путь в
393 // пул, который никогда не будет существовать.
394 if hash.len() != 64 {
395 continue;
396 }
397 files.insert(
398 PathBuf::from(path),
399 FileEntry { mode: mode as u32, hash: hash.to_string(), size },
400 );
401 }
402
403 let mut symlinks = BTreeMap::new();
404 for s in value.get("symlinks").and_then(|v| v.as_array()).into_iter().flatten() {
405 let (Some(path), Some(target)) = (
406 s.get("path").and_then(|v| v.as_str()),
407 s.get("target").and_then(|v| v.as_str()),
408 ) else {
409 continue;
410 };
411 symlinks.insert(PathBuf::from(path), PathBuf::from(target));
412 }
413
414 Ok(WineManifest { build, adopted_at, files, symlinks })
415}
416
417/// Имена всех сборок, у которых есть манифест в пуле, по алфавиту.
418pub fn adopted_builds(cas_root: &Path) -> Vec<String> {
419 let dir = wine_manifests_dir(cas_root);
420 let Ok(entries) = std::fs::read_dir(&dir) else {
421 return Vec::new();
422 };
423 let mut out: Vec<String> = entries
424 .flatten()
425 .filter(|e| e.path().join(MANIFEST_FILE).is_file())
426 .map(|e| e.file_name().to_string_lossy().into_owned())
427 .collect();
428 out.sort();
429 out
430}
431
432// ─── Материализация ─────────────────────────────────────────────────────────
433
434/// Собирает рабочий каталог сборки из объектов пула по манифесту.
435///
436/// `target_dir` не должен существовать — материализация в уже занятый путь
437/// отклоняется, чтобы не гадать, что делать с тем, что там уже лежит; вызов
438/// сам решает, освобождать ли место сначала. Собирается во временном
439/// каталоге рядом и переносится одним `rename` — тот же приём, что
440/// `Installer::install()` уже применяет к распакованным архивам: прерванная
441/// материализация не должна выглядеть как готовая сборка.
442///
443/// Каждый файл после reflink-копии перепроверяется по хэшу из манифеста —
444/// это единственное место, где содержимое пула читается заново перед тем,
445/// как отдать его вызывающему как «готово», и оно же ловит повреждение
446/// объекта, случившееся уже после того, как `put_object` его записал и
447/// проверил.
448pub fn materialize(cas_root: &Path, manifest: &WineManifest, target_dir: &Path) -> Result<MaterializeStats> {
449 if target_dir.exists() {
450 bail!(
451 "{} уже существует — материализация в занятый путь отклонена",
452 target_dir.display()
453 );
454 }
455 let parent = target_dir.parent().context("у целевого пути нет родителя")?;
456 std::fs::create_dir_all(parent)
457 .with_context(|| format!("не создаётся {}", parent.display()))?;
458
459 let staging = parent.join(format!(
460 ".{}.материализация",
461 target_dir.file_name().unwrap_or_default().to_string_lossy()
462 ));
463 if staging.exists() {
464 std::fs::remove_dir_all(&staging).ok();
465 }
466 std::fs::create_dir_all(&staging)
467 .with_context(|| format!("не создаётся {}", staging.display()))?;
468
469 let result = materialize_into(cas_root, manifest, &staging);
470 let stats = match result {
471 Ok(stats) => stats,
472 Err(e) => {
473 std::fs::remove_dir_all(&staging).ok();
474 return Err(e);
475 }
476 };
477
478 std::fs::rename(&staging, target_dir)
479 .with_context(|| format!("не переносится в {}", target_dir.display()))?;
480 Ok(stats)
481}
482
483fn materialize_into(cas_root: &Path, manifest: &WineManifest, staging: &Path) -> Result<MaterializeStats> {
484 let mut stats = MaterializeStats::default();
485
486 for (rel, entry) in &manifest.files {
487 let dest = staging.join(rel);
488 if let Some(dir) = dest.parent() {
489 std::fs::create_dir_all(dir)
490 .with_context(|| format!("не создаётся {}", dir.display()))?;
491 }
492 let object = object_path(cas_root, &entry.hash);
493 if !object.is_file() {
494 bail!(
495 "объект {} (файл {}) отсутствует в пуле — манифест {} \
496 не соответствует содержимому пула",
497 entry.hash,
498 rel.display(),
499 manifest.build
500 );
501 }
502
503 let status = std::process::Command::new("cp")
504 .args(["--reflink=auto"])
505 .arg(&object)
506 .arg(&dest)
507 .status()
508 .context("не запускается cp — он нужен для материализации из пула")?;
509 if !status.success() {
510 bail!("копирование {} из пула не удалось", rel.display());
511 }
512
513 let got = hash_file(&dest).with_context(|| format!("не хэшируется {}", dest.display()))?;
514 if got != entry.hash {
515 bail!(
516 "материализованный файл {} не совпал по хэшу с манифестом \
517 (ожидался {}, получился {got}) — объект в пуле повреждён",
518 rel.display(),
519 entry.hash
520 );
521 }
522
523 let mut perms = std::fs::metadata(&dest)?.permissions();
524 perms.set_mode(entry.mode);
525 std::fs::set_permissions(&dest, perms)
526 .with_context(|| format!("не выставляются права {}", dest.display()))?;
527
528 stats.files += 1;
529 stats.bytes += entry.size;
530 }
531
532 for (rel, target) in &manifest.symlinks {
533 let dest = staging.join(rel);
534 if let Some(dir) = dest.parent() {
535 std::fs::create_dir_all(dir)
536 .with_context(|| format!("не создаётся {}", dir.display()))?;
537 }
538 std::os::unix::fs::symlink(target, &dest)
539 .with_context(|| format!("не создаётся символическая ссылка {}", dest.display()))?;
540 stats.symlinks += 1;
541 }
542
543 Ok(stats)
544}
545
546// ─── Сборка мусора: mark-and-sweep ──────────────────────────────────────────
547
548/// Строит план сборки мусора. **Ничего не удаляет** — это и есть dry-run;
549/// см. модульную документацию про обязательный порядок из `CAS-DESIGN.md`.
550///
551/// «Живые» — хэши, на которые ссылается хотя бы один манифест из
552/// `manifests/wine/*/manifest.json`. Определяется заново на каждый вызов
553/// (mark-and-sweep, не подсчёт ссылок): забытый вручную удалённый манифест
554/// или испорченный счётчик здесь не может тихо разойтись с реальностью,
555/// потому что состояния между запусками просто нет.
556pub fn plan_gc(cas_root: &Path) -> Result<GcPlan> {
557 let live = live_hashes(cas_root)?;
558
559 let mut plan = GcPlan { live_hashes: live.len(), ..Default::default() };
560 let objects = objects_dir(cas_root);
561 let Ok(shards) = std::fs::read_dir(&objects) else {
562 return Ok(plan);
563 };
564 for shard in shards.flatten() {
565 if !shard.path().is_dir() {
566 continue;
567 }
568 let shard_name = shard.file_name().to_string_lossy().into_owned();
569 let Ok(inner) = std::fs::read_dir(shard.path()) else {
570 continue;
571 };
572 for f in inner.flatten() {
573 if !f.path().is_file() {
574 continue;
575 }
576 let rest = f.file_name().to_string_lossy().into_owned();
577 // Пропускаем недописанные staging-файлы (`.tmp-...`), если они
578 // вдруг остались от прерванного put_object — это не объект.
579 if rest.starts_with('.') {
580 continue;
581 }
582 let hash = format!("{shard_name}{rest}");
583 let size = f.metadata().map(|m| m.len()).unwrap_or(0);
584
585 plan.total_objects += 1;
586 plan.total_bytes += size;
587 if !live.contains(&hash) {
588 plan.candidates.push(GcCandidate { hash, size });
589 }
590 }
591 }
592 plan.candidates.sort_by_key(|c| std::cmp::Reverse(c.size));
593 Ok(plan)
594}
595
596fn live_hashes(cas_root: &Path) -> Result<HashSet<String>> {
597 let mut live = HashSet::new();
598 for build in adopted_builds(cas_root) {
599 if let Some(manifest) = read_manifest(cas_root, &build) {
600 live.extend(manifest.files.values().map(|f| f.hash.clone()));
601 }
602 }
603 Ok(live)
604}
605
606/// Удаляет объекты пула из [`GcPlan::candidates`]. Единственная по-настоящему
607/// разрушительная операция во всём модуле — вызывающий обязан сначала
608/// показать план пользователю и получить явное подтверждение (в CLI это
609/// флаг `--delete`, никогда не подразумеваемый по умолчанию).
610///
611/// План и удаление разнесены по времени: между `plan_gc` и вызовом этой
612/// функции кто-то мог успеть сделать `adopt` новой сборки, ссылающейся на
613/// один из кандидатов. Это не проверяется повторно (см. модульную
614/// документацию про отсутствие блокировки) — на однопользовательском CLI
615/// разумный компромисс, но не гарантия при параллельном использовании.
616pub fn delete_candidates(cas_root: &Path, plan: &GcPlan) -> Result<u64> {
617 let mut freed = 0u64;
618 for c in &plan.candidates {
619 let path = object_path(cas_root, &c.hash);
620 match std::fs::remove_file(&path) {
621 Ok(()) => freed += c.size,
622 Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
623 // Уже удалён — другим вызовом или руками. Не ошибка сборки
624 // мусора: цель (объекта больше нет) уже достигнута.
625 }
626 Err(e) => return Err(e).with_context(|| format!("не удаляется {}", path.display())),
627 }
628 }
629 Ok(freed)
630}
631
632fn now() -> u64 {
633 std::time::SystemTime::now()
634 .duration_since(std::time::UNIX_EPOCH)
635 .map(|d| d.as_secs())
636 .unwrap_or(0)
637}
638
639#[cfg(test)]
640mod tests {
641 use super::*;
642
643 fn scratch(name: &str) -> PathBuf {
644 let d = std::env::temp_dir().join(format!("chl-test-cas-{name}"));
645 std::fs::remove_dir_all(&d).ok();
646 std::fs::create_dir_all(&d).unwrap();
647 d
648 }
649
650 /// Синтетическая, но реалистичная по форме сборка: пара обычных файлов
651 /// (один из них "общий" между двумя сборками в тестах дедупликации) и
652 /// симлинк вида `libwine.so -> libwine.so.1`, как в настоящих сборках
653 /// Wine.
654 fn fake_build(dir: &Path, shared_content: &str) {
655 std::fs::create_dir_all(dir.join("bin")).unwrap();
656 std::fs::create_dir_all(dir.join("lib")).unwrap();
657 std::fs::write(dir.join("bin/wine"), "исполняемый файл, своя версия").unwrap();
658 let mut perms = std::fs::metadata(dir.join("bin/wine")).unwrap().permissions();
659 perms.set_mode(0o755);
660 std::fs::set_permissions(dir.join("bin/wine"), perms).unwrap();
661
662 std::fs::write(dir.join("lib/libwine.so.1"), shared_content).unwrap();
663 std::os::unix::fs::symlink("libwine.so.1", dir.join("lib/libwine.so")).unwrap();
664 }
665
666 #[test]
667 fn adopt_кладёт_объекты_и_пишет_манифест() {
668 let base = scratch("adopt-basic");
669 let build_dir = base.join("wine-build");
670 fake_build(&build_dir, "общий gecko-бандл");
671
672 let cas = cas_root(&base);
673 let stats = adopt(&cas, &build_dir, "wine-build").unwrap();
674
675 assert_eq!(stats.files, 2);
676 assert_eq!(stats.symlinks, 1);
677 assert_eq!(stats.new_objects, 2);
678 assert_eq!(stats.reused_objects, 0);
679
680 let manifest = read_manifest(&cas, "wine-build").unwrap();
681 assert_eq!(manifest.files.len(), 2);
682 assert_eq!(manifest.symlinks.len(), 1);
683 assert_eq!(
684 manifest.symlinks.get(&PathBuf::from("lib/libwine.so")),
685 Some(&PathBuf::from("libwine.so.1"))
686 );
687
688 std::fs::remove_dir_all(&base).ok();
689 }
690
691 #[test]
692 fn adopt_не_трогает_исходный_каталог_сборки() {
693 // Обязательное свойство: adopt должен быть безопасен на живой
694 // установке — покажем, что каталог сборки после adopt не изменился
695 // ни по набору файлов, ни по содержимому.
696 let base = scratch("adopt-readonly-source");
697 let build_dir = base.join("wine-build");
698 fake_build(&build_dir, "содержимое");
699
700 let before: Vec<_> = walk_paths(&build_dir);
701 adopt(&cas_root(&base), &build_dir, "wine-build").unwrap();
702 let after: Vec<_> = walk_paths(&build_dir);
703
704 assert_eq!(before, after, "adopt не должен менять исходный каталог");
705 assert_eq!(
706 std::fs::read_to_string(build_dir.join("lib/libwine.so.1")).unwrap(),
707 "содержимое"
708 );
709
710 std::fs::remove_dir_all(&base).ok();
711 }
712
713 fn walk_paths(dir: &Path) -> Vec<PathBuf> {
714 let mut out = Vec::new();
715 let mut stack = vec![dir.to_path_buf()];
716 while let Some(d) = stack.pop() {
717 let Ok(entries) = std::fs::read_dir(&d) else { continue };
718 for e in entries.flatten() {
719 let p = e.path();
720 if e.file_type().map(|t| t.is_dir()).unwrap_or(false)
721 && !e.file_type().unwrap().is_symlink()
722 {
723 stack.push(p.clone());
724 }
725 out.push(p);
726 }
727 }
728 out.sort();
729 out
730 }
731
732 #[test]
733 fn одинаковое_содержимое_двух_сборок_кладётся_в_пул_один_раз() {
734 let base = scratch("adopt-dedup");
735 let build_a = base.join("build-a");
736 let build_b = base.join("build-b");
737 // Общий контент — как xul.dll, перевозимый одинаковым во всех трёх
738 // сборках Proton в CAS-DESIGN.md.
739 fake_build(&build_a, "общий Gecko-бандл, побайтово одинаковый");
740 fake_build(&build_b, "общий Gecko-бандл, побайтово одинаковый");
741
742 let cas = cas_root(&base);
743 let a = adopt(&cas, &build_a, "build-a").unwrap();
744 let b = adopt(&cas, &build_b, "build-b").unwrap();
745
746 assert_eq!(a.new_objects, 2, "первая сборка кладёт оба объекта заново");
747 // У build-b bin/wine отличается (там текст "своя версия" одинаковый
748 // для обеих на самом деле — но lib/libwine.so.1 идентичен). Проверим
749 // предметно: общий файл переиспользован.
750 assert!(b.reused_objects >= 1, "{b:?}");
751
752 let plan = plan_gc(&cas).unwrap();
753 // Уникальных объектов в пуле должно быть меньше, чем суммарно файлов
754 // в обеих сборках (2 + 2 = 4), потому что часть содержимого общая.
755 assert!(plan.total_objects < 4, "объекты не дедуплицировались: {plan:?}");
756
757 std::fs::remove_dir_all(&base).ok();
758 }
759
760 #[test]
761 fn повторный_adopt_не_плодит_новых_объектов() {
762 let base = scratch("adopt-idempotent");
763 let build_dir = base.join("wine-build");
764 fake_build(&build_dir, "содержимое");
765 let cas = cas_root(&base);
766
767 let first = adopt(&cas, &build_dir, "wine-build").unwrap();
768 let second = adopt(&cas, &build_dir, "wine-build").unwrap();
769
770 assert_eq!(first.new_objects, 2);
771 assert_eq!(second.new_objects, 0, "повторный adopt не должен писать новые объекты");
772 assert_eq!(second.reused_objects, 2);
773
774 std::fs::remove_dir_all(&base).ok();
775 }
776
777 #[test]
778 fn объект_в_пуле_защищён_от_записи() {
779 let base = scratch("object-readonly");
780 let build_dir = base.join("wine-build");
781 fake_build(&build_dir, "неизменяемое содержимое");
782 let cas = cas_root(&base);
783 adopt(&cas, &build_dir, "wine-build").unwrap();
784
785 let manifest = read_manifest(&cas, "wine-build").unwrap();
786 let any_hash = &manifest.files.values().next().unwrap().hash;
787 let object = object_path(&cas, any_hash);
788 let mode = std::fs::metadata(&object).unwrap().permissions().mode() & 0o777;
789 assert_eq!(mode, 0o444, "объект пула должен быть доступен только на чтение");
790
791 std::fs::remove_dir_all(&base).ok();
792 }
793
794 #[test]
795 fn манифест_переживает_запись_и_чтение_с_диска() {
796 let base = scratch("manifest-roundtrip");
797 let build_dir = base.join("wine-build");
798 fake_build(&build_dir, "roundtrip-содержимое");
799 let cas = cas_root(&base);
800
801 adopt(&cas, &build_dir, "wine-build").unwrap();
802 let manifest = read_manifest(&cas, "wine-build").unwrap();
803
804 assert_eq!(manifest.build, "wine-build");
805 assert_eq!(manifest.files.len(), 2);
806 assert_eq!(manifest.symlinks.len(), 1);
807 for entry in manifest.files.values() {
808 assert_eq!(entry.hash.len(), 64);
809 }
810
811 std::fs::remove_dir_all(&base).ok();
812 }
813
814 #[test]
815 fn materialize_восстанавливает_байт_в_байт_включая_права_и_ссылки() {
816 let base = scratch("materialize-roundtrip");
817 let build_dir = base.join("wine-build");
818 fake_build(&build_dir, "материализуемое содержимое");
819 let cas = cas_root(&base);
820 adopt(&cas, &build_dir, "wine-build").unwrap();
821 let manifest = read_manifest(&cas, "wine-build").unwrap();
822
823 let target = base.join("восстановленная-сборка");
824 let stats = materialize(&cas, &manifest, &target).unwrap();
825
826 assert_eq!(stats.files, 2);
827 assert_eq!(stats.symlinks, 1);
828
829 assert_eq!(
830 std::fs::read_to_string(target.join("bin/wine")).unwrap(),
831 "исполняемый файл, своя версия"
832 );
833 assert_eq!(
834 std::fs::read_to_string(target.join("lib/libwine.so.1")).unwrap(),
835 "материализуемое содержимое"
836 );
837 let mode = std::fs::metadata(target.join("bin/wine")).unwrap().permissions().mode() & 0o777;
838 assert_eq!(mode, 0o755, "исполняемый бит должен восстановиться");
839
840 let link_target = std::fs::read_link(target.join("lib/libwine.so")).unwrap();
841 assert_eq!(link_target, PathBuf::from("libwine.so.1"));
842 // Симлинк должен реально разрешаться в правильное содержимое, а не
843 // просто существовать как строка.
844 assert_eq!(
845 std::fs::read_to_string(target.join("lib/libwine.so")).unwrap(),
846 "материализуемое содержимое"
847 );
848
849 std::fs::remove_dir_all(&base).ok();
850 }
851
852 #[test]
853 fn materialize_отказывается_писать_в_занятый_путь() {
854 let base = scratch("materialize-occupied");
855 let build_dir = base.join("wine-build");
856 fake_build(&build_dir, "x");
857 let cas = cas_root(&base);
858 adopt(&cas, &build_dir, "wine-build").unwrap();
859 let manifest = read_manifest(&cas, "wine-build").unwrap();
860
861 let target = base.join("занято");
862 std::fs::create_dir_all(&target).unwrap();
863
864 let err = materialize(&cas, &manifest, &target).unwrap_err().to_string();
865 assert!(err.contains("уже существует"), "{err}");
866
867 std::fs::remove_dir_all(&base).ok();
868 }
869
870 #[test]
871 fn materialize_ловит_повреждённый_объект_пула() {
872 let base = scratch("materialize-corrupt");
873 let build_dir = base.join("wine-build");
874 fake_build(&build_dir, "исходное содержимое");
875 let cas = cas_root(&base);
876 adopt(&cas, &build_dir, "wine-build").unwrap();
877 let manifest = read_manifest(&cas, "wine-build").unwrap();
878
879 // Имитация битого бита на диске: правим объект в пуле напрямую,
880 // в обход put_object.
881 let hash = &manifest.files.get(&PathBuf::from("bin/wine")).unwrap().hash;
882 let object = object_path(&cas, hash);
883 let mut perms = std::fs::metadata(&object).unwrap().permissions();
884 perms.set_mode(0o644);
885 std::fs::set_permissions(&object, perms).unwrap();
886 std::fs::write(&object, "испорчено после записи в пул").unwrap();
887
888 let target = base.join("восстановленная");
889 let err = materialize(&cas, &manifest, &target).unwrap_err().to_string();
890 assert!(err.contains("не совпал по хэшу"), "{err}");
891 assert!(!target.exists(), "повреждённая материализация не должна оставлять каталог");
892
893 std::fs::remove_dir_all(&base).ok();
894 }
895
896 #[test]
897 fn dry_run_не_удаляет_ничего() {
898 let base = scratch("gc-dry-run");
899 let build_dir = base.join("wine-build");
900 fake_build(&build_dir, "живое содержимое");
901 let cas = cas_root(&base);
902 adopt(&cas, &build_dir, "wine-build").unwrap();
903
904 let before = plan_gc(&cas).unwrap();
905 assert!(before.candidates.is_empty(), "все объекты живые сборки живы: {before:?}");
906
907 // Даже без кандидатов — build_gc сам по себе не должен ничего
908 // менять на диске: количество объектов до и после совпадает.
909 let objects_before = count_objects(&cas);
910 let _ = plan_gc(&cas).unwrap();
911 let objects_after = count_objects(&cas);
912 assert_eq!(objects_before, objects_after);
913
914 std::fs::remove_dir_all(&base).ok();
915 }
916
917 fn count_objects(cas: &Path) -> usize {
918 plan_gc(cas).unwrap().total_objects
919 }
920
921 #[test]
922 fn gc_находит_только_по_настоящему_несвязанные_объекты() {
923 let base = scratch("gc-mark-sweep");
924 let build_dir = base.join("wine-build");
925 fake_build(&build_dir, "используемое содержимое");
926 let cas = cas_root(&base);
927 adopt(&cas, &build_dir, "wine-build").unwrap();
928
929 // Сирота: кладём объект в пул напрямую, без манифеста, который бы
930 // на него ссылался — как будто сборку, ссылавшуюся на него, потом
931 // удалили руками в обход chl.
932 let orphan_hash = hash_orphan(&cas, "ничей мусор");
933
934 let plan = plan_gc(&cas).unwrap();
935 let candidate_hashes: Vec<&str> = plan.candidates.iter().map(|c| c.hash.as_str()).collect();
936 assert_eq!(candidate_hashes, vec![orphan_hash.as_str()]);
937 assert_eq!(plan.live_hashes, 2, "оба файла живой сборки должны быть помечены живыми");
938
939 std::fs::remove_dir_all(&base).ok();
940 }
941
942 /// Кладёт файл в пул напрямую (в обход adopt) — имитирует объект-сироту,
943 /// на который больше не ссылается ни один манифест.
944 fn hash_orphan(cas: &Path, content: &str) -> String {
945 let tmp = cas.join("orphan-source.tmp");
946 std::fs::create_dir_all(cas).unwrap();
947 std::fs::write(&tmp, content).unwrap();
948 let (hash, _) = put_object(cas, &tmp).unwrap();
949 std::fs::remove_file(&tmp).ok();
950 hash
951 }
952
953 #[test]
954 fn delete_candidates_удаляет_только_кандидатов() {
955 let base = scratch("gc-delete");
956 let build_dir = base.join("wine-build");
957 fake_build(&build_dir, "используемое содержимое, не трогать");
958 let cas = cas_root(&base);
959 adopt(&cas, &build_dir, "wine-build").unwrap();
960 let orphan_hash = hash_orphan(&cas, "мусор на удаление");
961
962 let plan = plan_gc(&cas).unwrap();
963 assert_eq!(plan.candidates.len(), 1);
964 let freed = delete_candidates(&cas, &plan).unwrap();
965
966 assert_eq!(freed, "мусор на удаление".len() as u64);
967 assert!(!object_path(&cas, &orphan_hash).exists(), "сирота должна быть удалена");
968
969 // Живые объекты сборки остались на месте и по-прежнему
970 // материализуются.
971 let manifest = read_manifest(&cas, "wine-build").unwrap();
972 for entry in manifest.files.values() {
973 assert!(
974 object_path(&cas, &entry.hash).is_file(),
975 "живой объект {} не должен быть тронут GC",
976 entry.hash
977 );
978 }
979 let after = plan_gc(&cas).unwrap();
980 assert!(after.candidates.is_empty());
981
982 std::fs::remove_dir_all(&base).ok();
983 }
984
985 #[test]
986 fn пустой_пул_не_ошибка() {
987 let base = scratch("empty-pool");
988 let cas = cas_root(&base);
989 let plan = plan_gc(&cas).unwrap();
990 assert_eq!(plan.total_objects, 0);
991 assert!(plan.candidates.is_empty());
992 assert!(adopted_builds(&cas).is_empty());
993 assert!(read_manifest(&cas, "нет-такой").is_none());
994 std::fs::remove_dir_all(&base).ok();
995 }
996
997 #[test]
998 fn adopt_отвергает_несуществующий_каталог() {
999 let base = scratch("adopt-missing");
1000 let cas = cas_root(&base);
1001 let err = adopt(&cas, &base.join("нет-такого"), "x").unwrap_err().to_string();
1002 assert!(err.contains("не похож на каталог"), "{err}");
1003 std::fs::remove_dir_all(&base).ok();
1004 }
1005}
1006