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

use crate::cli_state::NodeInfo;
use crate::config::lookup::InternetAddress;
use ockam::identity::Identifier;
use ockam_core::async_trait;
use ockam_core::Result;
use ockam_node::database::AutoRetry;
use ockam_node::retry;

/// This trait supports the storage of node data:
///
///  - a node has a unique name
///  - a node is always associated to an identifier
///  - a node can be associated to a (single) project
///  - when a node is running we can persist its process id and its TCP listener address
///  - one of the nodes is always set as the default node
///  - a node can be set as an authority node. The purpose of this flag is to be able to display
///    the node status without being able to start a TCP connection since the TCP listener might not be accessible
///
#[async_trait]
pub trait NodesRepository: Send + Sync + 'static {
    /// Store or update the information about a node
    async fn store_node(&self, node_info: &NodeInfo) -> Result<()>;

    /// Get the list of all the nodes
    async fn get_nodes(&self) -> Result<Vec<NodeInfo>>;

    /// Get a node by name
    async fn get_node(&self, node_name: &str) -> Result<Option<NodeInfo>>;

    /// Get the nodes using a given identifier
    async fn get_nodes_by_identifier(&self, identifier: &Identifier) -> Result<Vec<NodeInfo>>;

    /// Get the node set as default
    async fn get_default_node(&self) -> Result<Option<NodeInfo>>;

    /// Set a node set the default node
    async fn set_default_node(&self, node_name: &str) -> Result<()>;

    /// Return true if a node with the given name is the default node
    async fn is_default_node(&self, node_name: &str) -> Result<bool>;

    /// Delete a node given its name
    async fn delete_node(&self, node_name: &str) -> Result<()>;

    /// Set the TCP listener of a node
    async fn set_tcp_listener_address(
        &self,
        node_name: &str,
        address: &InternetAddress,
    ) -> Result<()>;

    /// Set the status endpoint address of a node
    async fn set_status_endpoint_address(
        &self,
        node_name: &str,
        address: &InternetAddress,
    ) -> Result<()>;

    /// Set that node as an authority node
    async fn set_as_authority_node(&self, node_name: &str) -> Result<()>;

    /// Get the TCP listener of a node
    async fn get_tcp_listener_address(&self, node_name: &str) -> Result<Option<InternetAddress>>;

    /// Get the address of the status endpoint of a node
    async fn get_status_endpoint_address(&self, node_name: &str)
        -> Result<Option<InternetAddress>>;

    /// Set the process id of a node
    async fn set_node_pid(&self, node_name: &str, pid: u32) -> Result<()>;

    /// Unset the process id of a node
    async fn set_no_node_pid(&self, node_name: &str) -> Result<()>;
}

#[async_trait]
impl<T: NodesRepository> NodesRepository for AutoRetry<T> {
    async fn store_node(&self, node_info: &NodeInfo) -> Result<()> {
        retry!(self.wrapped.store_node(node_info))
    }

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

    async fn get_node(&self, node_name: &str) -> Result<Option<NodeInfo>> {
        retry!(self.wrapped.get_node(node_name))
    }

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

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

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

    async fn is_default_node(&self, node_name: &str) -> Result<bool> {
        retry!(self.wrapped.is_default_node(node_name))
    }

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

    async fn set_tcp_listener_address(
        &self,
        node_name: &str,
        address: &InternetAddress,
    ) -> Result<()> {
        retry!(self.wrapped.set_tcp_listener_address(node_name, address))
    }

    async fn set_status_endpoint_address(
        &self,
        node_name: &str,
        address: &InternetAddress,
    ) -> Result<()> {
        retry!(self.wrapped.set_status_endpoint_address(node_name, address))
    }

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

    async fn get_tcp_listener_address(&self, node_name: &str) -> Result<Option<InternetAddress>> {
        retry!(self.wrapped.get_tcp_listener_address(node_name))
    }

    async fn get_status_endpoint_address(
        &self,
        node_name: &str,
    ) -> Result<Option<InternetAddress>> {
        retry!(self.wrapped.get_status_endpoint_address(node_name))
    }

    async fn set_node_pid(&self, node_name: &str, pid: u32) -> Result<()> {
        retry!(self.wrapped.set_node_pid(node_name, pid))
    }

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