umadb 0.3.3

Event store built for Dynamic Consistency Boundaries
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
114
115
116

use clap::{CommandFactory, FromArgMatches, Parser};
use tokio::signal;
use tokio::sync::oneshot;
use umadb_server::{
    start_server, start_server_secure_from_files, start_server_secure_from_files_with_api_key,
    start_server_with_api_key, uptime,
};

#[allow(dead_code)]
const BANNER_BIG: &str = r#"
  _    _                 _____  ____
 | |  | |               |  __ \|  _ \
 | |  | |_ __ ___   __ _| |  | | |_) |
 | |  | | '_ ` _ \ / _` | |  | |  _ <
 | |__| | | | | | | (_| | |__| | |_) |
  \____/|_| |_| |_|\__,_|_____/|____/ "#;

const BANNER: &str = BANNER_BIG;

#[derive(Parser, Debug)]
#[command(version)]
struct Args {
    /// Address to bind to
    #[arg(long = "listen", default_value = "127.0.0.1:50051")]
    listen: String,

    /// Path to database file or directory
    #[arg(long = "db-path", default_value = "./uma.db")]
    db_path: String,

    /// Path to server TLS certificate (PEM), optional
    #[arg(long = "tls-cert", required = false)]
    cert: Option<String>,

    /// Path to server TLS private key (PEM), optional
    #[arg(long = "tls-key", required = false)]
    key: Option<String>,

    /// API key for authenticating clients, optional
    #[arg(long = "api-key", required = false)]
    api_key: Option<String>,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let _ = uptime();
    let rt = tokio::runtime::Builder::new_multi_thread()
        .worker_threads(
            std::thread::available_parallelism()
                .map(|n| n.get())
                .unwrap_or(4),
        )
        .max_blocking_threads(2048)
        .enable_all()
        .build()?;

    rt.block_on(async_main())
}

async fn async_main() -> Result<(), Box<dyn std::error::Error>> {
    let mut cmd = Args::command();
    cmd = cmd.about(format!(
        "UmaDB gRPC server ({}-{})",
        std::env::consts::OS,
        std::env::consts::ARCH
    ));

    let matches = cmd.get_matches();
    let args = Args::from_arg_matches(&matches)?; // <-- FromArgMatches trait

    let cert = args.cert.or_else(|| std::env::var("UMADB_TLS_CERT").ok());
    let key = args.key.or_else(|| std::env::var("UMADB_TLS_KEY").ok());
    let api_key = args.api_key.or_else(|| std::env::var("UMADB_API_KEY").ok());

    let (tx, rx) = oneshot::channel::<()>();
    tokio::spawn(async move {
        let _ = signal::ctrl_c().await;
        let _ = tx.send(());
    });

    // println!("{}", BANNER);
    // println!("v{}", env!("CARGO_PKG_VERSION"));
    // let mut rng = rng();
    // let banner = BANNERS.choose(&mut rng).unwrap();
    let banner = BANNER;
    println!("{}  v{}", banner, env!("CARGO_PKG_VERSION"));
    println!();

    match (cert, key, api_key) {
        (Some(cert), Some(key), Some(api_key)) => {
            start_server_secure_from_files_with_api_key(
                args.db_path,
                &args.listen,
                rx,
                cert,
                key,
                api_key,
            )
            .await?
        }
        (Some(cert), Some(key), None) => {
            start_server_secure_from_files(args.db_path, &args.listen, rx, cert, key).await?
        }
        (None, None, Some(api_key)) => {
            start_server_with_api_key(args.db_path, &args.listen, rx, api_key).await?
        }
        (None, None, None) => start_server(args.db_path, &args.listen, rx).await?,
        _ => {
            eprintln!(
                "Both --tls-cert and --tls-key (or UMADB_TLS_CERT and UMADB_TLS_KEY) must be provided for TLS"
            );
            std::process::exit(2);
        }
    }

    Ok(())
}