neverest 0.1.0

CLI to synchronize and backup emails
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

//! # Check up account command
//!
//! This module contains the [`clap`] command for checking up left and
//! right backends integrity of a given account.

use anyhow::Result;
use clap::Parser;
use email::backend::{Backend, BackendBuilder};
#[cfg(feature = "imap")]
use email::imap::{ImapContextBuilder, ImapContextSync};
#[cfg(feature = "maildir")]
use email::maildir::{MaildirContextBuilder, MaildirContextSync};
#[cfg(feature = "notmuch")]
use email::notmuch::{NotmuchContextBuilder, NotmuchContextSync};
use log::info;
use std::sync::Arc;

use crate::{
    account::arg::name::OptionalAccountNameArg, backend::config::BackendConfig, config::Config,
    printer::Printer,
};

/// Check up the given account.
///
/// This command performs a checkup of the given account. It checks if
/// the configuration is valid, if backend can be created and if
/// sessions work as expected.
#[derive(Debug, Parser)]
pub struct CheckUpAccountCommand {
    #[command(flatten)]
    pub account: OptionalAccountNameArg,
}

impl CheckUpAccountCommand {
    pub async fn execute(self, printer: &mut impl Printer, config: &Config) -> Result<()> {
        info!("executing check up account command");

        let (name, config) = config.into_account_config(self.account.name.as_deref())?;
        printer.print_log(format!("Checking `{name}` account integrity…"))?;

        let folder_filter = config.folder.map(|c| c.filter).unwrap_or_default();
        let envelope_filter = config.envelope.map(|c| c.filter).unwrap_or_default();

        let (left_backend, left_config) = config.left.into_account_config(
            name.clone(),
            folder_filter.clone(),
            envelope_filter.clone(),
        );

        match left_backend {
            #[cfg(feature = "imap")]
            BackendConfig::Imap(imap_config) => {
                printer.print_log("Checking left IMAP integrity…")?;
                let ctx = ImapContextBuilder::new(left_config.clone(), Arc::new(imap_config));
                BackendBuilder::new(left_config.clone(), ctx)
                    .check_up::<Backend<ImapContextSync>>()
                    .await?;
            }
            #[cfg(feature = "maildir")]
            BackendConfig::Maildir(maildir_config) => {
                printer.print_log("Checking left Maildir integrity…")?;
                let ctx = MaildirContextBuilder::new(left_config.clone(), Arc::new(maildir_config));
                BackendBuilder::new(left_config.clone(), ctx)
                    .check_up::<Backend<MaildirContextSync>>()
                    .await?;
            }
            #[cfg(feature = "notmuch")]
            BackendConfig::Notmuch(notmuch_config) => {
                printer.print_log("Checking left Notmuch integrity…")?;
                let ctx = NotmuchContextBuilder::new(left_config.clone(), Arc::new(notmuch_config));
                BackendBuilder::new(left_config.clone(), ctx)
                    .check_up::<Backend<NotmuchContextSync>>()
                    .await?;
            }
        };

        let (right_backend, right_config) =
            config
                .right
                .into_account_config(name.clone(), folder_filter, envelope_filter);

        match right_backend {
            #[cfg(feature = "imap")]
            BackendConfig::Imap(imap_config) => {
                printer.print_log("Checking right IMAP integrity…")?;
                let ctx = ImapContextBuilder::new(right_config.clone(), Arc::new(imap_config));
                BackendBuilder::new(right_config.clone(), ctx)
                    .check_up::<Backend<ImapContextSync>>()
                    .await?;
            }
            #[cfg(feature = "maildir")]
            BackendConfig::Maildir(maildir_config) => {
                printer.print_log("Checking right Maildir integrity…")?;
                let ctx =
                    MaildirContextBuilder::new(right_config.clone(), Arc::new(maildir_config));
                BackendBuilder::new(right_config.clone(), ctx)
                    .check_up::<Backend<MaildirContextSync>>()
                    .await?;
            }
            #[cfg(feature = "notmuch")]
            BackendConfig::Notmuch(notmuch_config) => {
                printer.print_log("Checking right Notmuch integrity…")?;
                let ctx =
                    NotmuchContextBuilder::new(right_config.clone(), Arc::new(notmuch_config));
                BackendBuilder::new(right_config.clone(), ctx)
                    .check_up::<Backend<NotmuchContextSync>>()
                    .await?;
            }
        };

        printer.print("Checkup successfully completed!")
    }
}