backpak 0.3.0

A content-addressed backup system with deduplication and compression
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

use super::*;

use std::io::{self, Cursor};
use std::sync::Mutex;

use anyhow::Result;
use rustc_hash::FxHashMap;

/// A backend that stores everything as path-addressed buffers.
///
/// Great for testing
pub struct MemoryBackend {
    files: Mutex<FxHashMap<String, Vec<u8>>>,
}

impl MemoryBackend {
    pub fn new() -> Self {
        Self {
            files: Mutex::new(FxHashMap::default()),
        }
    }

    // Cursor is also seek - expose that to `CachedBackend`
    pub fn read_cursor(&self, from: &str) -> Result<Cursor<Vec<u8>>> {
        let buf: Vec<u8> = self
            .files
            .lock()
            .unwrap()
            .get(from)
            .ok_or_else(|| anyhow!("No file {}", from))?
            .clone();
        Ok(Cursor::new(buf))
    }
}

impl Default for MemoryBackend {
    fn default() -> Self {
        Self::new()
    }
}

impl Backend for MemoryBackend {
    fn read(&self, from: &str) -> Result<Box<dyn Read + Send + 'static>> {
        Ok(Box::new(self.read_cursor(from)?))
    }

    fn write(&self, _len: u64, from: &mut (dyn Read + Send), to: &str) -> Result<()> {
        let mut vec = Vec::new();
        io::copy(from, &mut vec)?;
        self.files.lock().unwrap().insert(to.to_owned(), vec);
        Ok(())
    }

    fn remove(&self, which: &str) -> Result<()> {
        self.files.lock().unwrap().remove(which);
        Ok(())
    }

    fn list(&self, prefix: &str) -> Result<Vec<(String, u64)>> {
        let paths: Vec<_> = self
            .files
            .lock()
            .unwrap()
            .iter()
            .filter(|(f, _v)| f.starts_with(prefix))
            .map(|(f, v)| (f.clone(), v.len() as u64))
            .collect();
        Ok(paths)
    }
}