chkpt-core 0.3.0

Core library for chkpt – a fast, content-addressable checkpoint system
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

use crate::error::Result;
use bitcode::{Decode, Encode};
use std::collections::HashMap;
use std::path::{Path, PathBuf};

#[derive(Debug, Clone, Encode, Decode)]
pub struct FileEntry {
    pub path: String,
    pub blob_hash: [u8; 16],
    pub size: u64,
    pub mtime_secs: i64,
    pub mtime_nanos: i64,
    pub inode: Option<u64>,
    pub mode: u32,
}

pub struct FileIndex {
    path: PathBuf,
    entries: HashMap<String, FileEntry>,
}

impl FileIndex {
    pub fn open<P: AsRef<Path>>(path: P) -> Result<Self> {
        let path = path.as_ref().to_path_buf();
        let entries = match std::fs::read(&path) {
            Ok(data) => match bitcode::decode::<Vec<FileEntry>>(&data) {
                Ok(entries_vec) => {
                    let mut entries = HashMap::with_capacity(entries_vec.len());
                    for entry in entries_vec {
                        entries.insert(entry.path.clone(), entry);
                    }
                    entries
                }
                Err(_) => {
                    // Decode failure means the on-disk index was written by an
                    // incompatible version (e.g. 32-byte hashes vs. 16-byte).
                    // The index is a pure performance cache: treat it as empty
                    // so the next save falls back to a full scan rather than
                    // hard-failing.  The stale file will be overwritten on the
                    // next successful flush.
                    HashMap::new()
                }
            },
            Err(error) if error.kind() == std::io::ErrorKind::NotFound => HashMap::new(),
            Err(error) => return Err(error.into()),
        };
        Ok(Self { path, entries })
    }

    fn flush(&self) -> Result<()> {
        let mut entries_vec = Vec::with_capacity(self.entries.len());
        entries_vec.extend(self.entries.values().cloned());
        let encoded = bitcode::encode(&entries_vec);
        let tmp_path = self.path.with_extension("bin.tmp");
        std::fs::write(&tmp_path, &encoded)?;
        std::fs::rename(&tmp_path, &self.path)?;
        Ok(())
    }

    pub fn upsert(&mut self, entry: &FileEntry) -> Result<()> {
        self.entries.insert(entry.path.clone(), entry.clone());
        self.flush()
    }

    pub fn bulk_upsert(&mut self, entries: &[FileEntry]) -> Result<()> {
        self.apply_changes(&[], entries)
    }

    pub fn bulk_remove(&mut self, paths: &[String]) -> Result<()> {
        self.apply_changes(paths, &[])
    }

    pub fn apply_changes(
        &mut self,
        paths_to_remove: &[String],
        entries_to_upsert: &[FileEntry],
    ) -> Result<()> {
        if paths_to_remove.is_empty() && entries_to_upsert.is_empty() {
            return Ok(());
        }
        for path in paths_to_remove {
            self.entries.remove(path);
        }
        for entry in entries_to_upsert {
            self.entries.insert(entry.path.clone(), entry.clone());
        }
        self.flush()
    }

    pub fn get(&self, path: &str) -> Result<Option<FileEntry>> {
        Ok(self.entries.get(path).cloned())
    }

    pub fn remove(&mut self, path: &str) -> Result<()> {
        self.entries.remove(path);
        self.flush()
    }

    pub fn all_paths(&self) -> Result<Vec<String>> {
        Ok(self.entries.keys().cloned().collect())
    }

    pub fn all_entries(&self) -> Result<Vec<FileEntry>> {
        Ok(self.entries.values().cloned().collect())
    }

    pub fn entries(&self) -> &HashMap<String, FileEntry> {
        &self.entries
    }

    pub fn entries_by_path(&self) -> Result<HashMap<String, FileEntry>> {
        Ok(self.entries.clone())
    }

    pub fn clear(&mut self) -> Result<()> {
        self.entries.clear();
        self.flush()
    }
}