mbx 1.21.1

A build cache for Rust projects
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

use super::cache::cache_workspace_root;
use super::cargo::{absolute, cargo_roots};
use super::exec::discover_project_root;
use crate::config::Config;
use crate::target;
use bytesize::ByteSize;
use eyre::Result;
use std::path::PathBuf;
use std::process::ExitCode;

#[derive(usage::Args)]
pub(super) struct CleanArgs {
    /// Workspace root whose managed target and learned incremental state are
    /// removed. Defaults to the current workspace.
    workspace: Option<PathBuf>,
}

pub(super) fn run(config: &Config, args: &CleanArgs) -> Result<ExitCode> {
    let working_dir = std::env::current_dir()?;
    let cargo = std::env::var_os("CARGO").unwrap_or_else(|| "cargo".into());
    let workspace = match args.workspace.as_deref() {
        Some(requested) => {
            let requested = absolute(&working_dir, &requested.to_string_lossy());
            cache_workspace_root(&cargo, &requested)
        }
        None => cargo_roots(&cargo, &[], None)
            .map(|roots| roots.workspace_root)
            .unwrap_or_else(|| discover_project_root(&working_dir)),
    };
    let mut config = config.clone();
    config.apply_workspace_policy(&workspace)?;

    match crate::incremental::remove_workspace(&config.cache_dir.join("incremental"), &workspace)? {
        crate::incremental::RemoveOutcome::Removed(bytes) => {
            if bytes > 0 {
                crate::savings::record_quietly(
                    &config.store_dir(),
                    &crate::savings::Delta {
                        freed_requested_bytes: bytes,
                        ..crate::savings::Delta::default()
                    },
                );
            }
            println!(
                "removed learned incremental state for {} ({})",
                workspace.display(),
                ByteSize::b(bytes).display().iec()
            );
        }
        crate::incremental::RemoveOutcome::Active => log::warn!(
            "{} is being built, so its learned incremental state was kept",
            workspace.display()
        ),
        crate::incremental::RemoveOutcome::Missing => {}
    }

    match target::remove_workspace(&config.target.root, &workspace)? {
        target::RemoveOutcome::Removed(bytes) => {
            if bytes > 0 {
                crate::savings::record_quietly(
                    &config.store_dir(),
                    &crate::savings::Delta {
                        freed_requested_bytes: bytes,
                        ..crate::savings::Delta::default()
                    },
                );
            }
            println!(
                "removed the managed target for {} ({})",
                workspace.display(),
                ByteSize::b(bytes).display().iec()
            );
        }
        target::RemoveOutcome::Active => log::warn!(
            "{} is in use by a running command, so its managed target was kept",
            workspace.display()
        ),
        target::RemoveOutcome::Missing => println!("no managed target for {}", workspace.display()),
    }
    Ok(ExitCode::SUCCESS)
}