homeboy 0.50.1

CLI for multi-component deployment and development workflow automation
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
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

use clap::{Args, Subcommand};
use serde::Serialize;
use std::collections::HashMap;

use homeboy::auth::{self, AuthStatus, LoginResult, LogoutResult};

use super::{CmdResult, GlobalArgs};
use crate::tty::{prompt, prompt_password};

#[derive(Args)]
pub struct AuthArgs {
    #[command(subcommand)]
    command: AuthCommand,
}

#[derive(Subcommand)]
enum AuthCommand {
    /// Authenticate with a project's API
    Login {
        /// Project ID
        #[arg(long)]
        project: String,

        /// Username or email
        #[arg(long)]
        identifier: Option<String>,

        /// Password (or read from stdin)
        #[arg(long)]
        password: Option<String>,
    },

    /// Clear stored authentication for a project
    Logout {
        /// Project ID
        #[arg(long)]
        project: String,
    },

    /// Show authentication status for a project
    Status {
        /// Project ID
        #[arg(long)]
        project: String,
    },
}

#[derive(Serialize)]
#[serde(untagged)]
pub enum AuthOutput {
    Login(LoginResult),
    Logout(LogoutResult),
    Status(AuthStatus),
}

pub fn run(args: AuthArgs, _global: &GlobalArgs) -> CmdResult<AuthOutput> {
    match args.command {
        AuthCommand::Login {
            project,
            identifier,
            password,
        } => run_login(&project, identifier, password),
        AuthCommand::Logout { project } => run_logout(&project),
        AuthCommand::Status { project } => run_status(&project),
    }
}

fn run_login(
    project_id: &str,
    identifier: Option<String>,
    password: Option<String>,
) -> CmdResult<AuthOutput> {
    let identifier = match identifier {
        Some(id) => id,
        None => prompt("Username/Email: ")?,
    };

    let password = match password {
        Some(pw) => pw,
        None => prompt_password("Password: ")?,
    };

    let mut credentials = HashMap::new();
    credentials.insert("identifier".to_string(), identifier);
    credentials.insert("password".to_string(), password);

    let result = auth::login(project_id, credentials)?;
    Ok((AuthOutput::Login(result), 0))
}

fn run_logout(project_id: &str) -> CmdResult<AuthOutput> {
    let result = auth::logout(project_id)?;
    Ok((AuthOutput::Logout(result), 0))
}

fn run_status(project_id: &str) -> CmdResult<AuthOutput> {
    let result = auth::status(project_id)?;
    Ok((AuthOutput::Status(result), 0))
}