homestar-runtime 0.3.0

Homestar runtime 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

use clap::Parser;
use homestar_runtime::{
    cli::{handle_init_command, Cli, Command, ConsoleTable},
    daemon,
    db::Database,
    runner::response,
    Db, FileLogger, Logger, Runner, Settings,
};
use miette::{miette, Result};
use tracing::info;

fn main() -> Result<()> {
    let cli = Cli::parse();

    match cli.command {
        Command::Init(init_args) => handle_init_command(init_args)?,
        Command::Start {
            runtime_config,
            daemonize,
            daemon_dir,
            database_url,
        } => {
            // Load settings first, so we can daemonize before starting the
            // runtime.
            let settings = if let Some(file) = runtime_config {
                Settings::load_from_file(file)
            } else {
                Settings::load()
            }
            .expect("runtime settings to be loaded");

            let _guard = if daemonize {
                daemon::start(daemon_dir.clone())
                    .expect("runner to be started as a daemon process");
                FileLogger::init(daemon_dir, settings.node().monitoring())
            } else {
                Logger::init(settings.node().monitoring())
            };

            info!(
                subject = "settings",
                category = "homestar.init",
                "starting with settings: {:?}",
                settings,
            );

            let db = Db::setup_connection_pool(settings.node(), database_url)
                .expect("to setup database pool");

            info!(
                subject = "database",
                category = "homestar.init",
                "starting with database: {}",
                Db::url().expect("database url to be provided"),
            );

            info!("starting Homestar runtime...");
            Runner::start(settings, db).expect("Failed to start runtime")
        }
        Command::Info => {
            let response = response::Info::default();
            response
                .echo_table()
                .map_err(|_| miette!("failed to extract binary information"))?
        }
        cmd => cmd.handle_rpc_command()?,
    }
    Ok(())
}