esdiag 0.16.4

Elastic Stack diagnostic collector and processor
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

// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
// or more contributor license agreements. Licensed under the Elastic License 2.0;
// you may not use this file except in compliance with the Elastic License 2.0.

use crate::data::{Auth, KnownHost};
use base64::Engine;
use eyre::Result;
use reqwest::{Client, Method};
use std::collections::HashMap;
use url::Url;

/// A reqwest-based client with authentication for Logstash
#[derive(Clone)]
pub struct LogstashClient {
    client: Client,
    url: Url,
}

impl LogstashClient {
    /// Create a new Logstash client from a URL and Auth
    pub fn try_new(url: Url, auth: Auth, ignore_certs: bool) -> Result<Self> {
        let mut headers = reqwest::header::HeaderMap::new();

        match auth {
            Auth::Basic(username, password) => {
                let credentials =
                    base64::engine::general_purpose::STANDARD.encode(format!("{}:{}", username, password));
                headers.append(
                    reqwest::header::AUTHORIZATION,
                    format!("Basic {}", credentials).parse()?,
                );
            }
            Auth::Apikey(apikey) => {
                headers.append(reqwest::header::AUTHORIZATION, format!("ApiKey {}", apikey).parse()?);
            }
            Auth::None => {}
        }

        let client = Client::builder()
            .default_headers(headers)
            .danger_accept_invalid_certs(ignore_certs)
            .build()?;

        Ok(Self { client, url })
    }

    /// Send a request to a given path on the Logstash client
    pub async fn request(
        &self,
        method: Method,
        headers: &HashMap<String, String>,
        path: &str,
        body: Option<&[u8]>,
    ) -> Result<reqwest::Response> {
        let headers: reqwest::header::HeaderMap = headers
            .iter()
            .map(|(k, v)| (k.parse().unwrap(), v.parse().unwrap()))
            .collect();

        let request = match path.split_once('?') {
            Some((p, query)) => {
                let query = Self::query_pairs(query);
                self.client
                    .request(method, self.url.join(p)?)
                    .query(&query)
                    .headers(headers)
            }
            None => self.client.request(method, self.url.join(path)?).headers(headers),
        };

        let response = match body {
            Some(body) => request.body(body.to_vec()).send().await,
            None => request.send().await,
        };

        response.map_err(Into::into)
    }

    fn query_pairs(query: &str) -> Vec<(&str, &str)> {
        query
            .split('&')
            .filter(|s| !s.is_empty())
            .map(|s| s.split_once('=').unwrap_or((s, "")))
            .collect()
    }

    /// Verify the connection and authentication to Logstash
    pub async fn test_connection(&self) -> Result<reqwest::Response> {
        self.request(Method::GET, &HashMap::new(), "/", None).await
    }
}

impl TryFrom<KnownHost> for LogstashClient {
    type Error = eyre::Report;

    fn try_from(host: KnownHost) -> Result<Self> {
        let url = host.get_url()?;
        let ignore_certs = host.accept_invalid_certs();
        let auth = host.get_auth()?;
        LogstashClient::try_new(url, auth, ignore_certs)
    }
}

impl std::fmt::Display for LogstashClient {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.url)
    }
}

#[cfg(test)]
mod tests {
    use super::LogstashClient;

    #[test]
    fn query_pairs_preserve_valueless_parameters() {
        assert_eq!(
            LogstashClient::query_pairs("human&threads=10000"),
            vec![("human", ""), ("threads", "10000")]
        );
    }
}