ockam_api 0.93.0

Ockam's request-response API
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use crate::cli_state::NamedIdentity;
use ockam::identity::Identifier;
use ockam_core::async_trait;
use ockam_core::Result;
use ockam_node::database::AutoRetry;
use ockam_node::retry;

/// The identities repository stores metadata about identities
/// which change history have been stored in the ChangeHistoryRepository.
///
/// It allows to:
///
///  - associate a user name to an identity
///  - set one (and one only) identity as the default identity
///  - associate a vault name to an identity so that we know where the identity private keys can be found
///
/// By default the get/delete functions use the identity name as a parameter.
/// When they use the identity identifier instead, this is indicated in the function name:
/// e.g. get_named_identity_by_identifier()
///
#[async_trait]
pub trait IdentitiesRepository: Send + Sync + 'static {
    /// Associate a name to an identity
    async fn store_named_identity(
        &self,
        identifier: &Identifier,
        name: &str,
        vault_name: &str,
    ) -> Result<NamedIdentity>;

    /// Delete an identity given its name and return its identifier
    async fn delete_identity(&self, name: &str) -> Result<Option<Identifier>>;

    /// Delete an identity given its identifier and return its name
    async fn delete_identity_by_identifier(
        &self,
        identifier: &Identifier,
    ) -> Result<Option<String>>;

    /// Update a named identity name
    async fn update_name(&self, identifier: &Identifier, name: &str) -> Result<()>;

    /// Return the identifier associated to a named identity
    async fn get_identifier(&self, name: &str) -> Result<Option<Identifier>>;

    /// Return the name associated to an identifier
    async fn get_identity_name_by_identifier(
        &self,
        identifier: &Identifier,
    ) -> Result<Option<String>>;

    /// Return the named identity with a specific name
    async fn get_named_identity(&self, name: &str) -> Result<Option<NamedIdentity>>;

    /// Return the named identity associated to an identifier
    async fn get_named_identity_by_identifier(
        &self,
        identifier: &Identifier,
    ) -> Result<Option<NamedIdentity>>;

    /// Return identities which have been given a name
    async fn get_named_identities(&self) -> Result<Vec<NamedIdentity>>;

    /// Return identities which have been given a name, and are using a specific vault
    async fn get_named_identities_by_vault_name(
        &self,
        vault_name: &str,
    ) -> Result<Vec<NamedIdentity>>;

    /// Set an identity as the default one, given its name
    async fn set_as_default(&self, name: &str) -> Result<()>;

    /// Set an identity as the default one, given its identifier
    async fn set_as_default_by_identifier(&self, identifier: &Identifier) -> Result<()>;

    /// Return the default named identity
    async fn get_default_named_identity(&self) -> Result<Option<NamedIdentity>>;
}

#[async_trait]
impl<T: IdentitiesRepository + Send + Sync + 'static> IdentitiesRepository for AutoRetry<T> {
    async fn store_named_identity(
        &self,
        identifier: &Identifier,
        name: &str,
        vault_name: &str,
    ) -> Result<NamedIdentity> {
        retry!(self
            .wrapped
            .store_named_identity(identifier, name, vault_name))
    }

    async fn delete_identity(&self, name: &str) -> Result<Option<Identifier>> {
        retry!(self.wrapped.delete_identity(name))
    }

    async fn delete_identity_by_identifier(
        &self,
        identifier: &Identifier,
    ) -> Result<Option<String>> {
        retry!(self.wrapped.delete_identity_by_identifier(identifier))
    }

    async fn update_name(&self, identifier: &Identifier, name: &str) -> Result<()> {
        retry!(self.wrapped.update_name(identifier, name))
    }

    async fn get_identifier(&self, name: &str) -> Result<Option<Identifier>> {
        retry!(self.wrapped.get_identifier(name))
    }

    async fn get_identity_name_by_identifier(
        &self,
        identifier: &Identifier,
    ) -> Result<Option<String>> {
        retry!(self.wrapped.get_identity_name_by_identifier(identifier))
    }

    async fn get_named_identity(&self, name: &str) -> Result<Option<NamedIdentity>> {
        retry!(self.wrapped.get_named_identity(name))
    }

    async fn get_named_identity_by_identifier(
        &self,
        identifier: &Identifier,
    ) -> Result<Option<NamedIdentity>> {
        retry!(self.wrapped.get_named_identity_by_identifier(identifier))
    }

    async fn get_named_identities(&self) -> Result<Vec<NamedIdentity>> {
        retry!(self.wrapped.get_named_identities())
    }

    async fn get_named_identities_by_vault_name(
        &self,
        vault_name: &str,
    ) -> Result<Vec<NamedIdentity>> {
        retry!(self.wrapped.get_named_identities_by_vault_name(vault_name))
    }

    async fn set_as_default(&self, name: &str) -> Result<()> {
        retry!(self.wrapped.set_as_default(name))
    }

    async fn set_as_default_by_identifier(&self, identifier: &Identifier) -> Result<()> {
        retry!(self.wrapped.set_as_default_by_identifier(identifier))
    }

    async fn get_default_named_identity(&self) -> Result<Option<NamedIdentity>> {
        retry!(self.wrapped.get_default_named_identity())
    }
}