espipe 0.4.0

A minimalist command-line utility to pipe documents from a file or I/O stream into an Elasticsearch cluster.
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

use eyre::{Result, eyre};
use serde::{Deserialize, Serialize};
use serde_yaml;
use std::collections::BTreeMap;
use std::env;
use std::fmt::{self, Display, Formatter};
use std::fs::{File, create_dir};
use std::io::BufReader;
use std::path::PathBuf;
use url::Url;

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "auth")]
pub enum KnownHost {
    ApiKey {
        insecure: Option<bool>,
        apikey: String,
        url: Url,
    },
    Basic {
        insecure: Option<bool>,
        password: String,
        url: Url,
        username: String,
    },
    None {
        insecure: Option<bool>,
        url: Url,
    },
}

impl KnownHost {
    pub fn parse(host: &str) -> Option<Self> {
        // parse the ~/.espipe/hosts.yml file into a HashMap<String, Host>
        let hosts = match parse_hosts_yml() {
            Ok(hosts) => hosts,
            Err(e) => {
                log::error!("Error parsing hosts.yml: {}", e);
                return None;
            }
        };
        log::debug!(
            "Known hosts: {}",
            hosts
                .clone()
                .into_iter()
                .map(|(k, _)| k)
                .collect::<Vec<String>>()
                .join(", ")
        );
        hosts.get(host).cloned()
    }

    pub fn get_url(&self) -> Url {
        match self {
            Self::ApiKey { url, .. } => url.clone(),
            Self::Basic { url, .. } => url.clone(),
            Self::None { url, .. } => url.clone(),
        }
    }
}

impl Display for KnownHost {
    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::ApiKey { url, .. } => write!(fmt, "ApiKey auth: {}", url,),
            Self::Basic { url, username, .. } => write!(fmt, "Basic auth: {}@ {}", username, url,),
            Self::None { url, .. } => write!(fmt, "No auth: {}", url),
        }
    }
}

impl TryFrom<&str> for KnownHost {
    type Error = eyre::Report;
    fn try_from(value: &str) -> Result<Self> {
        match KnownHost::parse(value) {
            Some(host) => Ok(host),
            None => Err(eyre!("No known host entry for: {}", value)),
        }
    }
}

/// Get the path for the hosts.yml file, fallback to ~/.espipe/hosts.yml
fn get_hosts_path() -> Result<PathBuf> {
    match env::var("ESPIPE_HOSTS") {
        Ok(path) => Ok(PathBuf::from(path)),
        Err(_) => {
            let home = env::var("HOME").map(|home| PathBuf::from(home))?;
            // Check if the `.espipe` directory exists, if not, create it
            let home_dir = home.join(".espipe");
            if !home_dir.exists() {
                create_dir(&home_dir)?
            }
            let path = home.join(".espipe").join("hosts.yml");
            Ok(path)
        }
    }
}

/// Tries to load hosts from a yml file, creates an empty file if it doesn't exist
fn parse_hosts_yml() -> Result<BTreeMap<String, KnownHost>> {
    let path = get_hosts_path()?;
    log::debug!("Parsing {:?}", path);
    match path.is_file() {
        true => {
            let file = File::open(path)?;
            let reader = BufReader::new(file);
            let hosts: BTreeMap<String, KnownHost> = serde_yaml::from_reader(reader)?;
            Ok(hosts)
        }
        false => {
            log::info!("No known hosts file, creating: {:?}", path);
            File::create(path)?;
            Ok(BTreeMap::new())
        }
    }
}