zccache 1.12.8

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//! Shared daemon-management utilities used by both the download client and
//! the download daemon binary (lock-file helpers, default endpoint, etc.).

use crate::core::NormalizedPath;

/// Return the default IPC endpoint for the download daemon.
pub fn default_endpoint() -> String {
    if let Some(top_root) = crate::core::config::cache_dir_override() {
        // Issue #761 / #762 Phase 0: append `v<VERSION>` so two sibling
        // daemon versions sharing one env-pinned root don't collide on
        // the IPC endpoint name. The override returns the unversioned
        // top-level; the endpoint resolver applies the version segment.
        let versioned = top_root.join(crate::core::config::versioned_subdir());
        return endpoint_for_cache_dir(versioned.as_path());
    }

    #[cfg(unix)]
    {
        if let Ok(runtime_dir) = std::env::var("XDG_RUNTIME_DIR") {
            return format!("{runtime_dir}/zccache-download/sock");
        }
        let user = std::env::var("USER").unwrap_or_else(|_| String::from("unknown"));
        format!("/tmp/zccache-download-{user}/sock")
    }
    #[cfg(windows)]
    {
        let username = std::env::var("USERNAME").unwrap_or_else(|_| String::from("unknown"));
        let username = crate::core::config::sanitize_ipc_component(&username)
            .unwrap_or_else(|| String::from("unknown"));
        format!(r"\\.\pipe\zccache-download-{username}")
    }
}

fn endpoint_for_cache_dir(cache_dir: &std::path::Path) -> String {
    #[cfg(unix)]
    {
        cache_dir
            .join("download-daemon.sock")
            .to_string_lossy()
            .into_owned()
    }
    #[cfg(windows)]
    {
        let suffix = crate::core::stable_path_id(cache_dir);
        format!(r"\\.\pipe\zccache-download-{suffix}")
    }
}

/// Path to the daemon PID lock file.
pub fn lock_file_path() -> NormalizedPath {
    crate::core::config::default_cache_dir().join("download-daemon.lock")
}

/// Write the daemon PID to the lock file.
pub fn write_lock_file(pid: u32) -> Result<(), std::io::Error> {
    let path = lock_file_path();
    if let Some(parent) = path.parent() {
        std::fs::create_dir_all(parent)?;
    }
    std::fs::write(path, pid.to_string())
}

/// Remove the daemon lock file (best-effort).
pub fn remove_lock_file() {
    let _ = std::fs::remove_file(lock_file_path());
}

/// Read the PID stored in the daemon lock file, if it exists and is valid.
pub fn read_lock_file_pid() -> Option<u32> {
    std::fs::read_to_string(lock_file_path())
        .ok()
        .and_then(|s| s.trim().parse::<u32>().ok())
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::ffi::OsString;
    use std::sync::{Mutex, MutexGuard};

    static ENV_LOCK: Mutex<()> = Mutex::new(());

    struct EnvGuard {
        _lock: MutexGuard<'static, ()>,
        previous: Option<OsString>,
    }

    impl EnvGuard {
        fn set_cache_dir(value: &std::path::Path) -> Self {
            let lock = ENV_LOCK.lock().unwrap();
            let previous = std::env::var_os(crate::core::config::CACHE_DIR_ENV);
            std::env::set_var(crate::core::config::CACHE_DIR_ENV, value);
            Self {
                _lock: lock,
                previous,
            }
        }
    }

    impl Drop for EnvGuard {
        fn drop(&mut self) {
            match &self.previous {
                Some(value) => std::env::set_var(crate::core::config::CACHE_DIR_ENV, value),
                None => std::env::remove_var(crate::core::config::CACHE_DIR_ENV),
            }
        }
    }

    #[test]
    fn cache_dir_override_moves_download_endpoint_and_lock_file() {
        let root = tempfile::tempdir().unwrap();
        let cache_dir = root.path().join("zc");
        let _env = EnvGuard::set_cache_dir(&cache_dir);

        // Issue #761 / #762 Phase 0: the env var pins the *top-level* root;
        // every state file (including this lock file) lives under
        // `<top-level>/v<VERSION>/`.
        let versioned = cache_dir.join(crate::core::config::versioned_subdir());

        let endpoint = default_endpoint();
        #[cfg(unix)]
        assert_eq!(
            endpoint,
            versioned
                .join("download-daemon.sock")
                .to_string_lossy()
                .into_owned()
        );
        #[cfg(windows)]
        {
            assert!(endpoint.starts_with(r"\\.\pipe\zccache-download-"));
            assert!(endpoint.ends_with(&crate::core::stable_path_id(&versioned)));
        }

        assert_eq!(lock_file_path(), versioned.join("download-daemon.lock"));
    }
}