hardcpy 0.2.1

Simple backup tool written in Rust
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

#[cfg(test)]
mod tests {
    use crate::_copy;
    use rand::Rng;
    use rusqlite::Connection;
    use std::fs;
    use std::fs::File;
    use std::io::Write;

    const FILE_SIZE: usize = 1024 * 1024 * 16;
    const FILE_SIZE_S: usize = 1024 * 1024;
    #[test]
    fn create_backup_singlethread() {
        let mut conn = Connection::open_in_memory().unwrap();
        let tx = conn.transaction().unwrap();

        tx.execute(
            "CREATE TABLE IF NOT EXISTS Backups (
            id INTEGER PRIMARY KEY,
            source TEXT NOT NULL,
            dest TEXT NOT NULL,
            compression TEXT
        )",
            (),
        )
        .unwrap();

        tx.execute(
            "CREATE TABLE IF NOT EXISTS Files (
            backup_id INTEGER NOT NULL,
            source TEXT NOT NULL,
            dest TEXT NOT NULL,
            sha256 TEXT NOT NULL,
            PRIMARY KEY (source, dest)
        )",
            (),
        )
        .unwrap();

        fs::create_dir_all("test/test_singlethread/source").unwrap();
        fs::create_dir_all("test/test_singlethread/dest").unwrap();

        let mut f = File::create("test/test_singlethread/source/big_file").unwrap();
        let mut rng = rand::thread_rng();
        let mut buf = Vec::with_capacity(FILE_SIZE);
        for _ in 0..=FILE_SIZE {
            buf.push(rng.gen());
        }
        f.write_all(&*buf).unwrap();
        f.flush().unwrap();

        _copy(
            &tx,
            false,
            "test/test_singlethread/source".into(),
            "test/test_singlethread/dest".into(),
        );
    }

    #[test]
    fn create_backup_multithread() {
        let mut conn = Connection::open_in_memory().unwrap();
        let tx = conn.transaction().unwrap();

        tx.execute(
            "CREATE TABLE IF NOT EXISTS Backups (
            id INTEGER PRIMARY KEY,
            source TEXT NOT NULL,
            dest TEXT NOT NULL,
            compression TEXT
        )",
            (),
        )
        .unwrap();

        tx.execute(
            "CREATE TABLE IF NOT EXISTS Files (
            backup_id INTEGER NOT NULL,
            source TEXT NOT NULL,
            dest TEXT NOT NULL,
            sha256 TEXT NOT NULL,
            PRIMARY KEY (source, dest)
        )",
            (),
        )
        .unwrap();

        fs::create_dir_all("test/test_multithread/source").unwrap();
        fs::create_dir_all("test/test_multithread/dest").unwrap();

        for i in 1..=16 {
            let mut f =
                File::create(format!("test/test_multithread/source/small_file{}", i)).unwrap();
            let mut rng = rand::thread_rng();
            let mut buf = Vec::with_capacity(FILE_SIZE_S);
            for _ in 0..=FILE_SIZE_S {
                buf.push(rng.gen());
            }
            f.write_all(&*buf).unwrap();
            f.flush().unwrap();
        }

        _copy(
            &tx,
            true,
            "test/test_multithread/source".into(),
            "test/test_multithread/dest".into(),
        );
    }
}