use std::collections::HashMap;
use std::time::Duration;
use super::error::{Error, Result};
use super::secret::Secret;
pub const ENV_PREFIX: &str = "GROW_GRAYLOG_";
#[derive(Debug, Clone)]
pub struct EnvReader {
prefix: String,
vars: Option<HashMap<String, String>>,
}
impl Default for EnvReader {
fn default() -> Self {
EnvReader::new()
}
}
impl EnvReader {
pub fn new() -> Self {
EnvReader {
prefix: ENV_PREFIX.to_owned(),
vars: None,
}
}
pub fn from_map<I, K, V>(vars: I) -> Self
where
I: IntoIterator<Item = (K, V)>,
K: Into<String>,
V: Into<String>,
{
EnvReader {
prefix: ENV_PREFIX.to_owned(),
vars: Some(
vars.into_iter()
.map(|(k, v)| (k.into(), v.into()))
.collect(),
),
}
}
pub fn with_prefix(mut self, prefix: impl Into<String>) -> Self {
self.prefix = prefix.into();
self
}
pub fn prefix(&self) -> &str {
&self.prefix
}
fn raw(&self, full_name: &str) -> Option<String> {
let value = match &self.vars {
Some(map) => map.get(full_name).cloned(),
None => std::env::var(full_name).ok(),
}?;
(!value.is_empty()).then_some(value)
}
pub fn lookup(&self, name: &str, vendor_names: &[&str]) -> Option<(String, String)> {
let prefixed = format!("{}{}", self.prefix, name);
std::iter::once(prefixed)
.chain(vendor_names.iter().map(|v| (*v).to_owned()))
.find_map(|var| self.raw(&var).map(|value| (var, value)))
}
pub fn string(&self, name: &str, vendor_names: &[&str]) -> Option<String> {
self.lookup(name, vendor_names).map(|(_, v)| v)
}
pub fn secret(&self, name: &str, vendor_names: &[&str]) -> Option<Secret> {
self.string(name, vendor_names).map(Secret::from)
}
pub fn duration(&self, name: &str, vendor_names: &[&str]) -> Result<Option<Duration>> {
self.parsed(name, vendor_names, "a duration", parse_duration)
}
pub fn bool(&self, name: &str, vendor_names: &[&str]) -> Result<Option<bool>> {
self.parsed(name, vendor_names, "a boolean", parse_bool)
}
pub fn int(&self, name: &str, vendor_names: &[&str]) -> Result<Option<i64>> {
self.parsed(name, vendor_names, "an integer", |s| s.trim().parse().ok())
}
fn parsed<T>(
&self,
name: &str,
vendor_names: &[&str],
what: &str,
parse: impl Fn(&str) -> Option<T>,
) -> Result<Option<T>> {
match self.lookup(name, vendor_names) {
None => Ok(None),
Some((var, value)) => parse(&value)
.map(Some)
.ok_or_else(|| Error::config(format!("environment variable {var} is not {what}"))),
}
}
}
pub fn parse_bool(value: &str) -> Option<bool> {
match value.trim().to_ascii_lowercase().as_str() {
"true" | "1" | "yes" | "on" => Some(true),
"false" | "0" | "no" | "off" => Some(false),
_ => None,
}
}
pub fn parse_duration(value: &str) -> Option<Duration> {
let s = value.trim();
if s.is_empty() {
return None;
}
if s.bytes().all(|b| b.is_ascii_digit()) {
return s.parse::<u64>().ok().map(Duration::from_millis);
}
let mut rest = s;
let mut total = 0f64;
while !rest.is_empty() {
let num_len = rest
.find(|c: char| !(c.is_ascii_digit() || c == '.'))
.unwrap_or(rest.len());
if num_len == 0 {
return None;
}
let number: f64 = rest[..num_len].parse().ok()?;
rest = &rest[num_len..];
let unit_len = rest
.find(|c: char| c.is_ascii_digit() || c == '.')
.unwrap_or(rest.len());
let nanos_per_unit = match &rest[..unit_len] {
"ns" => 1.0,
"us" | "µs" | "μs" => 1e3,
"ms" => 1e6,
"s" => 1e9,
"m" => 60e9,
"h" => 3600e9,
_ => return None,
};
rest = &rest[unit_len..];
total += number * nanos_per_unit;
}
if !total.is_finite() || total > u64::MAX as f64 {
return None;
}
Some(Duration::from_nanos(total.round() as u64))
}