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
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

use std::{
    io::prelude::*,
    process::{self, Stdio},
};

use anyhow::{Context, Result, bail, ensure};
use byte_unit::Byte;
use clap::{Parser, Subcommand};

use crate::backend;
use crate::pack;

#[derive(Debug, Parser)]
pub struct Args {
    #[clap(short, long)]
    pack_size: Option<String>,

    #[clap(long)]
    gpg: Option<String>,

    #[clap(subcommand)]
    subcommand: Command,
}

#[derive(Debug, Subcommand)]
enum Command {
    /// Backup to a directory on the local filesystem.
    Filesystem {
        /// Normally filesystem backups skip caching in ~/.cache/backpak,
        /// assuming reads & writes directly to the backend are just as fast.
        /// If the given path is over a remote mount (e.g., FTP, SMB, SSHFS)
        /// use this to override that assumption.
        #[clap(long, verbatim_doc_comment)]
        force_cache: bool,
    },
    /// Backup to Backblaze B2
    Backblaze {
        #[clap(short, long)]
        key_id: String,
        #[clap(short, long)]
        application_key: String,
        #[clap(short, long)]
        bucket: String,
        #[clap(short, long, default_value_t = 4)]
        concurrent_connections: u32,
    },
}

pub fn run(repository: &camino::Utf8Path, args: Args) -> Result<()> {
    let pack_size = args
        .pack_size
        .map(|s| Byte::parse_str(s, true)) // Don't interpret b as bits.
        .transpose()
        .context("Couldn't parse --pack-size")?;
    let pack_size = pack_size.unwrap_or(pack::DEFAULT_PACK_SIZE);
    let filter = args.gpg.map(|g| {
        (
            "gpg --encrypt --quiet --recipient ".to_owned() + &g,
            "gpg --decrypt --quiet".to_owned(),
        )
    });
    if let Some((f, u)) = &filter {
        round_trip_filter_test(f, u)?;
    }
    match args.subcommand {
        Command::Filesystem { force_cache } => {
            backend::fs::initialize(repository, pack_size, filter, force_cache)
        }
        Command::Backblaze {
            key_id,
            application_key,
            bucket,
            concurrent_connections,
        } => backend::backblaze::initialize(
            repository,
            pack_size,
            filter,
            key_id,
            application_key,
            bucket,
            concurrent_connections,
        ),
    }
}

const PLAINTEXT: &str = r"I'd like some help remembering stuff.
I wonder if I could come down and see you,
and we could drink and talk and remember.
r";

fn round_trip_filter_test(filter: &str, unfilter: &str) -> Result<()> {
    let mut f = process::Command::new("sh")
        .arg("-c")
        .arg(filter)
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .spawn()
        .with_context(|| format!("Couldn't run {filter}"))?;
    f.stdin
        .take()
        .unwrap()
        .write_all(PLAINTEXT.as_bytes())
        .with_context(|| format!("Couldn't write to {filter}"))?;
    let fr = f.wait_with_output().unwrap();
    ensure!(fr.status.success(), "{filter} failed");
    let filtered = fr.stdout;

    let mut uf = process::Command::new("sh")
        .arg("-c")
        .arg(unfilter)
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .spawn()
        .with_context(|| format!("Couldn't run {unfilter}"))?;
    uf.stdin
        .take()
        .unwrap()
        .write_all(&filtered)
        .with_context(|| format!("Couldn't write to {unfilter}"))?;
    let ufr = uf.wait_with_output().unwrap();
    ensure!(ufr.status.success(), "{unfilter} failed");

    let unfiltered = ufr.stdout;
    if unfiltered != PLAINTEXT.as_bytes() {
        let nope = String::from_utf8_lossy(&unfiltered);
        bail!("filter didn't round trip!\nExpected:\n{PLAINTEXT}\nGot:\n{nope}");
    }
    Ok(())
}