Skip to main content

devops_armory/monitoring/gke/ram/
total.rs

1use awc::{
2    Client, Connector,
3    ws::{
4        self, 
5        Frame
6    },
7};
8use futures::StreamExt;
9use futures_util::SinkExt as _;
10
11use openssl::ssl::{
12    SslConnector, 
13    SslMethod, 
14    SslVerifyMode
15};
16
17/// Total memory usage
18/// Token and gke cluster endpoint, namespace and pod name need to be provided
19pub async fn mem_total(
20    token: String,
21    gke_cluster_endpoint: String,
22    gke_cluster_namespace: String,
23    gke_pod_name: String
24) -> Result<f64, std::io::Error> {
25
26    let mut builder = SslConnector::builder(SslMethod::tls()).unwrap();
27    builder.set_verify(SslVerifyMode::NONE);
28    let myconnector = builder.build();
29    let client = Client::builder()
30        .connector(Connector::new().openssl(myconnector))
31        .finish();
32    loop {
33        let Ok((_resp, mut connection2)) = client
34                .ws(format!("https://{gke_cluster_endpoint}:443/api/v1/namespaces/{gke_cluster_namespace}/pods/{gke_pod_name}/exec?command=cat&command=/proc/meminfo&stdin=true&stdout=true&stderr=true"))
35                .bearer_auth(format!("{token}"))
36                .connect()
37                .await
38                else {
39                    continue;
40                };
41
42            connection2
43                .send(ws::Message::Text("SGVsbG8sIHdvcmxkIQ==".into()))
44                .await
45                .unwrap();
46
47        loop {
48            let response = connection2.next().await;
49            match response {
50                Some(Ok(Frame::Binary(b))) => {
51                    let s = String::from_utf8_lossy(&b);
52                    let v = s.trim_matches(|c: char| !c.is_alphanumeric());
53                    if v.is_empty() {
54                        continue;
55                    }
56
57                    let mem: String = v.parse().expect("Incorrect type");
58
59                    let z = mem.split(" ").collect::<Vec<&str>>()[7].trim();
60
61                    let mem_total: f64 = z.parse().expect("Parse number error");
62
63                    return Ok(mem_total);
64                }
65                Some(Ok(Frame::Close(_c))) => {
66                    //println!("Connection closed");
67                }
68                Some(Ok(_)) => todo!(),
69                Some(Err(e)) => {
70                    println!("Some error occured {e}");
71                    //continue;
72                }
73                None => {
74                    break;
75                }
76            }
77        }
78    }
79}