otoroshictl 0.0.8

a CLI to manage your otoroshi clusters with style ;)
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

use hyper::{body::Bytes, Request, Client};

pub enum HttpContentKind {
    JSON,
    YAML,
}

pub struct HttpContent {
    pub kind: HttpContentKind,
    pub content: Bytes,
}

pub struct Http {}

impl Http {

    pub async fn get_with_bearer(url: &String, token: &String) -> Result<HttpContent, String> {
        let tls = url.starts_with("https://");
        let req: Request<hyper::Body> = Request::builder()
            .method("GET")
            .uri(url)
            .header("accept", "application/json")
            .header("authorization", format!("Bearer {}", token))
            .body(hyper::Body::empty())
            .unwrap();
            
        let resp_result = if tls {
            let https = hyper_rustls::HttpsConnectorBuilder::new()
                .with_native_roots()
                .https_or_http()
                .enable_http1()
                .build();
            let client = Client::builder().build::<_, hyper::Body>(https);
            client.request(req).await
        } else {
            let client = Client::new();
            client.request(req).await
        };
        match resp_result {
            Err(err) => {
                std::result::Result::Err(format!("error while fetching content at '{}': \n\n{}", url, err))
            },
            Ok(resp) => {
                match resp.status().as_u16() {
                    200 => {
                        let content_type: String = resp.headers().get("content-type").map(|v| v.to_str().unwrap().to_string()).unwrap_or("application/json".to_string());
                        let body_bytes = hyper::body::to_bytes(resp).await.unwrap();
                        if content_type.contains("json") {
                            Ok(HttpContent {
                                kind: HttpContentKind::JSON,
                                content: body_bytes,
                            })
                        } else {
                            Ok(HttpContent {
                                kind: HttpContentKind::YAML,
                                content: body_bytes,
                            })
                        }
                    },
                    code => {
                        let body_bytes = hyper::body::to_bytes(resp).await.unwrap();
                        let error_msg = String::from_utf8(body_bytes.to_vec()).unwrap_or_default();
                        std::result::Result::Err(format!("bad response status {} while fetching content at '{}': {}", code, url, error_msg))
                    }
                }
            }
        }
    }

    pub async fn get(url: &String) -> Result<HttpContent, String> {
        let tls = url.starts_with("https://");
        let req: Request<hyper::Body> = Request::builder()
            .method("GET")
            .uri(url)
            .header("accept", "application/yaml, application/json".to_string())
            .body(hyper::Body::empty())
            .unwrap();
            
        let resp_result = if tls {
            let https = hyper_rustls::HttpsConnectorBuilder::new()
                .with_native_roots()
                .https_or_http()
                .enable_http1()
                .build();
            let client = Client::builder().build::<_, hyper::Body>(https);
            client.request(req).await
        } else {
            let client = Client::new();
            client.request(req).await
        };
        match resp_result {
            Err(err) => {
                std::result::Result::Err(format!("error while fetching content at '{}': \n\n{}", url, err))
            },
            Ok(resp) => {
                match resp.status().as_u16() {
                    200 => {
                        let content_type: String = resp.headers().get("content-type").map(|v| v.to_str().unwrap().to_string()).unwrap_or("application/yaml".to_string());
                        let body_bytes = hyper::body::to_bytes(resp).await.unwrap();
                        if content_type.contains("json") {
                            Ok(HttpContent {
                                kind: HttpContentKind::JSON,
                                content: body_bytes,
                            })
                        } else {
                            Ok(HttpContent {
                                kind: HttpContentKind::YAML,
                                content: body_bytes,
                            })
                        }
                    },
                    code => {
                        std::result::Result::Err(format!("bad response status {} while fetching content at '{}'", code, url))
                    }
                }
            }
        }
    }
}