covert 0.1.3

Covert CLI
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

use std::time::Duration;

use clap::{Args, Subcommand};
use covert_sdk::{
    psql::{CreateRoleParams, SetConnectionParams},
    Client,
};

use crate::handle_resp;

#[derive(Args, Debug)]
pub struct Psql {
    #[clap(subcommand)]
    subcommand: PsqlSubcommand,
}

#[derive(Subcommand, Debug)]
pub enum PsqlSubcommand {
    #[command(about = "set connection config")]
    SetConnection {
        #[arg(help = "path where PSQL engine is mounted")]
        path: String,
        #[arg(long)]
        connection_url: String,
    },
    #[command(about = "read connection config")]
    Connection {
        #[arg(help = "path where PSQL engine is mounted")]
        path: String,
    },
    #[command(about = "create credentials for a role")]
    Creds {
        #[arg(short, long, help = "role to generate credentials for")]
        name: String,
        #[arg(short, long, help = "path to the psql secrets engine mount")]
        path: String,
        #[arg(long, help = "time to live for credentials")]
        ttl: Option<humantime::Duration>,
    },
    #[command(about = "add a role")]
    AddRole {
        #[arg(short, long, help = "name of role to create")]
        name: String,
        #[arg(short, long)]
        path: String,
        #[arg(long)]
        sql: String,
        #[arg(long)]
        revocation_sql: String,
    },
}

impl Psql {
    pub async fn handle(self, sdk: &Client) {
        match self.subcommand {
            PsqlSubcommand::SetConnection {
                connection_url,
                path,
            } => {
                let resp = sdk
                    .psql
                    .set_connection(
                        &path,
                        &SetConnectionParams {
                            connection_url,
                            verify_connection: true,
                            max_open_connections: None,
                        },
                    )
                    .await;
                handle_resp(resp);
            }
            PsqlSubcommand::Connection { path } => {
                let resp = sdk.psql.read_connection(&path).await;
                handle_resp(resp);
            }
            PsqlSubcommand::Creds { name, path, ttl } => {
                let ttl = ttl.map(|ttl| Duration::from_millis(ttl.as_millis() as u64));
                let resp = sdk.psql.create_credentials(&path, &name, ttl).await;
                handle_resp(resp);
            }
            PsqlSubcommand::AddRole {
                name,
                path,
                sql,
                revocation_sql,
            } => {
                let resp = sdk
                    .psql
                    .create_role(
                        &path,
                        &name,
                        &CreateRoleParams {
                            sql,
                            revocation_sql,
                        },
                    )
                    .await;
                handle_resp(resp);
            }
        }
    }
}