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

use std::thread::Scope;

use anyhow::Result;
use console::Term;

use crate::{
    backup,
    progress::{self, print_backup_lines, print_download_line, truncate_path},
};

use super::*;

pub struct ProgressThread<'scope> {
    inner: progress::ProgressThread<'scope>,
}

impl<'scope> ProgressThread<'scope> {
    pub fn spawn<'env>(
        s: &'scope Scope<'scope, 'env>,
        bs: &'env backup::BackupStatistics,
        ws: &'env WalkStatistics,
        down: &'env AtomicU64,
        up: &'env AtomicU64,
    ) -> Self {
        let inner = progress::ProgressThread::spawn(s, |i| {
            print_progress(i, &Term::stdout(), bs, ws, down, up)
        });
        Self { inner }
    }

    pub fn join(self) {
        self.inner.join()
    }
}

fn print_progress(
    i: usize,
    term: &Term,
    bstats: &backup::BackupStatistics,
    wstats: &WalkStatistics,
    down: &AtomicU64,
    up: &AtomicU64,
) -> Result<()> {
    if i > 0 {
        term.clear_last_lines(5)?;
    }

    let rb = wstats.reused_bytes.load(Ordering::Relaxed);
    let ub = up.load(Ordering::Relaxed);
    print_backup_lines(i, bstats, rb, ub);

    print_download_line(down.load(Ordering::Relaxed));

    let cs = wstats.current_snapshot.borrow();
    println!("Snapshot: {cs}");

    let cf = wstats.current_file.borrow();
    let cf = truncate_path(&cf, term);
    println!("{cf}");
    Ok(())
}