grow-graylog 0.2.0

Rust SDK for Graylog Open by Grow Codes
Documentation
// Generated by sdk-kit 0.3.0 — do not edit; change sdk-kit and run "sdk-kit sync"
//! Environment variable reader with `GROW_<KEY>_*` and vendor fallbacks (SPEC §2.2).

use std::collections::HashMap;
use std::time::Duration;

use super::error::{Error, Result};
use super::secret::Secret;

/// Prefix of every SDK variable: `GROW_GRAYLOG_`.
pub const ENV_PREFIX: &str = "GROW_GRAYLOG_";

/// Reads configuration variables.
///
/// `name` arguments are the suffix after the prefix (`"URL"` → `GROW_<KEY>_URL`); vendor names
/// are full variable names checked in order when the prefixed one is unset. Empty values count
/// as unset. Tests inject a map so they never touch the process environment.
#[derive(Debug, Clone)]
pub struct EnvReader {
    prefix: String,
    vars: Option<HashMap<String, String>>,
}

impl Default for EnvReader {
    fn default() -> Self {
        EnvReader::new()
    }
}

impl EnvReader {
    /// Reader over the process environment with the SDK prefix.
    pub fn new() -> Self {
        EnvReader {
            prefix: ENV_PREFIX.to_owned(),
            vars: None,
        }
    }

    /// Reader over an explicit map with the SDK prefix.
    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(),
            ),
        }
    }

    /// Replaces the prefix (default `GROW_<KEY_UPPER>_`).
    pub fn with_prefix(mut self, prefix: impl Into<String>) -> Self {
        self.prefix = prefix.into();
        self
    }

    /// The prefix in use.
    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)
    }

    /// First present variable as `(variable name, 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)))
    }

    /// String value, or `None` when unset.
    pub fn string(&self, name: &str, vendor_names: &[&str]) -> Option<String> {
        self.lookup(name, vendor_names).map(|(_, v)| v)
    }

    /// Credential value, or `None` when unset.
    pub fn secret(&self, name: &str, vendor_names: &[&str]) -> Option<Secret> {
        self.string(name, vendor_names).map(Secret::from)
    }

    /// Duration value (`1500` ms or Go-style `1m30s`).
    pub fn duration(&self, name: &str, vendor_names: &[&str]) -> Result<Option<Duration>> {
        self.parsed(name, vendor_names, "a duration", parse_duration)
    }

    /// Boolean value (`true/false/1/0/yes/no/on/off`).
    pub fn bool(&self, name: &str, vendor_names: &[&str]) -> Result<Option<bool>> {
        self.parsed(name, vendor_names, "a boolean", parse_bool)
    }

    /// Integer value.
    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)
                // The message names the variable but never its value.
                .ok_or_else(|| Error::config(format!("environment variable {var} is not {what}"))),
        }
    }
}

/// Parses a boolean: `true/false/1/0/yes/no/on/off`, case-insensitive.
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,
    }
}

/// Parses a duration: integer milliseconds (`1500`) or Go-style units (`500ms`, `10s`, `2m`,
/// `1h`, `1m30s`, `1.5s`; also `ns`, `us`, `µs`).
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))
}