cargo-reclaim 0.2.2

Safe Cargo cleanup for target directories, stale artifacts, and Cargo home caches
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use std::fs;
use std::io;
use std::path::Path;

use super::model::{CargoHomePathKind, CargoHomeProblem};

pub(super) struct MeasuredPath {
    pub kind: CargoHomePathKind,
    pub size_bytes: u64,
    pub skipped: bool,
    pub reason: String,
    pub problems: Vec<CargoHomeProblem>,
}

pub(super) fn measure_existing_path(path: &Path) -> io::Result<MeasuredPath> {
    let metadata = fs::symlink_metadata(path)?;
    let file_type = metadata.file_type();
    if file_type.is_symlink() {
        return Ok(MeasuredPath {
            kind: CargoHomePathKind::Symlink,
            size_bytes: 0,
            skipped: true,
            reason: "preserved; symlink was not followed".to_string(),
            problems: Vec::new(),
        });
    }

    if file_type.is_file() {
        return Ok(MeasuredPath {
            kind: CargoHomePathKind::File,
            size_bytes: metadata.len(),
            skipped: false,
            reason: "preserved; Cargo home report is read-only".to_string(),
            problems: Vec::new(),
        });
    }

    if file_type.is_dir() {
        let mut problems = Vec::new();
        let size_bytes = measure_directory(path, &mut problems);
        let skipped = !problems.is_empty();
        let reason = if skipped {
            "preserved; one or more child paths could not be read".to_string()
        } else {
            "preserved; Cargo home report is read-only".to_string()
        };
        return Ok(MeasuredPath {
            kind: CargoHomePathKind::Directory,
            size_bytes,
            skipped,
            reason,
            problems,
        });
    }

    Ok(MeasuredPath {
        kind: CargoHomePathKind::Other,
        size_bytes: metadata.len(),
        skipped: false,
        reason: "preserved; unrecognized filesystem entry".to_string(),
        problems: Vec::new(),
    })
}

fn measure_directory(path: &Path, problems: &mut Vec<CargoHomeProblem>) -> u64 {
    let children = match fs::read_dir(path) {
        Ok(children) => children,
        Err(error) => {
            problems.push(CargoHomeProblem {
                path: path.to_path_buf(),
                message: error.to_string(),
            });
            return 0;
        }
    };

    let mut total = 0u64;
    for child in children {
        let child = match child {
            Ok(child) => child,
            Err(error) => {
                problems.push(CargoHomeProblem {
                    path: path.to_path_buf(),
                    message: error.to_string(),
                });
                continue;
            }
        };
        total = total.saturating_add(measure_child(&child.path(), problems));
    }
    total
}

fn measure_child(path: &Path, problems: &mut Vec<CargoHomeProblem>) -> u64 {
    let metadata = match fs::symlink_metadata(path) {
        Ok(metadata) => metadata,
        Err(error) => {
            problems.push(CargoHomeProblem {
                path: path.to_path_buf(),
                message: error.to_string(),
            });
            return 0;
        }
    };
    let file_type = metadata.file_type();
    if file_type.is_symlink() {
        return 0;
    }
    if file_type.is_dir() {
        return measure_directory(path, problems);
    }
    metadata.len()
}