s3 0.1.36

A lean, modern, unofficial S3-compatible client for Rust.
Documentation 
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

use crate::{Error, Result};

pub(crate) fn optional_var(name: &'static str) -> Result<Option<String>> {
    match std::env::var(name) {
        Ok(value) => Ok(Some(value)),
        Err(std::env::VarError::NotPresent) => Ok(None),
        Err(std::env::VarError::NotUnicode(_)) => Err(Error::invalid_config(format!(
            "{name} must be valid Unicode"
        ))),
    }
}

#[cfg(feature = "credentials-profile")]
pub(crate) fn optional_first_var(names: &[&'static str]) -> Result<Option<(&'static str, String)>> {
    optional_first_var_with(names, optional_var)
}

#[cfg(feature = "credentials-sts")]
pub(crate) fn optional_first_non_empty_var(
    names: &[&'static str],
) -> Result<Option<(&'static str, String)>> {
    optional_first_var_with(names, |name| {
        Ok(optional_var(name)?.filter(|value| !value.is_empty()))
    })
}

#[cfg(any(test, feature = "credentials-profile", feature = "credentials-sts"))]
fn optional_first_var_with<F>(
    names: &[&'static str],
    mut get: F,
) -> Result<Option<(&'static str, String)>>
where
    F: FnMut(&'static str) -> Result<Option<String>>,
{
    for name in names {
        if let Some(value) = get(name)? {
            return Ok(Some((name, value)));
        }
    }
    Ok(None)
}

#[cfg(any(feature = "credentials-imds", feature = "credentials-sts"))]
pub(crate) fn optional_non_empty_var(name: &'static str) -> Result<Option<String>> {
    Ok(optional_var(name)?.filter(|value| !value.is_empty()))
}

pub(crate) fn required_var(name: &'static str) -> Result<String> {
    optional_var(name)?.ok_or_else(|| Error::invalid_config(format!("missing {name}")))
}

#[cfg(feature = "credentials-sts")]
pub(crate) fn required_non_empty_var(name: &'static str) -> Result<String> {
    match optional_var(name)? {
        Some(value) if !value.is_empty() => Ok(value),
        Some(_) => Err(Error::invalid_config(format!("{name} must not be empty"))),
        None => Err(Error::invalid_config(format!("missing {name}"))),
    }
}

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

    #[test]
    fn optional_first_var_is_lazy() {
        let mut visited = Vec::new();
        let value = optional_first_var_with(&["PRIMARY", "FALLBACK"], |name| {
            visited.push(name);
            Ok((name == "PRIMARY").then(|| "value".to_string()))
        })
        .unwrap();

        assert_eq!(value, Some(("PRIMARY", "value".to_string())));
        assert_eq!(visited, ["PRIMARY"]);
    }

    #[test]
    fn optional_first_non_empty_var_skips_empty_values() {
        let mut visited = Vec::new();
        let value = optional_first_var_with(&["PRIMARY", "FALLBACK"], |name| {
            visited.push(name);
            Ok(match name {
                "PRIMARY" => Some(String::new()),
                "FALLBACK" => Some("fallback".to_string()),
                _ => None,
            }
            .filter(|value| !value.is_empty()))
        })
        .unwrap();

        assert_eq!(value, Some(("FALLBACK", "fallback".to_string())));
        assert_eq!(visited, ["PRIMARY", "FALLBACK"]);
    }

    #[test]
    fn optional_first_var_reports_first_error_before_fallback() {
        let err = optional_first_var_with(&["PRIMARY", "FALLBACK"], |name| {
            if name == "PRIMARY" {
                Err(Error::invalid_config("bad primary"))
            } else {
                Ok(Some("fallback".to_string()))
            }
        })
        .expect_err("primary error must stop fallback lookup");

        match err {
            Error::InvalidConfig { message } => assert!(message.contains("bad primary")),
            other => panic!("expected invalid config, got {other:?}"),
        }
    }
}