zccache 1.12.17

Local-first compiler cache for C/C++/Rust/Emscripten
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

use super::*;

#[test]
fn cook_partitioned_export_excludes_cook_owned_outputs() {
    let temp = tempfile::tempdir().unwrap();
    synthetic_target(temp.path());
    let mut plan = sample_plan(temp.path(), RustPlanMode::Thin);
    plan.cache_schema_version = 3;
    plan.packages.ownership_policy = Some(THIN_V3_OWNERSHIP_POLICY_ID.to_string());
    plan.packages.ownership_mode = Some(RustPlanOwnershipMode::CookPartitionedV1);
    plan.packages.ownership_complete = true;
    plan.packages.artifact_owners = vec![
        RustPlanArtifactOwner {
            relative_path: "debug/deps/libserde-abc.rlib".to_string(),
            package_id: "registry+serde@1".to_string(),
            owner: RustPlanArtifactOwnerKind::Cook,
        },
        RustPlanArtifactOwner {
            relative_path: "debug/deps/libapp-abc.rlib".to_string(),
            package_id: "path+app@0.1".to_string(),
            owner: RustPlanArtifactOwnerKind::Zccache,
        },
    ];

    save_rust_plan_local(&plan, temp.path()).unwrap();
    let manifest = load_manifest(&rust_plan_bundle_dir(
        temp.path(),
        &rust_plan_cache_key(&plan),
    ));
    let app = manifest
        .artifacts
        .iter()
        .find(|artifact| artifact.relative_path == "debug/deps/libapp-abc.rlib")
        .expect("project output should be exported");
    assert_eq!(app.owner, Some(RustPlanArtifactOwnerKind::Zccache));
    assert!(!manifest
        .artifacts
        .iter()
        .any(|artifact| artifact.relative_path == "debug/deps/libserde-abc.rlib"));
}

#[test]
fn cook_partitioned_plan_rejects_incomplete_ownership() {
    let temp = tempfile::tempdir().unwrap();
    let mut plan = sample_plan(temp.path(), RustPlanMode::Thin);
    plan.cache_schema_version = 3;
    plan.packages.ownership_policy = Some(THIN_V3_OWNERSHIP_POLICY_ID.to_string());
    plan.packages.ownership_mode = Some(RustPlanOwnershipMode::CookPartitionedV1);
    assert!(plan
        .validate()
        .unwrap_err()
        .to_string()
        .contains("ownership must be complete"));
}

#[test]
fn zccache_all_mode_exports_without_partition_filter() {
    let temp = tempfile::tempdir().unwrap();
    synthetic_target(temp.path());
    let mut plan = sample_plan(temp.path(), RustPlanMode::Thin);
    plan.cache_schema_version = 3;
    plan.packages.ownership_policy = Some(THIN_V3_OWNERSHIP_POLICY_ID.to_string());
    plan.packages.ownership_mode = Some(RustPlanOwnershipMode::ZccacheAllV1);

    save_rust_plan_local(&plan, temp.path()).unwrap();
    let manifest = load_manifest(&rust_plan_bundle_dir(
        temp.path(),
        &rust_plan_cache_key(&plan),
    ));
    assert!(manifest
        .artifacts
        .iter()
        .any(|artifact| artifact.relative_path == "debug/deps/libserde-abc.rlib"));
    assert!(manifest
        .artifacts
        .iter()
        .any(|artifact| artifact.relative_path == "debug/deps/libapp-abc.rlib"));
}

#[test]
fn materialization_rejects_owner_tampered_bundle() {
    let temp = tempfile::tempdir().unwrap();
    synthetic_target(temp.path());
    let mut plan = sample_plan(temp.path(), RustPlanMode::Thin);
    plan.cache_schema_version = 3;
    plan.packages.ownership_policy = Some(THIN_V3_OWNERSHIP_POLICY_ID.to_string());
    plan.packages.ownership_mode = Some(RustPlanOwnershipMode::ZccacheAllV1);
    save_rust_plan_local(&plan, temp.path()).unwrap();

    let bundle = rust_plan_bundle_dir(temp.path(), &rust_plan_cache_key(&plan));
    let mut manifest = load_manifest(&bundle);
    manifest.artifacts[0].owner = Some(RustPlanArtifactOwnerKind::Cook);
    write_manifest(&bundle, &manifest);
    std::fs::remove_file(temp.path().join("target/debug/deps/libserde-abc.rlib")).unwrap();

    let summary = restore_rust_plan_local(&plan, temp.path()).unwrap();
    assert_eq!(summary.restored_file_count, 0);
    assert!(summary
        .key_input_mismatches
        .iter()
        .any(|reason| reason.contains("non-zccache owner")));
}