secpar 0.1.1

A tool that leverages AWS Rust SDK for Secrets Manager & Parameter Store
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use crate::errors::SecParError;
use crate::opt::SecCommand;
use aws_sdk_secretsmanager::{Client, Region};
use color_eyre::eyre::eyre;
use color_eyre::Report;
use tracing::{debug, info};

/// list all secrets
pub async fn list_secrets(client: &Client) -> Result<(), SecParError> {
    match client.list_secrets().send().await {
        Ok(output) => {
            info!("Got secrets:");
            println!("Got secrets:");
            let secrets = output.secret_list().unwrap_or_default();
            for secret in secrets {
                info!("  {}", secret.name().unwrap_or("No name!"));
                println!("  {}", secret.name().unwrap_or("No name!"));
            }
            Ok(())
        }
        Err(e) => {
            debug!("Error: {:?}", e.to_string());
            Err(SecParError::NotFound(e.to_string()))
        }
    }
}

/// describe a secret in details:
/// https://docs.rs/aws-sdk-secretsmanager/0.16.0/aws_sdk_secretsmanager/output/struct.DescribeSecretOutput.html
pub async fn describe_secret(client: &Client, name: &str) -> Result<(), SecParError> {
    match client.describe_secret().secret_id(name).send().await {
        Ok(output) => {
            info!("Secret[{}] Details: ", name);
            info!("{:?}", output);
            Ok(())
        }
        Err(e) => {
            debug!("Error: {:?}", e.to_string());
            Err(SecParError::NotFound(name.to_string()))
        }
    }
}

/// delete the specified secret
pub async fn delete_secret(client: &Client, name: &str) -> Result<(), SecParError> {
    match client.delete_secret().secret_id(name).send().await {
        Ok(output) => {
            info!("To be deleted secret: {}", name);
            info!("{:?}", output);
            Ok(())
        }
        Err(e) => {
            debug!("Error: {:?}", e.to_string());
            Err(SecParError::NotFound(name.to_string()))
        }
    }
}

/// get a secret from secret manager
pub async fn retrieve_secret(client: &Client, name: &str) -> Result<String, SecParError> {
    match client.get_secret_value().secret_id(name).send().await {
        Ok(output) => {
            //debug!("Value: {}", output.secret_string().unwrap());
            Ok(output.secret_string().unwrap().to_owned())
        }
        Err(e) => {
            debug!("Error: {:?}", e.to_string());
            Err(SecParError::NotFound(e.to_string()))
        }
    }
}

/// create a secret in secrets manager
pub async fn save_secret(client: &Client, name: &str, secret: &str) -> Result<String, SecParError> {
    match client
        .create_secret()
        .name(name)
        .secret_string(secret)
        .send()
        .await
    {
        Ok(output) => {
            debug!("Value: {}", output.arn().unwrap());
            Ok(output.arn().unwrap().to_owned())
        }
        Err(e) => {
            debug!("Error: {:?}", e.to_string());
            Err(SecParError::CreateFail(e.to_string()))
        }
    }
}

/// secret subcommand processing
pub async fn process_sec_command(command: &SecCommand) -> Result<(), Report> {
    let region_provider = Region::new("us-east-1");
    let shared_config = aws_config::from_env().region(region_provider).load().await;
    let client = Client::new(&shared_config);
    match command {
        SecCommand::List {} => {
            info!("List All Secrets...");
            list_secrets(&client).await?;
        }
        SecCommand::Get { name } => match retrieve_secret(&client, &name).await {
            Ok(secret) => {
                info!("Got Secret:");
                info!("  {}", secret);
            }
            Err(_) => {
                return Err(eyre!("Failed to retrieve secret"));
            }
        },
        SecCommand::Describe { name } => {
            describe_secret(&client, name).await?;
        }
        SecCommand::Create { name, secret } => {
            save_secret(&client, &name, &secret).await?;
        }
        SecCommand::Delete { name } => {
            delete_secret(&client, name).await?;
        }
    }
    Ok(())
}