vaultrs 0.8.0

An asynchronous Rust client library for the Hashicorp Vault API.
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

use crate::{
    api::{
        self,
        identity::group_alias::{
            requests::{
                CreateGroupAliasRequest, CreateGroupAliasRequestBuilder,
                DeleteGroupAliasByIdRequest, ListGroupAliasesByIdRequest,
                ReadGroupAliasByIdRequest, UpdateGroupAliasByIdRequest,
                UpdateGroupAliasByIdRequestBuilder,
            },
            responses::{
                CreateGroupAliasResponse, ListGroupAliasesByIdResponse, ReadGroupAliasByIdResponse,
            },
        },
    },
    client::Client,
    error::ClientError,
};

pub async fn create(
    client: &impl Client,
    name: &str,
    mount_accessor: &str,
    opts: Option<&mut CreateGroupAliasRequestBuilder>,
) -> Result<CreateGroupAliasResponse, ClientError> {
    let mut t = CreateGroupAliasRequest::builder();
    let endpoint = opts
        .unwrap_or(&mut t)
        .name(name)
        .mount_accessor(mount_accessor)
        .build()
        .unwrap();
    api::exec_with_result(client, endpoint)
        .await
        .map_err(|err| {
            // In the case the response as an empty HTTP Body
            if matches!(
                err,
                ClientError::RestClientError {
                    source: rustify::errors::ClientError::ResponseParseError { .. }
                }
            ) {
                return ClientError::InvalidUpdateParameter;
            }
            err
        })
}

/// Reads group alias by `id`.
///
/// See [ReadGroupAliasByIdRequest]
pub async fn read_by_id(
    client: &impl Client,
    id: &str,
) -> Result<ReadGroupAliasByIdResponse, ClientError> {
    let endpoint = ReadGroupAliasByIdRequest::builder().id(id).build().unwrap();

    api::exec_with_result(client, endpoint).await
}

/// Update group alias by `id`.
///
/// See [UpdateGroupAliasByIdRequest]
pub async fn update_by_id(
    client: &impl Client,
    id: &str,
    mount_accessor: &str,
    opts: Option<&mut UpdateGroupAliasByIdRequestBuilder>,
) -> Result<(), ClientError> {
    let mut t = UpdateGroupAliasByIdRequest::builder();
    let endpoint = opts
        .unwrap_or(&mut t)
        .id(id)
        .mount_accessor(mount_accessor)
        .build()
        .unwrap();
    api::exec_with_empty(client, endpoint).await
}

/// Delete group alias by `id`.
///
/// See [DeleteGroupAliasByIdRequest]
pub async fn delete_by_id(client: &impl Client, id: &str) -> Result<(), ClientError> {
    let endpoint = DeleteGroupAliasByIdRequest::builder()
        .id(id)
        .build()
        .unwrap();
    api::exec_with_empty(client, endpoint).await
}

/// List groups aliases by ID.
///
/// See [ListGroupAliasesByIdRequest]
pub async fn list_by_id(client: &impl Client) -> Result<ListGroupAliasesByIdResponse, ClientError> {
    let endpoint = ListGroupAliasesByIdRequest::builder().build().unwrap();
    api::exec_with_result(client, endpoint).await
}