cacache-sync 11.0.0

Synchronous, content-addressable, key-value, high-performance, on-disk cache.
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
138
139
140

//! Functions for removing things from the cache.
use std::fs;
use std::path::Path;

use ssri::Integrity;

use crate::content::rm;
use crate::errors::{Internal, Result};
use crate::index;

/// Removes an individual index entry synchronously. The associated content
/// will be left in the cache.
///
/// ## Example
/// ```no_run
/// use std::io::Read;
///
/// fn main() -> cacache_sync::Result<()> {
///     let sri = cacache_sync::write("./my-cache", "my-key", b"hello")?;
///
///     cacache_sync::remove("./my-cache", "my-key")?;
///
///     // This fails:
///     cacache_sync::read("./my-cache", "my-key")?;
///
///     // But this succeeds:
///     cacache_sync::read_hash("./my-cache", &sri)?;
///
///     Ok(())
/// }
/// ```
pub fn remove<P, K>(cache: P, key: K) -> Result<()>
where
    P: AsRef<Path>,
    K: AsRef<str>,
{
    index::delete(cache.as_ref(), key.as_ref())
}

/// Removes an individual content entry synchronously. Any index entries
/// pointing to this content will become invalidated.
///
/// ## Example
/// ```no_run
/// use std::io::Read;
///
/// fn main() -> cacache_sync::Result<()> {
///     let sri = cacache_sync::write("./my-cache", "my-key", b"hello")?;
///
///     cacache_sync::remove_hash("./my-cache", &sri)?;
///
///     // These fail:
///     cacache_sync::read("./my-cache", "my-key")?;
///     cacache_sync::read_hash("./my-cache", &sri)?;
///
///     // But this succeeds:
///     cacache_sync::metadata("./my-cache", "my-key")?;
///
///     Ok(())
/// }
/// ```
pub fn remove_hash<P: AsRef<Path>>(cache: P, sri: &Integrity) -> Result<()> {
    rm::rm(cache.as_ref(), sri)
}

/// Removes entire contents of the cache synchronously, including temporary
/// files, the entry index, and all content data.
///
/// ## Example
/// ```no_run
/// use std::io::Read;
///
/// fn main() -> cacache_sync::Result<()> {
///     let sri = cacache_sync::write("./my-cache", "my-key", b"hello")?;
///
///     cacache_sync::clear("./my-cache")?;
///
///     // These all fail:
///     cacache_sync::read("./my-cache", "my-key")?;
///     cacache_sync::read_hash("./my-cache", &sri)?;
///     cacache_sync::metadata("./my-cache", "my-key")?;
///
///     Ok(())
/// }
/// ```
pub fn clear<P: AsRef<Path>>(cache: P) -> Result<()> {
    for entry in (cache.as_ref().read_dir().to_internal()?).flatten() {
        fs::remove_dir_all(entry.path()).to_internal()?;
    }
    Ok(())
}

#[cfg(test)]
mod tests {

    #[test]
    fn test_remove() {
        let tmp = tempfile::tempdir().unwrap();
        let dir = tmp.path().to_owned();
        let sri = crate::write(&dir, "key", b"my-data").unwrap();

        crate::remove(&dir, "key").unwrap();

        let new_entry = crate::metadata(&dir, "key").unwrap();
        assert!(new_entry.is_none());

        let data_exists = crate::exists(&dir, &sri);
        assert!(data_exists);
    }

    #[test]
    fn test_remove_data() {
        let tmp = tempfile::tempdir().unwrap();
        let dir = tmp.path().to_owned();
        let sri = crate::write(&dir, "key", b"my-data").unwrap();

        crate::remove_hash(&dir, &sri).unwrap();

        let entry = crate::metadata(&dir, "key").unwrap();
        assert!(entry.is_some());

        let data_exists = crate::exists(&dir, &sri);
        assert!(!data_exists);
    }

    #[test]
    fn test_clear() {
        let tmp = tempfile::tempdir().unwrap();
        let dir = tmp.path().to_owned();
        let sri = crate::write(&dir, "key", b"my-data").unwrap();

        crate::clear(&dir).unwrap();

        let entry = crate::metadata(&dir, "key").unwrap();
        assert_eq!(entry, None);

        let data_exists = crate::exists(&dir, &sri);
        assert!(!data_exists);
    }
}