revoke-cli 0.3.0

Command-line interface for managing Revoke microservices infrastructure
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
117
118
119
120
121
122
123
124
125
126
127
128
129

use clap::{Parser, Subcommand};
use anyhow::Result;
use colored::Colorize;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

mod commands;
mod config;
mod utils;

use commands::*;

/// Revoke Framework CLI - Manage your microservices infrastructure
#[derive(Parser)]
#[command(author, version, about, long_about = None)]
#[command(propagate_version = true)]
struct Cli {
    /// Config file path
    #[arg(short, long, global = true, env = "REVOKE_CONFIG")]
    config: Option<String>,

    /// Verbosity level
    #[arg(short, long, global = true, action = clap::ArgAction::Count)]
    verbose: u8,

    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Manage services
    Service {
        #[command(subcommand)]
        command: ServiceCommands,
    },
    /// Manage configuration
    Config {
        #[command(subcommand)]
        command: ConfigCommands,
    },
    /// Manage gateway
    Gateway {
        #[command(subcommand)]
        command: GatewayCommands,
    },
    /// View traces
    Trace {
        #[command(subcommand)]
        command: TraceCommands,
    },
    /// Health check commands
    Health {
        #[command(subcommand)]
        command: HealthCommands,
    },
    /// Initialize a new Revoke project
    Init {
        /// Project name
        #[arg(default_value = "my-revoke-app")]
        name: String,
        /// Project template
        #[arg(short, long, default_value = "basic")]
        template: String,
    },
    /// Start development environment
    Dev {
        /// Services to start
        #[arg(short, long)]
        services: Vec<String>,
        /// Start all services
        #[arg(short, long)]
        all: bool,
    },
}

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

    // Initialize logging
    init_logging(cli.verbose);

    // Load configuration
    let config = config::load_config(cli.config.as_deref())?;

    // Execute command
    match cli.command {
        Commands::Service { command } => {
            service::handle_command(command, &config).await?
        }
        Commands::Config { command } => {
            commands::config::handle_command(command, &config).await?
        }
        Commands::Gateway { command } => {
            gateway::handle_command(command, &config).await?
        }
        Commands::Trace { command } => {
            trace::handle_command(command, &config).await?
        }
        Commands::Health { command } => {
            health::handle_command(command, &config).await?
        }
        Commands::Init { name, template } => {
            init::handle_init(&name, &template).await?
        }
        Commands::Dev { services, all } => {
            dev::handle_dev(services, all, &config).await?
        }
    }

    Ok(())
}

fn init_logging(verbosity: u8) {
    let filter = match verbosity {
        0 => "warn",
        1 => "info",
        2 => "debug",
        _ => "trace",
    };

    tracing_subscriber::registry()
        .with(tracing_subscriber::EnvFilter::try_from_default_env()
            .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new(filter)))
        .with(tracing_subscriber::fmt::layer()
            .with_target(false)
            .with_thread_ids(false))
        .init();
}