cutler 0.19.7

Powerful, declarative settings management for your Mac, with speed.
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

use std::process::exit;

use clap::Parser;
use cutler::autosync::try_auto_sync;

use cutler::cli::Args;
use cutler::cli::atomic::{
    set_accept_all, set_dry_run, set_no_restart_services, set_quiet, set_verbose,
};
use cutler::commands::Runnable;
use cutler::context::AppContextManager;
use cutler::util::sudo::{run_with_noroot, run_with_root};
use cutler::{log_err, log_info};

#[tokio::main(flavor = "multi_thread")]
async fn main() {
    let args = Args::parse();

    // set some of them atomically
    // (described why in util/globals.rs)
    set_accept_all(args.accept_all);
    set_quiet(args.quiet);
    set_verbose(args.verbose);
    set_dry_run(args.dry_run);
    set_no_restart_services(args.no_restart_services);

    // create app context
    let ctx = match AppContextManager::sync().await {
        Ok(ctx) => ctx,
        Err(_) => {
            log_err!("App context failed to initialize for cutler.");
            exit(1);
        }
    };

    // retrieve Runnable from command instance
    let runnable: &dyn Runnable = args.command.as_runnable();
    let rules = runnable.get_invoke_rules();

    // do lock-check and terminate if true
    if rules.respect_lock && ctx.config.is_locked().await {
        log_err!("Config is locked. Run `cutler config unlock` to unlock.");
        exit(1);
    }

    // run remote-sync if command respects
    if args.no_sync {
        log_info!("Skipping remote config autosync.");
    } else if rules.do_config_autosync {
        try_auto_sync(&ctx.config).await;
    }

    // sudo protection
    if let Err(e) = if rules.require_sudo {
        run_with_root().await
    } else {
        run_with_noroot()
    } {
        log_err!("{e}");
        exit(1);
    }

    let result = runnable.run(&ctx).await;

    if let Err(err) = result {
        log_err!("{err}");
        exit(1);
    }
}