dwh 0.7.1

A library to use the digitronic protocol dwh
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

use std::path::PathBuf;

use dwh::{
    args::{ConnectionArgs, Timeout},
    git_backup::FileMetaProviderConfig,
    BackdoorReauthHandler, Dwh,
};

use clap::Parser;
use tracing_subscriber::EnvFilter;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]

pub struct GitBackupArgs {
    pub destination: PathBuf,
    pub host: String,

    #[command(flatten)]
    pub connection_args: ConnectionArgs,

    #[command(flatten)]
    timeout: Timeout,
    #[arg(long, env)]
    pub file_meta_provider: FileMetaProviderConfig,

    #[arg(long, short, env = "INCLUDE_FILES")]
    pub include: Option<Vec<String>>,
    #[arg(long, short, env = "EXCLUDE_FILES")]
    pub exclude: Option<Vec<String>>,

    #[arg(long, short, env = "IGNORE_ERROR_FILES")]
    pub ignore_errors: Option<Vec<String>>,
}

#[cfg(test)]
#[test]
fn test_parse() {
    let result = GitBackupArgs::try_parse_from(
        vec![
            "go_fuck_yourself",
            "--header",
            "x-serial-number: 18af9f00314d",
            "--file-meta-provider",
            "file-system",
            "./18af9f00314d",
            "http://127.0.0.1:3000",
        ]
        .iter(),
    );
    if let Err(e) = result.as_ref() {
        println!("{}", e)
    }
    assert!(result.is_ok());
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenv::dotenv().ok();
    tracing_subscriber::fmt()
        .compact()
        .with_env_filter(EnvFilter::from_default_env())
        .init();
    let args = GitBackupArgs::parse();
    let mut dwh = Dwh::new(args.host.clone())?;
    dwh.re_auth_handler = Box::new(BackdoorReauthHandler {});
    args.timeout.apply(&mut dwh);
    dwh.set_hooks(args.connection_args.into_hooks().await?);
    dwh.use_backdooor_and_login().await?;
    dwh::git_backup::backup(
        &mut dwh,
        args.destination,
        Some(dwh::git_backup::GitBackupConfig {
            filter: None,
            file_meta_provider: args.file_meta_provider,
            include: args.include.unwrap_or_default(),
            exclude: args.exclude.unwrap_or_default(),
            retry_strategy: None,
            ignore_errors: args.ignore_errors.unwrap_or_default(),
        }),
    )
    .await?;
    Ok(())
}