repro-env 0.3.0

Dependency lockfiles for a reproducible build environment 📦🔒
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

use crate::errors::*;
use std::path::PathBuf;

static SHARD_SIZE: usize = 2;

pub fn repro_env_dir() -> Result<PathBuf> {
    let mut cache = dirs::cache_dir().context("Failed to detect cache directory")?;
    cache.push("repro-env");
    Ok(cache)
}

pub fn pkgs_cache_dir() -> Result<PkgsCacheDir> {
    let mut path = repro_env_dir()?;
    path.push("pkgs");
    Ok(PkgsCacheDir { path })
}

#[derive(Debug)]
pub struct PkgsCacheDir {
    path: PathBuf,
}

impl PkgsCacheDir {
    pub fn sha256_path(&self, sha256: &str) -> Result<PathBuf> {
        if sha256.len() != 64 {
            bail!("Unexpected sha256 checksum length: {:?}", sha256.len());
        }
        if !sha256.chars().all(char::is_alphanumeric) {
            bail!("Unexpected characters in sha256: {sha256:?}");
        }

        let mut path = self.path.clone();

        let shard = &sha256[..SHARD_SIZE];
        path.push(shard);
        let suffix = &sha256[SHARD_SIZE..];
        path.push(suffix);

        Ok(path)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::path::Path;

    #[test]
    fn test_sha256_path() {
        let dir = PkgsCacheDir {
            path: PathBuf::from("/cache"),
        };
        assert!(dir.sha256_path("").is_err());
        assert!(dir.sha256_path("ffff").is_err());
        assert!(dir
            .sha256_path("////////////////////////////////////////////////////////////////")
            .is_err());

        let path = dir
            .sha256_path("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
            .unwrap();
        assert_eq!(
            path,
            Path::new("/cache/ff/ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
        );
    }
}