use std::path::Path;
use indexmap::IndexMap;
use serde::Deserialize;
use serde_json::Value;
use crate::error::{Error, Result};
use crate::expr;
use crate::model::InventoryData;
fn default_true() -> bool {
true
}
fn de_expr_map<'de, D>(deserializer: D) -> std::result::Result<IndexMap<String, String>, D::Error>
where
D: serde::Deserializer<'de>,
{
let raw: IndexMap<String, Value> = IndexMap::deserialize(deserializer)?;
raw.into_iter()
.map(|(k, v)| {
value_to_expr(&v)
.map(|s| (k, s))
.map_err(serde::de::Error::custom)
})
.collect()
}
fn value_to_expr(v: &Value) -> std::result::Result<String, String> {
match v {
Value::String(s) => Ok(s.clone()),
Value::Bool(b) => Ok(if *b { "True".into() } else { "False".into() }),
Value::Number(n) => Ok(n.to_string()),
Value::Null => Ok("None".into()),
Value::Array(_) | Value::Object(_) => {
Err(format!("expected a string expression, found {v}"))
}
}
}
fn default_separator() -> String {
"_".to_string()
}
#[derive(Debug, Deserialize)]
struct Config {
#[serde(default, deserialize_with = "de_expr_map")]
compose: IndexMap<String, String>,
#[serde(default)]
keyed_groups: Vec<KeyedGroup>,
#[serde(default, deserialize_with = "de_expr_map")]
groups: IndexMap<String, String>,
#[serde(default)]
strict: bool,
#[serde(default = "default_true")]
leading_separator: bool,
#[serde(default = "default_true")]
trailing_separator: bool,
}
#[derive(Debug, Deserialize)]
struct KeyedGroup {
key: String,
#[serde(default)]
prefix: String,
#[serde(default = "default_separator")]
separator: String,
#[serde(default)]
default_value: Option<String>,
#[serde(default)]
parent_group: Option<String>,
}
pub fn is_constructed(value: &Value) -> bool {
matches!(
value.get("plugin").and_then(|p| p.as_str()),
Some("constructed") | Some("ansible.builtin.constructed")
)
}
pub fn apply(inv: &mut InventoryData, value: &Value, path: &Path) -> Result<()> {
let cfg: Config = serde_json::from_value(value.clone()).map_err(|e| Error::Parse {
path: path.display().to_string(),
msg: format!("invalid constructed config: {e}"),
})?;
let err = |msg: String| Error::Parse {
path: path.display().to_string(),
msg,
};
let hosts: Vec<String> = inv.hosts.keys().cloned().collect();
let _span = tracing::info_span!(
"constructed",
hosts = hosts.len(),
compose = cfg.compose.len(),
keyed_groups = cfg.keyed_groups.len(),
groups = cfg.groups.len(),
)
.entered();
for host in &hosts {
if !cfg.compose.is_empty() {
let snapshot = crate::vars::resolve_host_inline_vars(inv, host);
let mut composed: Vec<(String, Value)> = Vec::new();
for (name, src) in &cfg.compose {
match expr::eval_compose(src, &snapshot, cfg.strict) {
Ok(Some(v)) => composed.push((name.clone(), v)),
Ok(None) => {} Err(e) => return Err(err(format!("constructed compose[{name}]: {}", e.0))),
}
}
for (name, v) in composed {
inv.set_host_var(host, &name, v);
}
}
let vars = crate::vars::resolve_host_inline_vars(inv, host);
for (gname, cond) in &cfg.groups {
match expr::eval_condition(cond, &vars) {
Ok(true) => {
let g = inv.add_group(gname);
inv.add_host_to_group(host, &g);
}
Ok(false) => {}
Err(e) => return Err(err(format!("constructed groups[{gname}]: {}", e.0))),
}
}
for kg in &cfg.keyed_groups {
let bares = match expr::eval_key(&kg.key, &vars) {
Ok(None) => continue, Ok(Some(v)) => bare_names(&v, kg, &cfg)
.map_err(|m| err(format!("constructed keyed_groups key {:?}: {m}", kg.key)))?,
Err(e) => return Err(err(format!("constructed keyed_groups: {}", e.0))),
};
for bare in bares {
let raw = group_name(&kg.prefix, &kg.separator, &bare, cfg.leading_separator);
let g = inv.add_group(&raw);
inv.add_host_to_group(host, &g);
if let Some(pg) = &kg.parent_group {
let parent = inv.add_group(pg);
inv.add_child(&parent, &g);
}
}
}
}
Ok(())
}
fn bare_names(
v: &Value,
kg: &KeyedGroup,
cfg: &Config,
) -> std::result::Result<Vec<String>, String> {
if expr::truthy(v) {
match v {
Value::String(s) => Ok(vec![s.clone()]),
Value::Number(n) => Ok(vec![n.to_string()]),
Value::Bool(b) => Ok(vec![if *b { "True".into() } else { "False".into() }]),
Value::Array(items) => {
let mut out = Vec::new();
for item in items {
out.push(scalar_to_string(item)?);
}
Ok(out)
}
Value::Object(_) => Err("dict-valued keys are not supported".into()),
Value::Null => Ok(vec![]),
}
} else {
match &kg.default_value {
Some(dv) => Ok(vec![dv.clone()]),
None if cfg.trailing_separator => Ok(vec![String::new()]),
None => Ok(vec![]),
}
}
}
fn scalar_to_string(v: &Value) -> std::result::Result<String, String> {
match v {
Value::String(s) => Ok(s.clone()),
Value::Number(n) => Ok(n.to_string()),
Value::Bool(b) => Ok(if *b { "True".into() } else { "False".into() }),
_ => Err("list elements must be scalars".into()),
}
}
fn group_name(prefix: &str, separator: &str, bare: &str, leading_separator: bool) -> String {
let sep = if prefix.is_empty() && !leading_separator {
""
} else {
separator
};
crate::sanitize::to_safe_group_name(&format!("{prefix}{sep}{bare}"))
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn non_string_group_and_compose_values_are_coerced() {
let value = json!({
"plugin": "constructed",
"groups": { "dpu": true, "off": false, "n": 1 },
"compose": { "flag": true },
});
let cfg: Config = serde_json::from_value(value).expect("non-string scalars accepted");
assert_eq!(cfg.groups.get("dpu").map(String::as_str), Some("True"));
assert_eq!(cfg.groups.get("off").map(String::as_str), Some("False"));
assert_eq!(cfg.groups.get("n").map(String::as_str), Some("1"));
assert_eq!(cfg.compose.get("flag").map(String::as_str), Some("True"));
let vars = serde_json::Map::new();
assert!(expr::eval_condition(cfg.groups.get("dpu").unwrap(), &vars).unwrap());
assert!(!expr::eval_condition(cfg.groups.get("off").unwrap(), &vars).unwrap());
}
#[test]
fn container_group_value_is_rejected() {
let value = json!({ "plugin": "constructed", "groups": { "bad": [1, 2] } });
assert!(serde_json::from_value::<Config>(value).is_err());
}
}