dee 0.0.18

An cli for drand, with support for timelock encryption.
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

use anyhow::anyhow;
use std::process;

mod cli;
mod cmd;
mod config;
mod print;
mod time;

fn main() {
    let cli = cli::build();
    let mut cfg: config::Local = config::Local::load();
    env_logger::Builder::new()
        .filter_level(cli.verbose.log_level_filter())
        .init();

    let output = match cli.command {
        cli::Commands::Rand {
            set_upstream,
            verify,
            long,
            json,
            beacon,
        } => match cfg.set_upstream_and_chain(set_upstream) {
            Ok(chain) => cmd::rand(&cfg, print::Format::new(long, json), chain, beacon, verify),
            Err(err) => Err(err),
        },
        cli::Commands::Crypt {
            encrypt,
            decrypt,
            inspect,
            set_upstream,
            round,
            armor,
            output,
            input,
        } => {
            let is_inspect = inspect.is_true();
            match cfg.set_upstream_and_chain(set_upstream) {
                Ok(chain) => match (encrypt, decrypt, is_inspect) {
                    (true, false, false) => {
                        cmd::crypt::encrypt(&cfg, output, input, armor, chain, round)
                    }
                    (_, true, _) => cmd::crypt::decrypt(&cfg, output, input, chain),
                    (_, _, true) => cmd::crypt::inspect(
                        &cfg,
                        print::Format::new(inspect.long(), inspect.json()),
                        input,
                        chain,
                    ),
                    _ => unreachable!(),
                },
                Err(err) => Err(err),
            }
        }
        cli::Commands::Remote { command } => match command {
            Some(command) => match command {
                cli::RemoteCommand::Add { name, url } => cmd::remote::add(&mut cfg, name, &url),
                cli::RemoteCommand::Remove { name } => cmd::remote::remove(&mut cfg, name),
                cli::RemoteCommand::Rename { old, new } => cmd::remote::rename(&mut cfg, old, new),
                cli::RemoteCommand::SetUrl { name, url } => {
                    cmd::remote::set_url(&mut cfg, name, &url)
                }
                cli::RemoteCommand::Show { long, json, name } => cmd::remote::show(
                    &cfg,
                    print::Format::new(long, json),
                    name.or(cfg.upstream())
                        .ok_or(anyhow!("No chain or upstream"))
                        .unwrap(),
                ),
            },
            None => cmd::remote::list(&cfg),
        },
    };

    match output {
        Ok(result) => {
            cfg.store().unwrap();
            if !result.is_empty() {
                println!("{result}")
            }
        }
        Err(err) => {
            eprintln!("error: {err}");
            process::exit(1)
        }
    }
}