xianyun_core/variables/

resolver.rs

//! Port of `internal/variables/resolver.go`.

use std::collections::HashMap;

use super::predefined::Options;

/// Resolves a variable name to its value. Matches `variables.Lookup` in the
/// Go original (used by `expand.go`'s `Lookup` function type).
pub trait Lookup {
    fn lookup(&self, name: &str) -> Option<String>;
}

/// Resolves variable names to string values. Immutable after construction and
/// safe for concurrent use, once the eventual implementation lands (the Go
/// original documents this contract on the `Resolver` interface).
pub trait Resolver {
    /// An `os.Expand`-compatible callback: returns the resolved value for
    /// `name`, or "" when the name is neither known nor set in the environment.
    fn expand(&self, name: &str) -> String;

    /// Every predefined variable plus all user-defined static variables. Does
    /// not include the (unbounded) environment.
    fn all(&self) -> HashMap<String, String>;

    /// The resolved value for `name` and whether `name` is known.
    fn lookup(&self, name: &str) -> Option<String>;
}

/// Adapts a `&dyn Resolver` to [`Lookup`], since both traits share the exact
/// `lookup(&self, name: &str) -> Option<String>` signature. Needed at the
/// `config`↔`variables` module boundary: `variables::expand::expand_map` and
/// `expand_definition` take `&dyn Lookup`, but `config::caproni`'s loader
/// only has a `Box<dyn Resolver>` to offer them. A thin wrapper struct is
/// used rather than `impl Lookup for dyn Resolver`, because Rust's `dyn`-to-
/// `dyn` coercion only applies to supertrait upcasting, not an arbitrary
/// blanket impl relating two unrelated traits.
pub struct ResolverLookup<'a>(pub &'a dyn Resolver);

impl Lookup for ResolverLookup<'_> {
    fn lookup(&self, name: &str) -> Option<String> {
        self.0.lookup(name)
    }
}

struct ResolverImpl {
    resolved: HashMap<String, String>,
}

impl Resolver for ResolverImpl {
    fn expand(&self, name: &str) -> String {
        match self.resolved.get(name) {
            Some(v) => v.clone(),
            None => std::env::var(name).unwrap_or_default(),
        }
    }

    fn all(&self) -> HashMap<String, String> {
        self.resolved.clone()
    }

    fn lookup(&self, name: &str) -> Option<String> {
        match self.resolved.get(name) {
            Some(v) => Some(v.clone()),
            None => std::env::var(name).ok(),
        }
    }
}

/// Resolves all predefined, tool-version, and static variables up front and
/// returns an immutable [`Resolver`]. Precedence, highest first: static
/// variables, predefined variables, tool versions, then (via `expand`) the
/// process environment.
pub fn new_resolver(
    opts: Options,
    static_vars: Option<HashMap<String, String>>,
    tool_versions: Option<HashMap<String, String>>,
) -> Box<dyn Resolver> {
    use super::predefined::{
        CAPRONI_CLUSTER_DOMAIN, CAPRONI_CLUSTER_NAME, CAPRONI_PRIMARY_HOSTNAME,
        XIANYUN_CLUSTER_DOMAIN, XIANYUN_CLUSTER_NAME, XIANYUN_PRIMARY_HOSTNAME, cluster_domain,
        primary_hostname,
    };

    let mut resolved = tool_versions.unwrap_or_default();

    // Both the primary XIANYUN_* name and the CAPRONI_* compatibility
    // alias resolve to the same value, so `${XIANYUN_CLUSTER_NAME}` and
    // `${CAPRONI_CLUSTER_NAME}` are interchangeable in config expansion.
    resolved.insert(XIANYUN_CLUSTER_NAME.to_string(), opts.profile_name.clone());
    resolved.insert(CAPRONI_CLUSTER_NAME.to_string(), opts.profile_name.clone());
    resolved.insert(
        XIANYUN_PRIMARY_HOSTNAME.to_string(),
        primary_hostname(&opts),
    );
    resolved.insert(
        CAPRONI_PRIMARY_HOSTNAME.to_string(),
        primary_hostname(&opts),
    );
    if let Ok(domain) = cluster_domain(&opts) {
        resolved.insert(XIANYUN_CLUSTER_DOMAIN.to_string(), domain.clone());
        resolved.insert(CAPRONI_CLUSTER_DOMAIN.to_string(), domain);
    }

    if let Some(static_vars) = static_vars {
        resolved.extend(static_vars);
    }

    Box::new(ResolverImpl { resolved })
}

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

    // Port of TestResolverExpand.
    #[test]
    fn resolver_expand_cases() {
        struct Case {
            name: &'static str,
            opts: Options,
            static_vars: Option<HashMap<String, String>>,
            env_vars: HashMap<&'static str, &'static str>,
            var_name: &'static str,
            want: &'static str,
        }

        let cases = vec![
            Case {
                name: "predefined resolves from options",
                opts: Options {
                    profile_name: "prod".into(),
                    cluster: None,
                },
                static_vars: None,
                env_vars: HashMap::new(),
                var_name: "CAPRONI_CLUSTER_NAME",
                want: "prod",
            },
            Case {
                name: "predefined resolves from options via the xianyun primary name",
                opts: Options {
                    profile_name: "prod".into(),
                    cluster: None,
                },
                static_vars: None,
                env_vars: HashMap::new(),
                var_name: "XIANYUN_CLUSTER_NAME",
                want: "prod",
            },
            Case {
                name: "static literal resolves",
                opts: Options::default(),
                static_vars: Some(HashMap::from([(
                    "HOSTNAME".to_string(),
                    "foo.example.com".to_string(),
                )])),
                env_vars: HashMap::new(),
                var_name: "HOSTNAME",
                want: "foo.example.com",
            },
            Case {
                name: "static shadows predefined",
                opts: Options {
                    profile_name: "prod".into(),
                    cluster: None,
                },
                static_vars: Some(HashMap::from([(
                    "CAPRONI_CLUSTER_NAME".to_string(),
                    "override".to_string(),
                )])),
                env_vars: HashMap::new(),
                var_name: "CAPRONI_CLUSTER_NAME",
                want: "override",
            },
            Case {
                name: "unknown falls back to env",
                opts: Options::default(),
                static_vars: None,
                env_vars: HashMap::from([("CUSTOM", "env-val")]),
                var_name: "CUSTOM",
                want: "env-val",
            },
            Case {
                name: "unknown not in env is empty",
                opts: Options::default(),
                static_vars: None,
                env_vars: HashMap::new(),
                var_name: "MISSING",
                want: "",
            },
        ];

        for case in cases {
            for (k, v) in &case.env_vars {
                unsafe {
                    std::env::set_var(k, v);
                }
            }

            let r = new_resolver(case.opts, case.static_vars, None);
            assert_eq!(r.expand(case.var_name), case.want, "{}", case.name);
        }
    }

    // Port of TestResolverExpandReadsEnvLive.
    #[test]
    fn resolver_expand_reads_env_live() {
        let r = new_resolver(Options::default(), None, None);

        unsafe {
            std::env::set_var("LIVE", "first");
        }
        assert_eq!(r.expand("LIVE"), "first");

        unsafe {
            std::env::set_var("LIVE", "second");
        }
        assert_eq!(r.expand("LIVE"), "second");
    }

    // Port of TestResolverExpandNilStaticVars.
    #[test]
    fn resolver_expand_nil_static_vars() {
        let r = new_resolver(
            Options {
                profile_name: "prod".into(),
                cluster: None,
            },
            None,
            None,
        );
        assert_eq!(r.expand("CAPRONI_CLUSTER_NAME"), "prod");
    }

    // Port of TestResolverAll.
    #[test]
    fn resolver_all() {
        let r = new_resolver(
            Options {
                profile_name: "my-cluster".into(),
                cluster: None,
            },
            Some(HashMap::from([(
                "HOSTNAME".to_string(),
                "foo.example.com".to_string(),
            )])),
            None,
        );

        let all = r.all();
        assert_eq!(
            all.get("CAPRONI_CLUSTER_NAME"),
            Some(&"my-cluster".to_string())
        );
        assert_eq!(all.get("HOSTNAME"), Some(&"foo.example.com".to_string()));
    }

    // Port of TestResolverAllStaticShadowsPredefined.
    #[test]
    fn resolver_all_static_shadows_predefined() {
        let r = new_resolver(
            Options {
                profile_name: "prod".into(),
                cluster: None,
            },
            Some(HashMap::from([(
                "CAPRONI_CLUSTER_NAME".to_string(),
                "override".to_string(),
            )])),
            None,
        );

        assert_eq!(
            r.all().get("CAPRONI_CLUSTER_NAME"),
            Some(&"override".to_string())
        );
    }

    // Port of TestResolver_Lookup.
    #[test]
    fn resolver_lookup_cases() {
        unsafe {
            std::env::set_var("CAPRONI_TEST_ENV", "from-env");
        }

        let static_vars = HashMap::from([("STATIC".to_string(), "from-static".to_string())]);
        let r = new_resolver(
            Options {
                profile_name: "demo".into(),
                cluster: None,
            },
            Some(static_vars),
            None,
        );

        let cases = [
            ("static variable", "STATIC", Some("from-static")),
            ("predefined variable", "CAPRONI_CLUSTER_NAME", Some("demo")),
            ("environment variable", "CAPRONI_TEST_ENV", Some("from-env")),
            ("unknown variable", "NOPE", None),
        ];

        for (name, var_name, want) in cases {
            assert_eq!(r.lookup(var_name), want.map(str::to_string), "{name}");
        }
    }

    // Port of TestResolver_ToolVersions.
    #[test]
    fn resolver_tool_versions_cases() {
        {
            let r = new_resolver(
                Options::default(),
                None,
                Some(HashMap::from([(
                    "GL_CERT_MANAGER_VERSION".to_string(),
                    "v1.2.3".to_string(),
                )])),
            );
            assert_eq!(r.expand("GL_CERT_MANAGER_VERSION"), "v1.2.3");
        }

        {
            let static_vars = HashMap::from([(
                "GL_CERT_MANAGER_VERSION".to_string(),
                "from-static".to_string(),
            )]);
            let tool_versions = HashMap::from([(
                "GL_CERT_MANAGER_VERSION".to_string(),
                "from-tool".to_string(),
            )]);
            let r = new_resolver(Options::default(), Some(static_vars), Some(tool_versions));
            assert_eq!(r.expand("GL_CERT_MANAGER_VERSION"), "from-static");
        }

        {
            unsafe {
                std::env::set_var("GL_CERT_MANAGER_VERSION", "from-env");
            }
            let tool_versions = HashMap::from([(
                "GL_CERT_MANAGER_VERSION".to_string(),
                "from-tool".to_string(),
            )]);
            let r = new_resolver(Options::default(), None, Some(tool_versions));
            assert_eq!(r.expand("GL_CERT_MANAGER_VERSION"), "from-tool");
        }

        {
            unsafe {
                std::env::set_var("SOME_OTHER_VAR", "from-env");
            }
            let tool_versions =
                HashMap::from([("GL_CERT_MANAGER_VERSION".to_string(), "v1.2.3".to_string())]);
            let r = new_resolver(Options::default(), None, Some(tool_versions));
            assert_eq!(r.expand("SOME_OTHER_VAR"), "from-env");
        }
    }
}