lumina_cli/
common.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
use std::env::current_exe;

use anyhow::Result;
use clap::{Parser, ValueEnum};
use lumina_node::network::Network;

use crate::native;
#[cfg(feature = "browser-node")]
use crate::server;

#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, ValueEnum)]
pub(crate) enum ArgNetwork {
    #[default]
    Mainnet,
    Arabica,
    Mocha,
    Private,
}

#[derive(Debug, Parser)]
pub(crate) enum CliArgs {
    /// Run native node locally
    Node(native::Params),
    /// Serve compiled wasm node to be run in the browser
    #[cfg(feature = "browser-node")]
    Browser(server::Params),
}

/// Run the Lumina node.
pub async fn run() -> Result<()> {
    let _ = dotenvy::dotenv();

    let args = if current_exe()?
        .file_name()
        .unwrap_or_default()
        .to_string_lossy()
        == "lumina-node"
    {
        CliArgs::Node(native::Params::parse())
    } else {
        CliArgs::parse()
    };

    let _guard = init_tracing();

    match args {
        CliArgs::Node(args) => native::run(args).await,
        #[cfg(feature = "browser-node")]
        CliArgs::Browser(args) => server::run(args).await,
    }
}

fn init_tracing() -> tracing_appender::non_blocking::WorkerGuard {
    let (non_blocking, guard) = tracing_appender::non_blocking(std::io::stdout());

    let filter = tracing_subscriber::EnvFilter::builder()
        .with_default_directive(tracing_subscriber::filter::LevelFilter::INFO.into())
        .from_env_lossy();

    tracing_subscriber::fmt()
        .with_env_filter(filter)
        .with_writer(non_blocking)
        .init();

    guard
}

impl From<ArgNetwork> for Network {
    fn from(network: ArgNetwork) -> Network {
        match network {
            ArgNetwork::Mainnet => Network::Mainnet,
            ArgNetwork::Arabica => Network::Arabica,
            ArgNetwork::Mocha => Network::Mocha,
            ArgNetwork::Private => Network::Private,
        }
    }
}

impl From<Network> for ArgNetwork {
    fn from(network: Network) -> ArgNetwork {
        match network {
            Network::Mainnet => ArgNetwork::Mainnet,
            Network::Arabica => ArgNetwork::Arabica,
            Network::Mocha => ArgNetwork::Mocha,
            Network::Private => ArgNetwork::Private,
        }
    }
}