arcbox-cli 0.0.1-alpha.1

Command-line interface for ArcBox
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

//! ArcBox CLI - High-performance container and VM runtime.

use anyhow::Result;
use arcbox_cli::client;
use clap::Parser;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

mod commands;

use commands::{Cli, Commands};

#[tokio::main]
async fn main() -> Result<()> {
    let cli = Cli::parse();

    // Initialize logging based on debug flag
    let filter = if cli.debug {
        "arcbox=debug,arcbox_cli=debug"
    } else {
        "arcbox=info"
    };

    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| filter.into()),
        )
        .with(tracing_subscriber::fmt::layer().with_target(false))
        .init();

    match cli.command {
        Commands::Run(args) => commands::run::execute(args).await,
        Commands::Start(args) => commands::start::execute(args).await,
        Commands::Stop(args) => commands::stop::execute(args).await,
        Commands::Ps(args) => commands::ps::execute(args).await,
        Commands::Rm(args) => commands::rm::execute(args).await,
        Commands::Logs(args) => commands::logs::execute(args).await,
        Commands::Exec(args) => commands::exec::execute(args).await,
        Commands::Images(args) => commands::images::execute(args).await,
        Commands::Pull(args) => commands::pull::execute(args).await,
        Commands::Rmi(args) => commands::images::execute_rmi(args).await,
        Commands::Machine(cmd) => commands::machine::execute(cmd).await,
        Commands::Docker(cmd) => commands::docker::execute(cmd).await,
        Commands::Daemon(args) => commands::daemon::execute(args).await,
        Commands::Info => execute_info().await,
        Commands::Version => commands::version::execute().await,
    }
}

/// Display system-wide information.
async fn execute_info() -> Result<()> {
    println!("ArcBox Version: {}", env!("CARGO_PKG_VERSION"));
    println!("OS: {}", std::env::consts::OS);
    println!("Arch: {}", std::env::consts::ARCH);
    println!(
        "CPUs: {}",
        std::thread::available_parallelism()
            .map(|n| n.get())
            .unwrap_or(1)
    );

    // Try to connect to daemon for runtime info
    let daemon = client::DaemonClient::new();
    if daemon.is_running().await {
        // Get container count
        let containers: Vec<client::ContainerSummary> = daemon
            .get("/v1.43/containers/json?all=true")
            .await
            .unwrap_or_default();
        println!("Containers: {}", containers.len());

        // Get image count
        let images: Vec<client::ImageSummary> = daemon
            .get("/v1.43/images/json")
            .await
            .unwrap_or_default();
        println!("Images: {}", images.len());

        // TODO: Get machine count from gRPC API
        println!("Machines: 0");
    } else {
        println!("Containers: (daemon not running)");
        println!("Images: (daemon not running)");
        println!("Machines: (daemon not running)");
    }

    Ok(())
}