use std::path::Path;
use std::process::{Command, Stdio};
use serde_json::{Map, Value};
use crate::error::{Error, Result};
use crate::model::InventoryData;
#[cfg(unix)]
pub fn is_executable(path: &Path) -> bool {
use std::os::unix::fs::PermissionsExt;
std::fs::metadata(path)
.map(|m| m.is_file() && m.permissions().mode() & 0o111 != 0)
.unwrap_or(false)
}
#[cfg(not(unix))]
pub fn is_executable(_path: &Path) -> bool {
false
}
pub fn parse_script(inv: &mut InventoryData, path: &Path) -> Result<()> {
let list = run_list(path)?;
parse_list(inv, path, list)
}
pub fn run_list(path: &Path) -> Result<Value> {
run_script(path, &["--list"])
}
pub fn parse_list(inv: &mut InventoryData, path: &Path, list: Value) -> Result<()> {
let top = list.as_object().ok_or_else(|| Error::Parse {
path: path.display().to_string(),
msg: "inventory script --list output must be a JSON object".into(),
})?;
let mut hosts: Vec<String> = Vec::new();
let mut meta: Option<&Map<String, Value>> = None;
for (group, gdata) in top {
if group == "_meta" {
meta = gdata.get("hostvars").and_then(|h| h.as_object());
} else {
parse_group(inv, group, gdata, &mut hosts);
}
}
for host in &hosts {
let vars = match meta {
Some(m) => m
.get(host)
.and_then(|v| v.as_object())
.cloned()
.unwrap_or_default(),
None => run_script(path, &["--host", host])?
.as_object()
.cloned()
.unwrap_or_default(),
};
for (k, v) in vars {
inv.set_host_var(host, &k, v);
}
}
Ok(())
}
fn parse_group(inv: &mut InventoryData, group: &str, data: &Value, hosts: &mut Vec<String>) {
let safe = inv.add_group(group);
let normalized: Map<String, Value> = match data {
Value::Object(o)
if o.contains_key("hosts") || o.contains_key("vars") || o.contains_key("children") =>
{
o.clone()
}
Value::Object(o) => {
let mut m = Map::new();
m.insert(
"hosts".into(),
Value::Array(vec![Value::String(group.to_string())]),
);
m.insert("vars".into(), Value::Object(o.clone()));
m
}
other => {
let mut m = Map::new();
m.insert("hosts".into(), other.clone());
m
}
};
if let Some(Value::Array(list)) = normalized.get("hosts") {
for h in list {
if let Some(name) = h.as_str() {
inv.add_host(name);
inv.add_host_to_group(name, &safe);
if !hosts.iter().any(|x| x == name) {
hosts.push(name.to_string());
}
}
}
}
if let Some(Value::Object(vars)) = normalized.get("vars") {
for (k, v) in vars {
inv.set_group_var(&safe, k, v.clone());
}
}
if let Some(Value::Array(children)) = normalized.get("children") {
for c in children {
if let Some(child) = c.as_str() {
let cs = inv.add_group(child);
inv.add_child(&safe, &cs);
}
}
}
}
fn run_script(path: &Path, args: &[&str]) -> Result<Value> {
let command_path = if path.is_relative() && path.components().count() == 1 {
Path::new(".").join(path)
} else {
path.to_path_buf()
};
let output = Command::new(command_path)
.args(args)
.stdout(Stdio::piped())
.stderr(Stdio::inherit())
.spawn()
.and_then(|child| child.wait_with_output())
.map_err(|e| Error::Io {
path: path.display().to_string(),
source: e,
})?;
if !output.status.success() {
return Err(Error::Parse {
path: path.display().to_string(),
msg: format!("inventory script {args:?} exited with {}", output.status),
});
}
serde_json::from_slice(&output.stdout).map_err(|e| Error::Parse {
path: path.display().to_string(),
msg: format!("invalid JSON from script {args:?}: {e}"),
})
}