1use std::path::{Path, PathBuf};
11
12use anyhow::{Context as _, Result, bail};
13
14use crate::proc::Quiet as _;
15
16pub fn enough_space(free: u64, min_free: u64) -> bool {
21 free >= min_free
22}
23
24pub fn gate(free: u64, min_free: u64) -> Option<String> {
31 gate_in(free, min_free, "en")
32}
33
34const SHORT_EN: &str = "not enough free space to start a run:";
37const SHORT_JA: &str = "run を開始するための空き容量が不足しています:";
38pub const RUNNING_PRESSURE: &str = "disk pressure while a run was writing: ";
40pub const UNMEASURED_EN: &str = "could not measure free space on ";
42pub const UNMEASURED_JA: &str = "空き容量を測定できませんでした: ";
44
45pub fn gate_in(free: u64, min_free: u64, language: &str) -> Option<String> {
48 if enough_space(free, min_free) {
49 None
50 } else if crate::lang::is_japanese(language) {
51 Some(format!(
52 "{SHORT_JA} 空き {free} バイト、`[disk] min_free_bytes` の要求は {min_free} バイト"
53 ))
54 } else {
55 Some(format!(
56 "{SHORT_EN} {free} bytes free, \
57 {min_free} required by `[disk] min_free_bytes`"
58 ))
59 }
60}
61
62pub fn unmeasured_in(
64 path: &std::path::Path,
65 err: &dyn std::fmt::Display,
66 language: &str,
67) -> String {
68 if crate::lang::is_japanese(language) {
69 format!(
70 "{UNMEASURED_JA}{} ({err}); ディスクゲートは測定できないまま run を開始させません",
71 path.display()
72 )
73 } else {
74 format!(
75 "{UNMEASURED_EN}{} ({err}); the disk gate refuses \
76 to let a run start blind",
77 path.display()
78 )
79 }
80}
81
82pub fn is_gate_reason(reason: &str) -> bool {
85 fn numbers(text: &str, middle: &str, suffix: &str) -> bool {
86 text.strip_suffix(suffix)
87 .and_then(|s| s.split_once(middle))
88 .is_some_and(|(a, b)| {
89 !a.is_empty()
90 && !b.is_empty()
91 && a.bytes().all(|c| c.is_ascii_digit())
92 && b.bytes().all(|c| c.is_ascii_digit())
93 && matches!((a.parse::<u64>(), b.parse::<u64>()), (Ok(free), Ok(required)) if free < required)
94 })
95 }
96 reason
97 .strip_prefix(&format!("{SHORT_EN} "))
98 .is_some_and(|s| numbers(s, " bytes free, ", " required by `[disk] min_free_bytes`"))
99 || reason
100 .strip_prefix(&format!("{SHORT_JA} 空き "))
101 .is_some_and(|s| numbers(s, " バイト、`[disk] min_free_bytes` の要求は ", " バイト"))
102 || [
103 (
104 UNMEASURED_EN,
105 "); the disk gate refuses to let a run start blind",
106 ),
107 (
108 UNMEASURED_JA,
109 "); ディスクゲートは測定できないまま run を開始させません",
110 ),
111 ]
112 .iter()
113 .any(|(prefix, suffix)| {
114 reason
115 .strip_prefix(prefix)
116 .and_then(|s| s.strip_suffix(suffix))
117 .is_some_and(|s| {
118 s.split_once(" (").is_some_and(|(path, error)| {
119 !path.is_empty() && !error.is_empty() && !s.contains('\n')
120 })
121 })
122 })
123}
124
125pub fn over_limit(size: u64, limit: u64) -> bool {
128 size > limit
129}
130
131pub fn pressure_limit(size: u64, cap: u64, min_free: u64, free: u64) -> u64 {
134 cap.min(size.saturating_sub(min_free.saturating_sub(free)))
135}
136
137pub fn extract_cargo_target_dir(command: &str) -> Option<PathBuf> {
151 const KEY: &str = "CARGO_TARGET_DIR=";
152 let rest = command.split_once(KEY)?.1.trim_start();
153 let value = if let Some(s) = rest.strip_prefix('\'') {
154 s.split('\'').next().unwrap_or("")
155 } else if let Some(s) = rest.strip_prefix('"') {
156 s.split('"').next().unwrap_or("")
157 } else {
158 let end = rest.find(char::is_whitespace).unwrap_or(rest.len());
159 &rest[..end]
160 };
161 if value.is_empty() {
162 None
163 } else {
164 Some(PathBuf::from(value))
165 }
166}
167
168pub 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 let abs = std::path::absolute(path)
213 .with_context(|| format!("absolute path for {}", path.display()))?;
214 let root = volume_root(&abs)
215 .with_context(|| format!("no volume root in {} to measure", abs.display()))?;
216 let quoted = root.replace('\'', "''");
217 let script = format!("[System.IO.DriveInfo]::new('{quoted}').AvailableFreeSpace");
218 let out = std::process::Command::new("powershell")
219 .args(["-NoProfile", "-NonInteractive", "-Command", &script])
220 .quiet()
225 .output()
226 .with_context(|| format!("run PowerShell for {}", abs.display()))?;
227 if !out.status.success() {
228 bail!(
229 "PowerShell failed: {}",
230 String::from_utf8_lossy(&out.stderr).trim()
231 );
232 }
233 parse_u64(&String::from_utf8_lossy(&out.stdout))
234 .with_context(|| format!("parse PowerShell bytes for {}", abs.display()))
235}
236
237pub fn parse_df_available(line: &str) -> Option<u64> {
241 let mut fields = line.split_whitespace();
242 fields.next()?; fields.next()?; fields.next()?; let blocks: u64 = fields.next()?.parse().ok()?;
246 Some(blocks.saturating_mul(1024))
247}
248
249pub fn volume_root(path: &Path) -> Option<String> {
258 let text = path.to_str()?;
259 let bare = text
261 .strip_prefix(r"\\?\")
262 .or_else(|| text.strip_prefix("//?/"))
263 .unwrap_or(text);
264 let mut chars = bare.chars();
265 let letter = chars.next()?;
266 if !letter.is_ascii_alphabetic() || chars.next()? != ':' {
267 return None;
268 }
269 Some(format!(r"{letter}:\"))
270}
271
272pub fn parse_u64(text: &str) -> Option<u64> {
274 text.trim().parse().ok()
275}
276
277pub fn dir_size(path: &Path) -> u64 {
283 let Ok(meta) = std::fs::symlink_metadata(path) else {
284 return 0;
285 };
286 if meta.is_file() {
287 return meta.len();
288 }
289 if !meta.is_dir() {
290 return 0;
291 }
292 let mut total = 0u64;
293 let mut stack = vec![path.to_path_buf()];
294 while let Some(dir) = stack.pop() {
295 let Ok(rd) = std::fs::read_dir(&dir) else {
296 continue;
297 };
298 for entry in rd.flatten() {
299 let Ok(meta) = entry.metadata() else {
302 continue;
303 };
304 if meta.is_dir() {
305 stack.push(entry.path());
306 } else if meta.is_file() {
307 total += meta.len();
308 }
309 }
310 }
311 total
312}
313
314#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
316pub struct Prune {
317 pub freed: u64,
319 pub files: usize,
321 pub remaining: u64,
323}
324
325#[derive(Debug, Clone, Default, PartialEq, Eq)]
331pub struct PrunePlan {
332 pub files: Vec<(PathBuf, u64)>,
334 pub freed: u64,
336 pub remaining: u64,
339}
340
341#[must_use]
356pub fn plan_prune(dir: &Path, limit: u64) -> PrunePlan {
357 let Some(tree) = Tree::of(dir) else {
358 return PrunePlan::default();
359 };
360 let mut total = tree.total;
361 if !over_limit(total, limit) {
362 return PrunePlan {
363 files: Vec::new(),
364 freed: 0,
365 remaining: total,
366 };
367 }
368 let mut freed = 0u64;
369 let mut files = Vec::new();
370 for (_, size, path) in &tree.files {
371 if !over_limit(total, limit) {
372 break;
373 }
374 total = total.saturating_sub(*size);
375 freed += *size;
376 files.push((path.clone(), *size));
377 }
378 PrunePlan {
379 files,
380 freed,
381 remaining: total,
382 }
383}
384
385pub fn prune_dir(dir: &Path, limit: u64) -> Result<Prune> {
399 let Some(tree) = Tree::of(dir) else {
400 return Ok(Prune {
401 freed: 0,
402 files: 0,
403 remaining: 0,
404 });
405 };
406 let mut total = tree.total;
407 if !over_limit(total, limit) {
408 return Ok(Prune {
409 freed: 0,
410 files: 0,
411 remaining: total,
412 });
413 }
414 let mut freed = 0u64;
415 let mut removed = 0usize;
416 for (_, size, path) in &tree.files {
426 if !over_limit(total, limit) {
427 break;
428 }
429 if std::fs::remove_file(path).is_ok() {
430 total = total.saturating_sub(*size);
431 freed += *size;
432 removed += 1;
433 }
434 }
435 strip_empty_dirs(&tree.dirs);
436 Ok(Prune {
437 freed,
438 files: removed,
439 remaining: total,
440 })
441}
442
443const PRESERVED_AT_ROOT: &str = "CACHEDIR.TAG";
452
453struct Tree {
457 total: u64,
458 files: Vec<(u128, u64, PathBuf)>,
459 dirs: Vec<(usize, PathBuf)>,
460}
461
462impl Tree {
463 fn of(dir: &Path) -> Option<Tree> {
466 if dir.symlink_metadata().ok()?.is_dir() {
467 Some(Tree::from_dir(dir))
468 } else {
469 None
470 }
471 }
472
473 fn from_dir(dir: &Path) -> Tree {
474 let mut total = 0u64;
475 let mut files = Vec::new();
476 let mut dirs = Vec::new();
477 let mut stack: Vec<(usize, PathBuf)> = vec![(0, dir.to_path_buf())];
480 while let Some((depth, d)) = stack.pop() {
481 let Ok(rd) = std::fs::read_dir(&d) else {
482 continue;
483 };
484 for entry in rd.flatten() {
485 let Ok(meta) = entry.metadata() else {
486 continue;
487 };
488 let path = entry.path();
489 if meta.is_dir() {
490 dirs.push((depth + 1, path.clone()));
491 stack.push((depth + 1, path));
492 } else if meta.is_file() {
493 let size = meta.len();
494 total += size;
495 if depth == 0 && entry.file_name() == PRESERVED_AT_ROOT {
496 continue;
497 }
498 let mtime = meta
499 .modified()
500 .ok()
501 .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
502 .map(|d| d.as_nanos())
503 .unwrap_or(0);
504 files.push((mtime, size, path));
505 }
506 }
507 }
508 files.sort_unstable_by(|a, b| a.0.cmp(&b.0).then(b.1.cmp(&a.1)).then(a.2.cmp(&b.2)));
516 Tree { total, files, dirs }
517 }
518}
519
520fn strip_empty_dirs(dirs: &[(usize, PathBuf)]) {
522 let mut by_depth: Vec<&PathBuf> = dirs.iter().map(|(_, d)| d).collect();
523 by_depth.sort_unstable_by_key(|d| std::cmp::Reverse(d.iter().count()));
524 for d in by_depth {
525 let _ = std::fs::remove_dir(d);
526 }
527}
528
529#[cfg(test)]
530mod tests {
531 #[test]
532 fn gate_reasons_follow_the_language_and_stay_recognisable() {
533 let en = gate_in(1, 10, "en").unwrap();
534 let ja = gate_in(1, 10, "日本語").unwrap();
535 assert_eq!(gate_in(1, 10, "fr").unwrap(), en);
536 assert_eq!(en, gate(1, 10).unwrap());
537 assert!(ja.starts_with("run を開始"), "{ja}");
538 assert!(is_gate_reason(&en) && is_gate_reason(&ja));
539 let p = std::path::Path::new("/x");
540 let m_ja = unmeasured_in(p, &"boom", "ja");
541 assert!(m_ja.contains("測定できませんでした") && is_gate_reason(&m_ja));
542 assert!(is_gate_reason(&unmeasured_in(p, &"boom", "en")));
543 assert!(!is_gate_reason("something else"));
544 }
545
546 #[test]
547 fn disk_wait_legacy_reasons_require_the_complete_gate_format() {
548 let observed = "run を開始するための空き容量が不足しています: 空き 1477050368 バイト、`[disk] min_free_bytes` の要求は 3221225472 バイト";
549 assert!(is_gate_reason(observed));
550 assert!(is_gate_reason(
551 &gate_in(1477050368, 3221225472, "en").unwrap()
552 ));
553 for ambiguous in [
554 format!("{observed}\nowner: hold"),
555 format!("{SHORT_EN} inspect manually"),
556 format!("{RUNNING_PRESSURE}unknown"),
557 format!("{UNMEASURED_EN}/tmp (error)"),
558 ] {
559 assert!(!is_gate_reason(&ambiguous), "{ambiguous}");
560 }
561 }
562
563 use super::*;
564 use std::fs;
565
566 #[test]
567 fn the_free_space_predicate_is_the_boundary() {
568 assert!(enough_space(100, 100));
569 assert!(enough_space(101, 100));
570 assert!(!enough_space(99, 100));
571 assert!(enough_space(0, 0));
573 }
574
575 #[test]
576 fn the_gate_text_conveys_both_numbers_and_opens_with_room() {
577 assert_eq!(
578 gate(9, 10).expect("closed"),
579 "not enough free space to start a run: 9 bytes free, 10 required by `[disk] min_free_bytes`"
580 );
581 assert_eq!(gate(10, 10), None, "exactly at the floor is open");
582 assert_eq!(gate(10_000, 0), None, "a zero floor is an opt-out");
583 }
584
585 #[test]
586 fn over_limit_uses_strict_greater_than() {
587 assert!(over_limit(11, 10));
588 assert!(!over_limit(10, 10));
589 assert!(!over_limit(9, 10));
590 }
591
592 #[test]
593 fn df_row_parses_1024_blocks_into_bytes() {
594 let row = "/dev/sda1 976762584 808522388 168240196 83% /home";
595 assert_eq!(parse_df_available(row), Some(168_240_196 * 1024));
596 assert_eq!(parse_df_available("garbage"), None);
597 assert_eq!(parse_df_available("a b c x"), None);
598 }
599
600 #[test]
601 fn a_powershell_number_is_one_unsigned_integer() {
602 assert_eq!(parse_u64(" 82072211456\r\n"), Some(82_072_211_456));
603 assert_eq!(parse_u64("nah"), None);
604 }
605
606 #[test]
608 fn the_volume_root_is_a_drive_not_the_path_it_came_from() {
609 assert_eq!(
612 volume_root(Path::new(
613 r"\\?\C:\Users\yukimemi\src\github.com\yukimemi\magi"
614 )),
615 Some(r"C:\".to_owned())
616 );
617 assert_eq!(
618 volume_root(Path::new(r"C:\Users\yukimemi")),
619 Some(r"C:\".to_owned())
620 );
621 assert_eq!(volume_root(Path::new(r"D:\")), Some(r"D:\".to_owned()));
622 assert_eq!(
624 volume_root(Path::new("C:/Users/yukimemi/src")),
625 Some(r"C:\".to_owned())
626 );
627 assert_eq!(volume_root(Path::new(r"\\server\share\dir")), None);
630 assert_eq!(volume_root(Path::new(r"\\?\UNC\server\share")), None);
631 assert_eq!(volume_root(Path::new("/home/yukimemi")), None);
632 }
633
634 #[test]
635 fn the_cache_dir_is_read_back_out_of_a_rendered_command() {
636 let cmd = r"CARGO_TARGET_DIR=C:\Users\me\Temp\magi-target cargo make check";
637 assert_eq!(
638 extract_cargo_target_dir(cmd),
639 Some(PathBuf::from(r"C:\Users\me\Temp\magi-target"))
640 );
641 assert_eq!(
643 extract_cargo_target_dir(r"CARGO_TARGET_DIR='/tmp/a b' cargo test"),
644 Some(PathBuf::from("/tmp/a b"))
645 );
646 assert_eq!(
647 extract_cargo_target_dir(r#"CARGO_TARGET_DIR="/tmp/qq" cargo test"#),
648 Some(PathBuf::from("/tmp/qq"))
649 );
650 assert_eq!(extract_cargo_target_dir("cargo make check"), None);
651 assert_eq!(extract_cargo_target_dir("CARGO_TARGET_DIR="), None);
652 let two = "CARGO_TARGET_DIR=/first and CARGO_TARGET_DIR=/second cargo x";
655 assert_eq!(extract_cargo_target_dir(two), Some(PathBuf::from("/first")));
656 }
657
658 #[test]
659 fn dir_size_is_zero_for_missing_and_counts_files_without_following_links() {
660 let t = tempfile::TempDir::new().expect("temp");
661 assert_eq!(dir_size(&t.path().join("nope")), 0);
662 fs::write(t.path().join("a"), b"12345").expect("write");
663 fs::create_dir(t.path().join("sub")).expect("dir");
664 fs::write(t.path().join("sub").join("b"), b"678").expect("write");
665 assert_eq!(dir_size(t.path()), 8);
666 #[cfg(unix)]
667 {
668 std::os::unix::fs::symlink(t.path().join("sub"), t.path().join("link"))
669 .expect("symlink");
670 assert_eq!(dir_size(t.path()), 8, "a link is counted as a link");
671 }
672 }
673
674 #[test]
675 fn prune_deletes_oldest_first_until_the_cap_is_met() {
676 let t = tempfile::TempDir::new().expect("temp");
677 let old = t.path().join("old");
678 fs::write(&old, b"yyyy").expect("write");
679 std::thread::sleep(std::time::Duration::from_millis(1_200));
682 fs::write(t.path().join("new"), b"xxxxx").expect("write");
683
684 let keep = prune_dir(t.path(), 9).expect("prune");
686 assert_eq!(
687 keep,
688 Prune {
689 freed: 0,
690 files: 0,
691 remaining: 9
692 }
693 );
694
695 let pruned = prune_dir(t.path(), 6).expect("prune");
697 assert!(pruned.freed > 0);
698 assert_eq!(pruned.files, 1);
699 assert_eq!(pruned.remaining, 5);
700 assert!(!old.exists(), "the older file is the one shed");
701 assert!(t.path().join("new").exists());
702 }
703
704 #[test]
705 fn plan_prune_selects_what_prune_dir_would_delete_without_deleting_it() {
706 let t = tempfile::TempDir::new().expect("temp");
707 let old = t.path().join("old");
708 fs::write(&old, b"yyyy").expect("write");
709 std::thread::sleep(std::time::Duration::from_millis(1_200));
710 fs::write(t.path().join("new"), b"xxxxx").expect("write");
711
712 let plan = plan_prune(t.path(), 6);
713 assert_eq!(plan.files, vec![(old.clone(), 4)]);
714 assert_eq!(plan.freed, 4);
715 assert_eq!(plan.remaining, 5);
716 assert!(old.exists(), "a plan never deletes anything");
717 assert!(t.path().join("new").exists());
718
719 let pruned = prune_dir(t.path(), 6).expect("prune");
721 assert_eq!(pruned.freed, plan.freed);
722 assert_eq!(pruned.remaining, plan.remaining);
723 assert!(!old.exists());
724 }
725
726 #[test]
727 fn a_root_cachedir_tag_survives_even_as_the_oldest_file() {
728 let t = tempfile::TempDir::new().expect("temp");
731 let tag = t.path().join("CACHEDIR.TAG");
732 fs::write(&tag, b"Signature: x").expect("write");
733 let f = fs::File::options().write(true).open(&tag).expect("open");
734 f.set_modified(std::time::UNIX_EPOCH + std::time::Duration::from_secs(1))
735 .expect("mtime");
736 drop(f);
737 fs::write(t.path().join("a"), b"aaaa").expect("write");
738 fs::create_dir(t.path().join("sub")).expect("mkdir");
739 let nested = t.path().join("sub").join("CACHEDIR.TAG");
741 fs::write(&nested, b"nn").expect("write");
742
743 let limit = 12; let plan = plan_prune(t.path(), limit);
745 assert!(plan.files.iter().all(|(p, _)| p != &tag));
746 assert!(plan.remaining <= limit);
747
748 let pruned = prune_dir(t.path(), limit).expect("prune");
749 assert!(tag.exists(), "the root tag is never pruned");
750 assert!(pruned.remaining <= limit);
751 assert_eq!(pruned.freed, plan.freed);
752 assert_eq!(pruned.remaining, plan.remaining);
753 assert!(!nested.exists());
754 }
755
756 #[test]
757 fn plan_prune_is_empty_under_the_cap_and_for_a_missing_dir() {
758 let t = tempfile::TempDir::new().expect("temp");
759 fs::write(t.path().join("a"), b"12345").expect("write");
760 let plan = plan_prune(t.path(), 100);
761 assert_eq!(
762 plan,
763 PrunePlan {
764 files: Vec::new(),
765 freed: 0,
766 remaining: 5,
767 }
768 );
769
770 assert_eq!(
771 plan_prune(&t.path().join("absent"), 0),
772 PrunePlan::default()
773 );
774 }
775
776 #[cfg(windows)]
783 #[test]
784 fn prune_keeps_reaching_past_an_undeletable_file_to_still_reach_the_cap() {
785 use std::os::windows::fs::OpenOptionsExt as _;
786
787 let t = tempfile::TempDir::new().expect("temp");
788 let old = t.path().join("old");
789 fs::write(&old, b"yyyy").expect("write");
790 std::thread::sleep(std::time::Duration::from_millis(1_200));
791 let mid = t.path().join("mid");
792 fs::write(&mid, b"zzzz").expect("write");
793 std::thread::sleep(std::time::Duration::from_millis(1_200));
794 let new = t.path().join("new");
795 fs::write(&new, b"xxxxx").expect("write");
796
797 let lock = std::fs::OpenOptions::new()
801 .read(true)
802 .share_mode(0)
803 .open(&old)
804 .expect("lock the old file exclusively");
805
806 let pruned = prune_dir(t.path(), 8).expect("prune");
807 drop(lock);
808
809 assert!(old.exists(), "the locked file could not be deleted");
810 assert!(!mid.exists(), "the next-oldest file was tried and removed");
811 assert!(
812 !new.exists(),
813 "pruning kept reaching for newer files until the cap was actually met, \
814 not just until a fixed selection ran out"
815 );
816 assert!(
817 pruned.remaining <= 8,
818 "the achieved total must reach the cap: {pruned:?}"
819 );
820 }
821
822 #[test]
823 fn prune_leaves_a_missing_dir_alone() {
824 let t = tempfile::TempDir::new().expect("temp");
825 let out = prune_dir(&t.path().join("absent"), 1).expect("prune");
826 assert_eq!(out, Prune::default());
827 }
828
829 #[test]
830 fn prune_sweeps_directories_the_files_leave_empty() {
831 let t = tempfile::TempDir::new().expect("temp");
832 let deep = t.path().join("a").join("b").join("c");
833 fs::create_dir_all(&deep).expect("dirs");
834 fs::write(deep.join("f"), b"1234").expect("write");
835 let out = prune_dir(t.path(), 0).expect("prune");
836 assert_eq!(out.files, 1);
837 assert_eq!(out.remaining, 0);
838 assert!(!t.path().join("a").exists(), "empty chain swept");
839 }
840}
841
842#[cfg(test)]
843mod pressure_tests {
844 #[test]
845 fn pressure_reclaims_below_cap_without_underflow() {
846 assert_eq!(super::pressure_limit(100, 200, 80, 30), 50);
847 assert_eq!(super::pressure_limit(100, 200, 80, 100), 100);
848 assert_eq!(super::pressure_limit(100, 200, 800, 0), 0);
849 assert_eq!(super::pressure_limit(100, 50, 0, 0), 50);
850 }
851}