amaru 0.1.2

A Cardano blockchain node implementation
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

// Copyright 2024 PRAGMA
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use amaru::{
    observability::{Color, setup_observability},
    panic::panic_handler,
};
use clap::{Parser, Subcommand};
use tracing::info;

mod cmd;

#[derive(Debug, Subcommand)]
enum Command {
    /// Syncs the ledger with local blocks.
    ///
    /// The ledger state must be in an already bootstrapped state (e.g. via amaru snapshots).
    Sync(cmd::sync::Args),

    #[cfg(feature = "mithril")]
    Mithril(cmd::mithril::Args),
}
#[derive(Debug, Parser)]
#[clap(name = "Amaru Ledger")]
#[clap(bin_name = "amaru-ledger")]
#[clap(author, version, about, long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Command,

    #[clap(long, action, env("AMARU_WITH_OPEN_TELEMETRY"))]
    with_open_telemetry: bool,

    #[clap(long, action, env("AMARU_WITH_JSON_TRACES"))]
    with_json_traces: bool,

    #[clap(long, action, env("AMARU_COLOR"))]
    color: Option<Color>,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    panic_handler();

    let args = Cli::parse();

    info!(
        with_open_telemetry = args.with_open_telemetry,
        with_json_traces = args.with_json_traces,
        "Started with global arguments"
    );

    let (_metrics, teardown) =
        setup_observability(args.with_open_telemetry, args.with_json_traces, Color::is_enabled(args.color));

    let result = match args.command {
        Command::Sync(args) => cmd::sync::run(args).await,
        #[cfg(feature = "mithril")]
        Command::Mithril(args) => cmd::mithril::run(args).await,
    };

    // TODO: we might also want to integrate this into a graceful shutdown system, and into a panic hook
    if let Err(report) = teardown() {
        eprintln!("Failed to teardown tracing: {report}");
    }

    result
}