ginmi 0.1.3

An asynchrounous gNMI client to interact with and manage network devices.
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

use crate::gen::gnmi::CapabilityResponse;
use crate::gen::gnmi::ModelData;

pub use crate::gen::gnmi::Encoding;

/// Capabilities of a given gNMI Target device.
///
/// Contains information about the capabilities that supported by a gNMI Target device.
/// Obtained via [Client::capabilities](super::Client::capabilities).
#[derive(Debug, Clone)]
pub struct Capabilities(pub CapabilityResponse);

impl<'a> Capabilities {
    /// Retrieve the gNMI Version that the target device supports.
    ///
    /// # Examples
    /// ```rust
    /// # use ginmi::client::{Client, Capabilities};
    /// # fn main() -> std::io::Result<()> {
    /// # tokio_test::block_on(async {
    /// # const CERT: &str = "CA Certificate";
    /// let mut client = Client::builder("https://clab-srl01-srl:57400")
    ///     .tls(CERT, "clab-srl01-srl")
    ///     .credentials("admin", "admin")
    ///     .build()
    ///     .await
    ///     .unwrap();
    ///
    /// let capabilities = client.capabilities().await.unwrap();
    /// let version = capabilities.gnmi_version();
    /// # });
    /// # Ok(())
    /// # }
    /// ```
    pub fn gnmi_version(&'a self) -> &'a str {
        self.0.g_nmi_version.as_str()
    }

    /// Check if target device supports a given model.
    ///
    /// # Arguments
    /// - name: Name of the model
    /// - organization: Organization publishing the model
    /// - version: Version of the model
    ///
    /// # Examples
    /// ```rust
    /// # use ginmi::client::{Client, Capabilities};
    /// # fn main() -> std::io::Result<()> {
    /// # tokio_test::block_on(async {
    /// # const CERT: &str = "CA Certificate";
    /// let mut client = Client::builder("https://clab-srl01-srl:57400")
    ///     .tls(CERT, "clab-srl01-srl")
    ///     .credentials("admin", "admin")
    ///     .build()
    ///     .await
    ///     .unwrap();
    ///
    /// let capabilities = client.capabilities().await.unwrap();
    /// let supports_aaa_nokia = capabilities.supports_model(
    ///     "urn:srl_nokia/aaa:srl_nokia-aaa",
    ///     "Nokia",
    ///     "2023-10-31"
    /// );
    /// # });
    /// # Ok(())
    /// # }
    /// ```
    pub fn supports_model(&self, name: &str, organization: &str, version: &str) -> bool {
        self.0.supported_models.contains(&ModelData {
            name: name.to_string(),
            organization: organization.to_string(),
            version: version.to_string(),
        })
    }

    /// Check if a target device supports a given [`Encoding`].
    ///
    /// # Arguments
    /// - encoding: The [`Encoding`] to check for.
    ///
    /// # Examples
    /// ```rust
    /// # use ginmi::client::{Client, Capabilities, Encoding};
    /// # fn main() -> std::io::Result<()> {
    /// # tokio_test::block_on(async {
    /// # const CERT: &str = "CA Certificate";
    /// let mut client = Client::builder("https://clab-srl01-srl:57400")
    ///     .tls(CERT, "clab-srl01-srl")
    ///     .credentials("admin", "admin")
    ///     .build()
    ///     .await
    ///     .unwrap();
    ///
    /// let capabilities = client.capabilities().await.unwrap();
    /// let supports_json = capabilities.supports_encoding(Encoding::Json);
    ///
    /// # });
    /// # Ok(())
    /// # }
    /// ```
    pub fn supports_encoding(&self, encoding: Encoding) -> bool {
        let enc: i32 = match encoding {
            Encoding::Json => 0,
            Encoding::Bytes => 1,
            Encoding::Proto => 2,
            Encoding::Ascii => 3,
            Encoding::JsonIetf => 4,
        };

        self.0.supported_encodings.contains(&enc)
    }
}