auberge 0.14.15

CLI tool for managing self-hosted infrastructure with Ansible
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

mod reconcile;
mod rescan;
mod verify;

use crate::output::OutputFormat;
use crate::services::bichon::rescan::ARCHIVE_DIR;
use clap::Subcommand;
use eyre::Result;

pub use reconcile::run_reconcile_folders;
pub use rescan::run_rescan;
pub use verify::run_verify_coverage;

#[derive(Subcommand)]
pub enum BichonCommands {
    #[command(
        alias = "rf",
        about = "Reconcile account sync_folders from live IMAP folders"
    )]
    ReconcileFolders {
        #[arg(short = 'H', long, help = "Target host running Bichon")]
        host: String,
        #[arg(long, help = "Apply changes to Bichon accounts")]
        apply: bool,
        #[arg(long, help = "Only reconcile one account email")]
        account: Option<String>,
        #[arg(
            short = 'o',
            long,
            value_enum,
            default_value = "human",
            help = "Output format"
        )]
        output: OutputFormat,
    },
    #[command(
        alias = "vc",
        about = "Verify one folder's Email Archive coverage by message identity"
    )]
    VerifyCoverage {
        #[arg(short = 'H', long, help = "Target host running Bichon")]
        host: String,
        #[arg(
            long,
            help = "Account email; it also names the Email Archive directory"
        )]
        account: String,
        #[arg(long, help = "Folder whose coverage to verify")]
        folder: String,
        #[arg(
            long,
            value_name = "YYYY-MM-DD",
            help = "Verify messages dated strictly before this UTC date"
        )]
        before: String,
        #[arg(
            long,
            default_value = ARCHIVE_DIR,
            help = "Email Archive root on the host"
        )]
        archive_path: String,
        #[arg(
            short = 'o',
            long,
            value_enum,
            default_value = "human",
            help = "Output format"
        )]
        output: OutputFormat,
    },
    #[command(
        alias = "rs",
        about = "Re-archive mail whose Date predates the archive cursor"
    )]
    Rescan {
        #[arg(
            short = 'H',
            long,
            help = "Target host running Bichon (prompted on a TTY when omitted)"
        )]
        host: Option<String>,
        #[arg(
            long,
            help = "Only rescan one account email (prompted on a TTY when omitted)"
        )]
        account: Option<String>,
        #[arg(
            short = 'o',
            long,
            value_enum,
            default_value = "human",
            help = "Output format"
        )]
        output: OutputFormat,
    },
}

pub async fn run_bichon_command(cmd: BichonCommands) -> Result<i32> {
    match cmd {
        BichonCommands::ReconcileFolders {
            host,
            apply,
            account,
            output,
        } => {
            run_reconcile_folders(host, apply, account, output).await?;
            Ok(0)
        }
        BichonCommands::VerifyCoverage {
            host,
            account,
            folder,
            before,
            archive_path,
            output,
        } => run_verify_coverage(host, account, folder, before, archive_path, output).await,
        BichonCommands::Rescan {
            host,
            account,
            output,
        } => run_rescan(host, account, output).await,
    }
}