vaultrs/
aws.rs

1pub mod config {
2
3    use crate::{
4        api::{
5            self,
6            aws::{
7                requests::{
8                    ConfigureLeaseRequest, GetConfigurationRequest, ReadLeaseRequest,
9                    RotateRootCredentialsRequest, SetConfigurationRequest,
10                    SetConfigurationRequestBuilder,
11                },
12                responses::{
13                    GetConfigurationResponse, ReadLeaseResponse, RotateRootCredentialsResponse,
14                },
15            },
16        },
17        client::Client,
18        error::ClientError,
19    };
20
21    /// Configures the root IAM credentials to communicate with AWS.
22    ///
23    /// See [SetConfigurationRequest]
24    pub async fn set(
25        client: &impl Client,
26        mount: &str,
27        access_key: &str,
28        secret_key: &str,
29        opts: Option<&mut SetConfigurationRequestBuilder>,
30    ) -> Result<(), ClientError> {
31        let mut t = SetConfigurationRequest::builder();
32        let endpoint = opts
33            .unwrap_or(&mut t)
34            .mount(mount)
35            .access_key(access_key)
36            .secret_key(secret_key)
37            .build()
38            .unwrap();
39
40        api::exec_with_empty(client, endpoint).await
41    }
42
43    pub async fn get(
44        client: &impl Client,
45        mount: &str,
46    ) -> Result<GetConfigurationResponse, ClientError> {
47        let e = GetConfigurationRequest::builder()
48            .mount(mount)
49            .build()
50            .unwrap();
51
52        api::exec_with_result(client, e).await
53    }
54
55    pub async fn rotate(
56        client: &impl Client,
57        mount: &str,
58    ) -> Result<RotateRootCredentialsResponse, ClientError> {
59        let endpoint = RotateRootCredentialsRequest::builder()
60            .mount(mount)
61            .build()
62            .unwrap();
63
64        api::exec_with_result(client, endpoint).await
65    }
66
67    /// Configures the root IAM credentials to communicate with AWS.
68    ///
69    /// See [SetConfigurationRequest]
70    pub async fn set_lease(
71        client: &impl Client,
72        mount: &str,
73        lease: &str,
74        lease_max: &str,
75    ) -> Result<(), ClientError> {
76        let endpoint = ConfigureLeaseRequest::builder()
77            .mount(mount)
78            .lease(lease)
79            .lease_max(lease_max)
80            .build()
81            .unwrap();
82
83        api::exec_with_empty(client, endpoint).await
84    }
85
86    pub async fn read_lease(
87        client: &impl Client,
88        mount: &str,
89    ) -> Result<ReadLeaseResponse, ClientError> {
90        let endpoint = ReadLeaseRequest::builder().mount(mount).build().unwrap();
91
92        api::exec_with_result(client, endpoint).await
93    }
94}
95
96pub mod roles {
97
98    use crate::{
99        api::{
100            self,
101            aws::{
102                requests::{
103                    CreateUpdateRoleRequest, CreateUpdateRoleRequestBuilder, DeleteRoleRequest,
104                    GenerateCredentialsRequest, GenerateCredentialsRequestBuilder,
105                    GenerateCredentialsStsRequest, GenerateCredentialsStsRequestBuilder,
106                    ListRolesRequest, ReadRoleRequest,
107                },
108                responses::{GenerateCredentialsResponse, ListRolesResponse, ReadRoleResponse},
109            },
110        },
111        client::Client,
112        error::ClientError,
113    };
114
115    pub async fn create_update(
116        client: &impl Client,
117        mount: &str,
118        name: &str,
119        credential_type: &str,
120        opts: Option<&mut CreateUpdateRoleRequestBuilder>,
121    ) -> Result<(), ClientError> {
122        let mut t = CreateUpdateRoleRequest::builder();
123        let endpoint = opts
124            .unwrap_or(&mut t)
125            .mount(mount)
126            .name(name)
127            .credential_type(credential_type)
128            .build()
129            .unwrap();
130
131        api::exec_with_empty(client, endpoint).await
132    }
133
134    pub async fn read(
135        client: &impl Client,
136        mount: &str,
137        name: &str,
138    ) -> Result<ReadRoleResponse, ClientError> {
139        let e = ReadRoleRequest::builder()
140            .mount(mount)
141            .name(name)
142            .build()
143            .unwrap();
144
145        api::exec_with_result(client, e).await
146    }
147
148    pub async fn delete(client: &impl Client, mount: &str, name: &str) -> Result<(), ClientError> {
149        let e = DeleteRoleRequest::builder()
150            .mount(mount)
151            .name(name)
152            .build()
153            .unwrap();
154
155        api::exec_with_empty(client, e).await
156    }
157
158    pub async fn list(client: &impl Client, mount: &str) -> Result<ListRolesResponse, ClientError> {
159        let e = ListRolesRequest::builder().mount(mount).build().unwrap();
160
161        api::exec_with_result(client, e).await
162    }
163
164    /// Generate credentials using /aws/creds endpoint
165    pub async fn credentials(
166        client: &impl Client,
167        mount: &str,
168        name: &str,
169        opts: Option<&mut GenerateCredentialsRequestBuilder>,
170    ) -> Result<GenerateCredentialsResponse, ClientError> {
171        let mut t = GenerateCredentialsRequest::builder();
172        let endpoint = opts
173            .unwrap_or(&mut t)
174            .mount(mount)
175            .name(name)
176            .build()
177            .unwrap();
178
179        api::exec_with_result(client, endpoint).await
180    }
181
182    /// Generate credentials using /aws/sts endpoint
183    pub async fn credentials_sts(
184        client: &impl Client,
185        mount: &str,
186        name: &str,
187        opts: Option<&mut GenerateCredentialsStsRequestBuilder>,
188    ) -> Result<GenerateCredentialsResponse, ClientError> {
189        let mut t = GenerateCredentialsStsRequest::builder();
190        let endpoint = opts
191            .unwrap_or(&mut t)
192            .mount(mount)
193            .name(name)
194            .build()
195            .unwrap();
196
197        api::exec_with_result(client, endpoint).await
198    }
199}
vaultrs/aws.rs

vaultrs/
aws.rs
