1use std::path::{Path, PathBuf};
11
12use anyhow::{Context as _, Result};
13
14#[cfg(unix)]
15use {crate::proc::Quiet as _, anyhow::bail};
16
17pub fn enough_space(free: u64, min_free: u64) -> bool {
22 free >= min_free
23}
24
25pub fn gate(free: u64, min_free: u64) -> Option<String> {
32 gate_in(free, min_free, "en")
33}
34
35const SHORT_EN: &str = "not enough free space to start a run:";
38const SHORT_JA: &str = "run を開始するための空き容量が不足しています:";
39pub const RUNNING_PRESSURE: &str = "disk pressure while a run was writing: ";
41pub const UNMEASURED_EN: &str = "could not measure free space on ";
43pub const UNMEASURED_JA: &str = "空き容量を測定できませんでした: ";
45
46pub fn gate_in(free: u64, min_free: u64, language: &str) -> Option<String> {
49 if enough_space(free, min_free) {
50 None
51 } else if crate::lang::is_japanese(language) {
52 Some(format!(
53 "{SHORT_JA} 空き {free} バイト、`[disk] min_free_bytes` の要求は {min_free} バイト"
54 ))
55 } else {
56 Some(format!(
57 "{SHORT_EN} {free} bytes free, \
58 {min_free} required by `[disk] min_free_bytes`"
59 ))
60 }
61}
62
63pub fn unmeasured_in(
65 path: &std::path::Path,
66 err: &dyn std::fmt::Display,
67 language: &str,
68) -> String {
69 if crate::lang::is_japanese(language) {
70 format!(
71 "{UNMEASURED_JA}{} ({err}); ディスクゲートは測定できないまま run を開始させません",
72 path.display()
73 )
74 } else {
75 format!(
76 "{UNMEASURED_EN}{} ({err}); the disk gate refuses \
77 to let a run start blind",
78 path.display()
79 )
80 }
81}
82
83pub fn is_gate_reason(reason: &str) -> bool {
86 fn numbers(text: &str, middle: &str, suffix: &str) -> bool {
87 text.strip_suffix(suffix)
88 .and_then(|s| s.split_once(middle))
89 .is_some_and(|(a, b)| {
90 !a.is_empty()
91 && !b.is_empty()
92 && a.bytes().all(|c| c.is_ascii_digit())
93 && b.bytes().all(|c| c.is_ascii_digit())
94 && matches!((a.parse::<u64>(), b.parse::<u64>()), (Ok(free), Ok(required)) if free < required)
95 })
96 }
97 reason
98 .strip_prefix(&format!("{SHORT_EN} "))
99 .is_some_and(|s| numbers(s, " bytes free, ", " required by `[disk] min_free_bytes`"))
100 || reason
101 .strip_prefix(&format!("{SHORT_JA} 空き "))
102 .is_some_and(|s| numbers(s, " バイト、`[disk] min_free_bytes` の要求は ", " バイト"))
103 || [
104 (
105 UNMEASURED_EN,
106 "); the disk gate refuses to let a run start blind",
107 ),
108 (
109 UNMEASURED_JA,
110 "); ディスクゲートは測定できないまま run を開始させません",
111 ),
112 ]
113 .iter()
114 .any(|(prefix, suffix)| {
115 reason
116 .strip_prefix(prefix)
117 .and_then(|s| s.strip_suffix(suffix))
118 .is_some_and(|s| {
119 s.split_once(" (").is_some_and(|(path, error)| {
120 !path.is_empty() && !error.is_empty() && !s.contains('\n')
121 })
122 })
123 })
124}
125
126pub fn over_limit(size: u64, limit: u64) -> bool {
129 size > limit
130}
131
132pub fn pressure_limit(size: u64, cap: u64, min_free: u64, free: u64) -> u64 {
135 cap.min(size.saturating_sub(min_free.saturating_sub(free)))
136}
137
138pub fn extract_cargo_target_dir(command: &str) -> Option<PathBuf> {
152 const KEY: &str = "CARGO_TARGET_DIR=";
153 let rest = command.split_once(KEY)?.1.trim_start();
154 let value = if let Some(s) = rest.strip_prefix('\'') {
155 s.split('\'').next().unwrap_or("")
156 } else if let Some(s) = rest.strip_prefix('"') {
157 s.split('"').next().unwrap_or("")
158 } else {
159 let end = rest.find(char::is_whitespace).unwrap_or(rest.len());
160 &rest[..end]
161 };
162 if value.is_empty() {
163 None
164 } else {
165 Some(PathBuf::from(value))
166 }
167}
168
169pub fn free_bytes(path: &Path) -> Result<u64> {
174 free_bytes_by_os(path)
175}
176
177#[cfg(unix)]
179fn free_bytes_by_os(path: &Path) -> Result<u64> {
180 let out = std::process::Command::new("df")
181 .args(["-k", "-P"])
182 .arg(path)
183 .quiet()
184 .output()
185 .with_context(|| format!("run `df` for {}", path.display()))?;
186 if !out.status.success() {
187 bail!(
188 "`df` failed: {}",
189 String::from_utf8_lossy(&out.stderr).trim()
190 );
191 }
192 let text = String::from_utf8_lossy(&out.stdout);
193 text.lines()
194 .skip(1)
195 .find_map(parse_df_available)
196 .with_context(|| format!("parse `df` output for {}", path.display()))
197}
198
199#[cfg(windows)]
201fn free_bytes_by_os(path: &Path) -> Result<u64> {
202 #[link(name = "kernel32")]
203 unsafe extern "system" {
204 fn GetDiskFreeSpaceExW(
205 directory: *const u16,
206 available: *mut u64,
207 total: *mut u64,
208 free: *mut u64,
209 ) -> i32;
210 }
211 let abs = std::path::absolute(path)
214 .with_context(|| format!("absolute path for {}", path.display()))?;
215 let root = volume_root(&abs)
216 .with_context(|| format!("no volume root in {} to measure", abs.display()))?;
217 let wide: Vec<u16> = root.encode_utf16().chain(std::iter::once(0)).collect();
220 let mut available = 0_u64;
221 if unsafe {
224 GetDiskFreeSpaceExW(
225 wide.as_ptr(),
226 &mut available,
227 std::ptr::null_mut(),
228 std::ptr::null_mut(),
229 )
230 } == 0
231 {
232 let error = std::io::Error::last_os_error();
233 return Err(error).with_context(|| format!("query free bytes for {}", abs.display()));
234 }
235 Ok(available)
237}
238
239pub fn parse_df_available(line: &str) -> Option<u64> {
243 let mut fields = line.split_whitespace();
244 fields.next()?; fields.next()?; fields.next()?; let blocks: u64 = fields.next()?.parse().ok()?;
248 Some(blocks.saturating_mul(1024))
249}
250
251pub fn volume_root(path: &Path) -> Option<String> {
259 let text = path.to_str()?;
260 let bare = text
262 .strip_prefix(r"\\?\")
263 .or_else(|| text.strip_prefix("//?/"))
264 .unwrap_or(text);
265 let mut chars = bare.chars();
266 let letter = chars.next()?;
267 if !letter.is_ascii_alphabetic() || chars.next()? != ':' {
268 return None;
269 }
270 Some(format!(r"{letter}:\"))
271}
272
273pub fn dir_size(path: &Path) -> u64 {
279 let Ok(meta) = std::fs::symlink_metadata(path) else {
280 return 0;
281 };
282 if meta.is_file() {
283 return meta.len();
284 }
285 if !meta.is_dir() {
286 return 0;
287 }
288 let mut total = 0u64;
289 let mut stack = vec![path.to_path_buf()];
290 while let Some(dir) = stack.pop() {
291 let Ok(rd) = std::fs::read_dir(&dir) else {
292 continue;
293 };
294 for entry in rd.flatten() {
295 let Ok(meta) = entry.metadata() else {
298 continue;
299 };
300 if meta.is_dir() {
301 stack.push(entry.path());
302 } else if meta.is_file() {
303 total += meta.len();
304 }
305 }
306 }
307 total
308}
309
310#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
312pub struct Prune {
313 pub freed: u64,
315 pub files: usize,
317 pub remaining: u64,
319}
320
321#[derive(Debug, Clone, Default, PartialEq, Eq)]
327pub struct PrunePlan {
328 pub files: Vec<(PathBuf, u64)>,
330 pub freed: u64,
332 pub remaining: u64,
335}
336
337#[must_use]
352pub fn plan_prune(dir: &Path, limit: u64) -> PrunePlan {
353 let Some(tree) = Tree::of(dir) else {
354 return PrunePlan::default();
355 };
356 let mut total = tree.total;
357 if !over_limit(total, limit) {
358 return PrunePlan {
359 files: Vec::new(),
360 freed: 0,
361 remaining: total,
362 };
363 }
364 let mut freed = 0u64;
365 let mut files = Vec::new();
366 for (_, size, path) in &tree.files {
367 if !over_limit(total, limit) {
368 break;
369 }
370 total = total.saturating_sub(*size);
371 freed += *size;
372 files.push((path.clone(), *size));
373 }
374 PrunePlan {
375 files,
376 freed,
377 remaining: total,
378 }
379}
380
381pub fn prune_dir(dir: &Path, limit: u64) -> Result<Prune> {
395 let Some(tree) = Tree::of(dir) else {
396 return Ok(Prune {
397 freed: 0,
398 files: 0,
399 remaining: 0,
400 });
401 };
402 let mut total = tree.total;
403 if !over_limit(total, limit) {
404 return Ok(Prune {
405 freed: 0,
406 files: 0,
407 remaining: total,
408 });
409 }
410 let mut freed = 0u64;
411 let mut removed = 0usize;
412 for (_, size, path) in &tree.files {
422 if !over_limit(total, limit) {
423 break;
424 }
425 if std::fs::remove_file(path).is_ok() {
426 total = total.saturating_sub(*size);
427 freed += *size;
428 removed += 1;
429 }
430 }
431 strip_empty_dirs(&tree.dirs);
432 Ok(Prune {
433 freed,
434 files: removed,
435 remaining: total,
436 })
437}
438
439const PRESERVED_AT_ROOT: &str = "CACHEDIR.TAG";
448
449struct Tree {
453 total: u64,
454 files: Vec<(u128, u64, PathBuf)>,
455 dirs: Vec<(usize, PathBuf)>,
456}
457
458impl Tree {
459 fn of(dir: &Path) -> Option<Tree> {
462 if dir.symlink_metadata().ok()?.is_dir() {
463 Some(Tree::from_dir(dir))
464 } else {
465 None
466 }
467 }
468
469 fn from_dir(dir: &Path) -> Tree {
470 let mut total = 0u64;
471 let mut files = Vec::new();
472 let mut dirs = Vec::new();
473 let mut stack: Vec<(usize, PathBuf)> = vec![(0, dir.to_path_buf())];
476 while let Some((depth, d)) = stack.pop() {
477 let Ok(rd) = std::fs::read_dir(&d) else {
478 continue;
479 };
480 for entry in rd.flatten() {
481 let Ok(meta) = entry.metadata() else {
482 continue;
483 };
484 let path = entry.path();
485 if meta.is_dir() {
486 dirs.push((depth + 1, path.clone()));
487 stack.push((depth + 1, path));
488 } else if meta.is_file() {
489 let size = meta.len();
490 total += size;
491 if depth == 0 && entry.file_name() == PRESERVED_AT_ROOT {
492 continue;
493 }
494 let mtime = meta
495 .modified()
496 .ok()
497 .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
498 .map(|d| d.as_nanos())
499 .unwrap_or(0);
500 files.push((mtime, size, path));
501 }
502 }
503 }
504 files.sort_unstable_by(|a, b| a.0.cmp(&b.0).then(b.1.cmp(&a.1)).then(a.2.cmp(&b.2)));
512 Tree { total, files, dirs }
513 }
514}
515
516fn strip_empty_dirs(dirs: &[(usize, PathBuf)]) {
518 let mut by_depth: Vec<&PathBuf> = dirs.iter().map(|(_, d)| d).collect();
519 by_depth.sort_unstable_by_key(|d| std::cmp::Reverse(d.iter().count()));
520 for d in by_depth {
521 let _ = std::fs::remove_dir(d);
522 }
523}
524
525#[cfg(test)]
526mod tests {
527 #[test]
528 fn gate_reasons_follow_the_language_and_stay_recognisable() {
529 let en = gate_in(1, 10, "en").unwrap();
530 let ja = gate_in(1, 10, "日本語").unwrap();
531 assert_eq!(gate_in(1, 10, "fr").unwrap(), en);
532 assert_eq!(en, gate(1, 10).unwrap());
533 assert!(ja.starts_with("run を開始"), "{ja}");
534 assert!(is_gate_reason(&en) && is_gate_reason(&ja));
535 let p = std::path::Path::new("/x");
536 let m_ja = unmeasured_in(p, &"boom", "ja");
537 assert!(m_ja.contains("測定できませんでした") && is_gate_reason(&m_ja));
538 assert!(is_gate_reason(&unmeasured_in(p, &"boom", "en")));
539 assert!(!is_gate_reason("something else"));
540 }
541
542 #[test]
543 fn disk_wait_legacy_reasons_require_the_complete_gate_format() {
544 let observed = "run を開始するための空き容量が不足しています: 空き 1477050368 バイト、`[disk] min_free_bytes` の要求は 3221225472 バイト";
545 assert!(is_gate_reason(observed));
546 assert!(is_gate_reason(
547 &gate_in(1477050368, 3221225472, "en").unwrap()
548 ));
549 for ambiguous in [
550 format!("{observed}\nowner: hold"),
551 format!("{SHORT_EN} inspect manually"),
552 format!("{RUNNING_PRESSURE}unknown"),
553 format!("{UNMEASURED_EN}/tmp (error)"),
554 ] {
555 assert!(!is_gate_reason(&ambiguous), "{ambiguous}");
556 }
557 }
558
559 use super::*;
560 use std::fs;
561
562 #[test]
563 fn the_free_space_predicate_is_the_boundary() {
564 assert!(enough_space(100, 100));
565 assert!(enough_space(101, 100));
566 assert!(!enough_space(99, 100));
567 assert!(enough_space(0, 0));
569 }
570
571 #[test]
572 fn the_gate_text_conveys_both_numbers_and_opens_with_room() {
573 assert_eq!(
574 gate(9, 10).expect("closed"),
575 "not enough free space to start a run: 9 bytes free, 10 required by `[disk] min_free_bytes`"
576 );
577 assert_eq!(gate(10, 10), None, "exactly at the floor is open");
578 assert_eq!(gate(10_000, 0), None, "a zero floor is an opt-out");
579 }
580
581 #[test]
582 fn over_limit_uses_strict_greater_than() {
583 assert!(over_limit(11, 10));
584 assert!(!over_limit(10, 10));
585 assert!(!over_limit(9, 10));
586 }
587
588 #[test]
589 fn df_row_parses_1024_blocks_into_bytes() {
590 let row = "/dev/sda1 976762584 808522388 168240196 83% /home";
591 assert_eq!(parse_df_available(row), Some(168_240_196 * 1024));
592 assert_eq!(parse_df_available("garbage"), None);
593 assert_eq!(parse_df_available("a b c x"), None);
594 }
595
596 #[test]
598 fn the_volume_root_is_a_drive_not_the_path_it_came_from() {
599 assert_eq!(
602 volume_root(Path::new(
603 r"\\?\C:\Users\yukimemi\src\github.com\yukimemi\magi"
604 )),
605 Some(r"C:\".to_owned())
606 );
607 assert_eq!(
608 volume_root(Path::new(r"C:\Users\yukimemi")),
609 Some(r"C:\".to_owned())
610 );
611 assert_eq!(volume_root(Path::new(r"D:\")), Some(r"D:\".to_owned()));
612 assert_eq!(
614 volume_root(Path::new("C:/Users/yukimemi/src")),
615 Some(r"C:\".to_owned())
616 );
617 assert_eq!(volume_root(Path::new(r"\\server\share\dir")), None);
620 assert_eq!(volume_root(Path::new(r"\\?\UNC\server\share")), None);
621 assert_eq!(volume_root(Path::new("/home/yukimemi")), None);
622 }
623
624 #[test]
625 fn the_cache_dir_is_read_back_out_of_a_rendered_command() {
626 let cmd = r"CARGO_TARGET_DIR=C:\Users\me\Temp\magi-target cargo make check";
627 assert_eq!(
628 extract_cargo_target_dir(cmd),
629 Some(PathBuf::from(r"C:\Users\me\Temp\magi-target"))
630 );
631 assert_eq!(
633 extract_cargo_target_dir(r"CARGO_TARGET_DIR='/tmp/a b' cargo test"),
634 Some(PathBuf::from("/tmp/a b"))
635 );
636 assert_eq!(
637 extract_cargo_target_dir(r#"CARGO_TARGET_DIR="/tmp/qq" cargo test"#),
638 Some(PathBuf::from("/tmp/qq"))
639 );
640 assert_eq!(extract_cargo_target_dir("cargo make check"), None);
641 assert_eq!(extract_cargo_target_dir("CARGO_TARGET_DIR="), None);
642 let two = "CARGO_TARGET_DIR=/first and CARGO_TARGET_DIR=/second cargo x";
645 assert_eq!(extract_cargo_target_dir(two), Some(PathBuf::from("/first")));
646 }
647
648 #[test]
649 fn dir_size_is_zero_for_missing_and_counts_files_without_following_links() {
650 let t = tempfile::TempDir::new().expect("temp");
651 assert_eq!(dir_size(&t.path().join("nope")), 0);
652 fs::write(t.path().join("a"), b"12345").expect("write");
653 fs::create_dir(t.path().join("sub")).expect("dir");
654 fs::write(t.path().join("sub").join("b"), b"678").expect("write");
655 assert_eq!(dir_size(t.path()), 8);
656 #[cfg(unix)]
657 {
658 std::os::unix::fs::symlink(t.path().join("sub"), t.path().join("link"))
659 .expect("symlink");
660 assert_eq!(dir_size(t.path()), 8, "a link is counted as a link");
661 }
662 }
663
664 #[test]
665 fn prune_deletes_oldest_first_until_the_cap_is_met() {
666 let t = tempfile::TempDir::new().expect("temp");
667 let old = t.path().join("old");
668 fs::write(&old, b"yyyy").expect("write");
669 std::thread::sleep(std::time::Duration::from_millis(1_200));
672 fs::write(t.path().join("new"), b"xxxxx").expect("write");
673
674 let keep = prune_dir(t.path(), 9).expect("prune");
676 assert_eq!(
677 keep,
678 Prune {
679 freed: 0,
680 files: 0,
681 remaining: 9
682 }
683 );
684
685 let pruned = prune_dir(t.path(), 6).expect("prune");
687 assert!(pruned.freed > 0);
688 assert_eq!(pruned.files, 1);
689 assert_eq!(pruned.remaining, 5);
690 assert!(!old.exists(), "the older file is the one shed");
691 assert!(t.path().join("new").exists());
692 }
693
694 #[test]
695 fn plan_prune_selects_what_prune_dir_would_delete_without_deleting_it() {
696 let t = tempfile::TempDir::new().expect("temp");
697 let old = t.path().join("old");
698 fs::write(&old, b"yyyy").expect("write");
699 std::thread::sleep(std::time::Duration::from_millis(1_200));
700 fs::write(t.path().join("new"), b"xxxxx").expect("write");
701
702 let plan = plan_prune(t.path(), 6);
703 assert_eq!(plan.files, vec![(old.clone(), 4)]);
704 assert_eq!(plan.freed, 4);
705 assert_eq!(plan.remaining, 5);
706 assert!(old.exists(), "a plan never deletes anything");
707 assert!(t.path().join("new").exists());
708
709 let pruned = prune_dir(t.path(), 6).expect("prune");
711 assert_eq!(pruned.freed, plan.freed);
712 assert_eq!(pruned.remaining, plan.remaining);
713 assert!(!old.exists());
714 }
715
716 #[test]
717 fn a_root_cachedir_tag_survives_even_as_the_oldest_file() {
718 let t = tempfile::TempDir::new().expect("temp");
721 let tag = t.path().join("CACHEDIR.TAG");
722 fs::write(&tag, b"Signature: x").expect("write");
723 let f = fs::File::options().write(true).open(&tag).expect("open");
724 f.set_modified(std::time::UNIX_EPOCH + std::time::Duration::from_secs(1))
725 .expect("mtime");
726 drop(f);
727 fs::write(t.path().join("a"), b"aaaa").expect("write");
728 fs::create_dir(t.path().join("sub")).expect("mkdir");
729 let nested = t.path().join("sub").join("CACHEDIR.TAG");
731 fs::write(&nested, b"nn").expect("write");
732
733 let limit = 12; let plan = plan_prune(t.path(), limit);
735 assert!(plan.files.iter().all(|(p, _)| p != &tag));
736 assert!(plan.remaining <= limit);
737
738 let pruned = prune_dir(t.path(), limit).expect("prune");
739 assert!(tag.exists(), "the root tag is never pruned");
740 assert!(pruned.remaining <= limit);
741 assert_eq!(pruned.freed, plan.freed);
742 assert_eq!(pruned.remaining, plan.remaining);
743 assert!(!nested.exists());
744 }
745
746 #[test]
747 fn plan_prune_is_empty_under_the_cap_and_for_a_missing_dir() {
748 let t = tempfile::TempDir::new().expect("temp");
749 fs::write(t.path().join("a"), b"12345").expect("write");
750 let plan = plan_prune(t.path(), 100);
751 assert_eq!(
752 plan,
753 PrunePlan {
754 files: Vec::new(),
755 freed: 0,
756 remaining: 5,
757 }
758 );
759
760 assert_eq!(
761 plan_prune(&t.path().join("absent"), 0),
762 PrunePlan::default()
763 );
764 }
765
766 #[cfg(windows)]
773 #[test]
774 fn prune_keeps_reaching_past_an_undeletable_file_to_still_reach_the_cap() {
775 use std::os::windows::fs::OpenOptionsExt as _;
776
777 let t = tempfile::TempDir::new().expect("temp");
778 let old = t.path().join("old");
779 fs::write(&old, b"yyyy").expect("write");
780 std::thread::sleep(std::time::Duration::from_millis(1_200));
781 let mid = t.path().join("mid");
782 fs::write(&mid, b"zzzz").expect("write");
783 std::thread::sleep(std::time::Duration::from_millis(1_200));
784 let new = t.path().join("new");
785 fs::write(&new, b"xxxxx").expect("write");
786
787 let lock = std::fs::OpenOptions::new()
791 .read(true)
792 .share_mode(0)
793 .open(&old)
794 .expect("lock the old file exclusively");
795
796 let pruned = prune_dir(t.path(), 8).expect("prune");
797 drop(lock);
798
799 assert!(old.exists(), "the locked file could not be deleted");
800 assert!(!mid.exists(), "the next-oldest file was tried and removed");
801 assert!(
802 !new.exists(),
803 "pruning kept reaching for newer files until the cap was actually met, \
804 not just until a fixed selection ran out"
805 );
806 assert!(
807 pruned.remaining <= 8,
808 "the achieved total must reach the cap: {pruned:?}"
809 );
810 }
811
812 #[test]
813 fn prune_leaves_a_missing_dir_alone() {
814 let t = tempfile::TempDir::new().expect("temp");
815 let out = prune_dir(&t.path().join("absent"), 1).expect("prune");
816 assert_eq!(out, Prune::default());
817 }
818
819 #[test]
820 fn prune_sweeps_directories_the_files_leave_empty() {
821 let t = tempfile::TempDir::new().expect("temp");
822 let deep = t.path().join("a").join("b").join("c");
823 fs::create_dir_all(&deep).expect("dirs");
824 fs::write(deep.join("f"), b"1234").expect("write");
825 let out = prune_dir(t.path(), 0).expect("prune");
826 assert_eq!(out.files, 1);
827 assert_eq!(out.remaining, 0);
828 assert!(!t.path().join("a").exists(), "empty chain swept");
829 }
830}
831
832#[cfg(test)]
833mod pressure_tests {
834 #[test]
835 fn pressure_reclaims_below_cap_without_underflow() {
836 assert_eq!(super::pressure_limit(100, 200, 80, 30), 50);
837 assert_eq!(super::pressure_limit(100, 200, 80, 100), 100);
838 assert_eq!(super::pressure_limit(100, 200, 800, 0), 0);
839 assert_eq!(super::pressure_limit(100, 50, 0, 0), 50);
840 }
841}