ockam_app_lib 0.146.0

Ockam's desktop application library
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

use crate::cli::cli_bin;
use crate::Result;
use ockam::compat::tokio::task::spawn_blocking;
use ockam_api::cli_state::EnrollmentTicket;
use ockam_core::async_trait;
use std::process::Command;
use tracing::{debug, error, info};

pub trait BackgroundNodeClientTrait: Send + Sync + 'static {
    fn nodes(&self) -> Box<dyn Nodes>;
    fn projects(&self) -> Box<dyn Projects>;
}

#[async_trait]
pub trait Nodes: Send + Sync + 'static {
    async fn create(&mut self, node_name: &str, project_name: &str) -> Result<()>;
}

#[async_trait]
pub trait Projects: Send + Sync + 'static {
    async fn enroll(&self, node_name: &str, enrollment_ticket: EnrollmentTicket) -> Result<()>;
}

#[derive(Clone)]
pub struct Cli {
    bin: String,
}

impl Cli {
    pub fn new() -> Self {
        Self {
            bin: cli_bin().expect("OCKAM env variable is not valid"),
        }
    }
}

fn log_command(cmd: &mut Command) -> std::io::Result<()> {
    info!(
        "Executing command: {} {}",
        cmd.get_program().to_string_lossy(),
        cmd.get_args()
            .map(|arg| arg.to_string_lossy())
            .fold(String::new(), |acc, arg| acc + " " + &arg)
    );

    Ok(())
}

impl BackgroundNodeClientTrait for Cli {
    fn nodes(&self) -> Box<dyn Nodes> {
        Box::new(self.clone())
    }

    fn projects(&self) -> Box<dyn Projects> {
        Box::new(self.clone())
    }
}

#[async_trait]
impl Nodes for Cli {
    async fn create(&mut self, node_name: &str, project_name: &str) -> Result<()> {
        let bin = self.bin.clone();
        let node_name = node_name.to_string();
        let project_name = project_name.to_string();
        spawn_blocking(move || {
            match duct::cmd!(
                &bin,
                "--no-input",
                "node",
                "create",
                &node_name,
                "--project",
                &project_name
            )
            .before_spawn(log_command)
            .stderr_null()
            .stdout_capture()
            .run()
            {
                Ok(_) => {
                    debug!(node = %node_name, "Node created")
                }
                Err(err) => {
                    error!(node = %node_name, error=%err, "Failed to create node")
                }
            }
        })
        .await?;

        Ok(())
    }
}

#[async_trait]
impl Projects for Cli {
    async fn enroll(&self, node_name: &str, enrollment_ticket: EnrollmentTicket) -> Result<()> {
        let node_name = node_name.to_string();
        let encoded_ticket = enrollment_ticket.export()?.to_string();
        let bin = self.bin.clone();
        Ok(spawn_blocking(move || {
            match duct::cmd!(&bin, "--no-input", "project", "enroll", &encoded_ticket)
                .before_spawn(log_command)
                .stderr_null()
                .stdout_capture()
                .run()
            {
                Ok(_) => {
                    debug!(node = %node_name, "Node enrolled using enrollment ticket");
                }
                Err(err) => {
                    error!(node = %node_name, error=%err, "Failed to enroll node")
                }
            }
        })
        .await?)
    }
}