nanocld_client 0.17.0

The Nanocl daemon api client
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
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

use nanocl_error::http_client::HttpClientResult;

use nanocl_stubs::generic::GenericFilter;
use nanocl_stubs::secret::{Secret, SecretPartial, SecretUpdate};

use super::http_client::NanocldClient;

impl NanocldClient {
  /// ## Default path for secrets
  const SECRET_PATH: &'static str = "/secrets";

  /// List existing secrets in the system.
  ///
  /// ## Example
  ///
  /// ```no_run,ignore
  /// use nanocld_client::NanocldClient;
  ///
  /// let client = NanocldClient::connect_to("http://localhost:8585", None);
  /// let res = client.list_secret(None).await;
  /// ```
  pub async fn list_secret(
    &self,
    query: Option<&GenericFilter>,
  ) -> HttpClientResult<Vec<Secret>> {
    let query = Self::convert_query(query)?;
    let res = self.send_get(Self::SECRET_PATH, Some(&query)).await?;
    Self::res_json(res).await
  }

  /// Create a new secret
  pub async fn create_secret(
    &self,
    item: &SecretPartial,
  ) -> HttpClientResult<Secret> {
    let res = self
      .send_post(Self::SECRET_PATH, Some(item), None::<String>)
      .await?;
    Self::res_json(res).await
  }

  /// Patch a secret by it's key to update it with new data
  pub async fn patch_secret(
    &self,
    key: &str,
    item: &SecretUpdate,
  ) -> HttpClientResult<Secret> {
    let res = self
      .send_patch(
        &format!("{}/{key}", Self::SECRET_PATH),
        Some(item),
        None::<String>,
      )
      .await?;
    Self::res_json(res).await
  }

  /// Inspect a secret by it's key to get more information about it
  ///
  /// ## Example
  ///
  /// ```no_run,ignore
  /// use nanocld_client::NanocldClient;
  ///
  /// let client = NanocldClient::connect_to("http://localhost:8585", None);
  /// let secret = client.inspect_secret("my-secret").await?;
  /// ```
  pub async fn inspect_secret(&self, key: &str) -> HttpClientResult<Secret> {
    let res = self
      .send_get(
        &format!("{}/{key}/inspect", Self::SECRET_PATH),
        None::<String>,
      )
      .await?;
    Self::res_json(res).await
  }

  /// Delete a secret by it's key
  ///
  /// ## Example
  ///
  /// ```no_run,ignore
  /// use nanocld_client::NanocldClient;
  ///
  /// let client = NanocldClient::connect_to("http://localhost:8585", None);
  /// client.delete_secret("my-secret").await?;
  /// ```
  pub async fn delete_secret(&self, key: &str) -> HttpClientResult<()> {
    self
      .send_delete(&format!("{}/{key}", Self::SECRET_PATH), None::<String>)
      .await?;
    Ok(())
  }
}

#[cfg(test)]
mod tests {
  use crate::ConnectOpts;

  use super::*;

  #[ntex::test]
  async fn basic() {
    const SECRET_NAME: &str = "secret-test";
    let client = NanocldClient::connect_to(&ConnectOpts {
      url: "http://nanocl.internal:8585".into(),
      ..Default::default()
    })
    .expect("Failed to create a nanocl client");
    client.list_secret(None).await.unwrap();
    let secret = SecretPartial {
      name: SECRET_NAME.to_owned(),
      kind: "gen.io/generic".to_owned(),
      data: serde_json::json!({"key": "value"}),
      metadata: None,
      immutable: false,
    };
    let secret = client.create_secret(&secret).await.unwrap();
    assert_eq!(secret.name, SECRET_NAME);
    let secret = client.inspect_secret(SECRET_NAME).await.unwrap();
    assert_eq!(secret.name, SECRET_NAME);
    client.delete_secret(SECRET_NAME).await.unwrap();
  }
}