genev/
main.rs

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
/* This file is part of DarkFi (https://dark.fi)
 *
 * Copyright (C) 2020-2024 Dyne.org foundation
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

use std::sync::Arc;

use clap::{Parser, Subcommand};
use darkfi::{
    rpc::client::RpcClient,
    util::cli::{get_log_config, get_log_level},
    Result,
};
use simplelog::{ColorChoice, TermLogger, TerminalMode};
use smol::Executor;
use url::Url;

use genevd::GenEvent;

mod rpc;
use rpc::Gen;

#[derive(Parser)]
#[clap(name = "genev", version)]
struct Args {
    #[arg(short, action = clap::ArgAction::Count)]
    /// Increase verbosity (-vvv supported)
    verbose: u8,

    #[clap(short, long, default_value = "tcp://127.0.0.1:28880")]
    /// JSON-RPC endpoint
    endpoint: Url,

    #[clap(subcommand)]
    command: Option<SubCmd>,
}

#[derive(Subcommand)]
enum SubCmd {
    Add { values: Vec<String> },

    List,
}

fn main() -> Result<()> {
    let args = Args::parse();

    let log_level = get_log_level(args.verbose);
    let log_config = get_log_config(args.verbose);
    TermLogger::init(log_level, log_config, TerminalMode::Mixed, ColorChoice::Auto)?;

    let executor = Arc::new(Executor::new());

    smol::block_on(executor.run(async {
        let rpc_client = RpcClient::new(args.endpoint, executor.clone()).await?;
        let gen = Gen { rpc_client };

        match args.command {
            Some(subcmd) => match subcmd {
                SubCmd::Add { values } => {
                    let event = GenEvent {
                        nick: values[0].clone(),
                        title: values[1].clone(),
                        text: values[2..].join(" "),
                    };

                    return gen.add(event).await
                }

                SubCmd::List => {
                    let events = gen.list().await?;
                    for event in events {
                        println!("=============================");
                        println!(
                            "- nickname: {}, title: {}, text: {}",
                            event.nick, event.title, event.text
                        );
                    }
                }
            },
            None => println!("none"),
        }

        gen.close_connection().await;

        Ok(())
    }))
}