lgtm-cli 0.1.0

Run LGTM code reviews with a bundled web UI and gRPC server.
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

use clap::{Args, Parser, Subcommand};

#[path = "../bundle/backend.rs"]
pub mod backend;
mod daemon;
mod log;
mod server;
mod store;
mod ui;

// types -----------------------------------------------------------------------

/// Run LGTM with a bundled web UI and gRPC server.
#[derive(Parser)]
#[command(name = "lgtm", version, about)]
struct Cli {
    #[command(subcommand)]
    command: Command,
}

#[derive(Subcommand)]
enum Command {
    /// Start the UI and gRPC server in the background.
    Up(Up),
    /// Stop the background server.
    Down,
    /// Show whether the server is running.
    Status {
        /// Print server discovery information as JSON.
        #[arg(long)]
        json: bool,
    },
    /// Open the current directory in the web interface.
    Review {
        /// Server port when starting a new instance (0 selects a free port).
        #[arg(long, default_value_t = 8080)]
        port: u16,
        /// Print the review URL without opening a browser.
        #[arg(long)]
        no_open: bool,
    },
    #[command(hide = true)]
    Serve {
        #[arg(long, default_value_t = 8080)]
        port: u16,
        #[arg(long)]
        daemonize: bool,
    },
}

#[derive(Args)]
struct Up {
    /// Local port for both the UI and RPC API (0 selects a free port).
    #[arg(long, default_value_t = 8080)]
    port: u16,
    /// Run in this terminal instead of starting a background process.
    #[arg(long)]
    foreground: bool,
    /// Start without opening a browser.
    #[arg(long)]
    no_open: bool,
}

// api -------------------------------------------------------------------------

fn main() -> anyhow::Result<()> {
    let cli = Cli::parse();
    let store = store::Store::new()?;
    // Fork only in the fresh server process, before starting Tokio threads.
    if let Command::Serve {
        daemonize: true, ..
    } = cli.command
    {
        daemon::detach(&store)?;
    }
    if matches!(cli.command, Command::Serve { .. })
        || matches!(&cli.command, Command::Up(options) if options.foreground)
    {
        log::init(&store)?;
    }
    tokio::runtime::Runtime::new()?.block_on(async {
        match cli.command {
            Command::Up(options) if options.foreground => {
                server::serve(options.port, &store, false).await
            }
            Command::Up(options) => daemon::up(options.port, !options.no_open, &store).await,
            Command::Down => daemon::down(&store).await,
            Command::Status { json } => daemon::status(&store, json).await,
            Command::Review { port, no_open } => {
                ui::open_review_ui_at_path(&std::env::current_dir()?, port, !no_open, &store).await
            }
            Command::Serve { port, daemonize } => server::serve(port, &store, daemonize).await,
        }
    })
}