bitsrun 0.1.0

A headless login and logout CLI app for 10.0.0.55 at BIT
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
130
131
132
133

mod cli;
mod client;
mod tables;
mod user;
mod xencode;

use anyhow::Context;
use anyhow::Result;
use cli::Arguments;
use cli::Commands;
use client::get_login_state;
use client::SrunClient;
use owo_colors::OwoColorize;

use clap::Parser;
use tables::print_config_paths;
use tables::print_login_state;

#[tokio::main]
async fn main() {
    if let Err(err) = cli().await {
        eprintln!("{} {} {}", "bitsrun:".bright_red(), "[error]".dimmed(), err);
        std::process::exit(1);
    }
}

async fn cli() -> Result<()> {
    let args = Arguments::parse();

    // reusable http client
    let http_client = reqwest::Client::new();

    // commands
    match &args.command {
        // check login status
        Some(Commands::Status(status_args)) => {
            let login_state = get_login_state(&http_client).await?;

            // output json
            if status_args.json {
                let raw_json = serde_json::to_string(&login_state)?;
                println!("{}", raw_json);
                return Ok(());
            }

            // output human readable
            if login_state.error == "ok" {
                println!(
                    "{} {} {} is online",
                    "bitsrun:".bright_green(),
                    &login_state.online_ip.to_string().underline(),
                    format!("({})", login_state.user_name.clone().unwrap_or_default()).dimmed()
                );

                // print status table
                print_login_state(login_state);
            } else {
                println!(
                    "{} {} is offline",
                    "bitsrun:".blue(),
                    login_state.online_ip.to_string().underline()
                );
            }
        }

        // login or logout
        Some(Commands::Login(client_args)) | Some(Commands::Logout(client_args)) => {
            let bit_user = user::get_bit_user(
                &client_args.username,
                &client_args.password,
                &client_args.config,
            )
            .with_context(|| "unable to parse user credentials")?;

            let srun_client = SrunClient::new(
                bit_user.username,
                bit_user.password,
                Some(http_client),
                client_args.ip,
            )
            .await?;

            if let Some(Commands::Login(_)) = &args.command {
                let resp = srun_client.login().await?;
                match resp.error.as_str() {
                    "ok" => println!(
                        "{} {} {} logged in",
                        "bitsrun:".bright_green(),
                        resp.online_ip.to_string().underline(),
                        format!("({})", resp.username.clone().unwrap_or_default()).dimmed()
                    ),
                    _ => println!(
                        "{} failed to login, {} {}",
                        "bitsrun:".red(),
                        resp.error,
                        format!("({})", resp.error_msg).dimmed()
                    ),
                }

                if args.verbose {
                    let pretty_json = serde_json::to_string_pretty(&resp)?;
                    println!("{} response from API\n{}", "bitsrun:".blue(), pretty_json);
                }
            } else if let Some(Commands::Logout(_)) = &args.command {
                let resp = srun_client.logout().await?;
                match resp.error.as_str() {
                    "ok" => println!(
                        "{} {} logged out",
                        "bitsrun:".green(),
                        resp.online_ip.to_string().underline()
                    ),
                    _ => println!(
                        "{} failed to logout, {} {}",
                        "bitsrun:".red(),
                        resp.error,
                        format!("({})", resp.error_msg).dimmed()
                    ),
                }

                if args.verbose {
                    let pretty_json = serde_json::to_string_pretty(&resp)?;
                    println!("{} response from API\n{}", "bitsrun:".blue(), pretty_json);
                }
            }
        }

        Some(Commands::ConfigPaths) => print_config_paths(),

        None => {}
    }

    Ok(())
}