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

use super::Result;
use crate::cli_state::TcpInlet;
use crate::nodes::models::portal::OutletStatus;
use crate::CliState;
use ockam_core::errcode::{Kind, Origin};
use ockam_core::Address;
use ockam_multiaddr::MultiAddr;
use ockam_transport_core::HostnamePort;
use std::net::SocketAddr;

impl CliState {
    /// Create a TCP inlet
    #[instrument(skip_all)]
    pub async fn create_tcp_inlet(
        &self,
        node_name: &str,
        bind_addr: &SocketAddr,
        outlet_addr: &MultiAddr,
        alias: &str,
        privileged: bool,
    ) -> Result<TcpInlet> {
        let tcp_inlet = TcpInlet::new(bind_addr, outlet_addr, alias, privileged);
        self.tcp_portals_repository()
            .store_tcp_inlet(node_name, &tcp_inlet)
            .await?;
        Ok(tcp_inlet)
    }

    /// Get a TCP inlet by node name and alias
    #[instrument(skip_all)]
    pub async fn get_tcp_inlet(&self, node_name: &str, alias: &str) -> Result<TcpInlet> {
        Ok(self
            .tcp_portals_repository()
            .get_tcp_inlet(node_name, alias)
            .await?
            .ok_or_else(|| {
                ockam_core::Error::new(
                    Origin::Api,
                    Kind::NotFound,
                    format!("no tcp inlet found for node {node_name}, with alias {alias}"),
                )
            })?)
    }

    /// Delete a TCP inlet
    #[instrument(skip_all)]
    pub async fn delete_tcp_inlet(&self, node_name: &str, alias: &str) -> Result<()> {
        Ok(self
            .tcp_portals_repository()
            .delete_tcp_inlet(node_name, alias)
            .await?)
    }

    /// Create a TCP outlet
    #[instrument(skip_all)]
    pub async fn create_tcp_outlet(
        &self,
        node_name: &str,
        to: &HostnamePort,
        worker_addr: &Address,
        payload: &Option<String>,
        privileged: bool,
    ) -> Result<OutletStatus> {
        let tcp_outlet_status =
            OutletStatus::new(to.clone(), worker_addr.clone(), payload.clone(), privileged);

        self.tcp_portals_repository()
            .store_tcp_outlet(node_name, &tcp_outlet_status)
            .await?;
        Ok(tcp_outlet_status)
    }

    /// Delete a TCP outlet
    #[instrument(skip_all)]
    pub async fn delete_tcp_outlet(&self, node_name: &str, worker_addr: &Address) -> Result<()> {
        Ok(self
            .tcp_portals_repository()
            .delete_tcp_outlet(node_name, worker_addr)
            .await?)
    }
}