nxd_core/domain/selection/

mod.rs

//! Pure expansion of canonical resource selections.

use crate::domain::contract::{CanonicalConfig, Resource};
use crate::domain::host_lifecycle::LifecycleIntent;
use std::collections::BTreeSet;

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ResolvedSelection {
	pub resource_ids: BTreeSet<String>,
	pub lifecycle_intent: Option<LifecycleIntent>,
	pub artifact_set: Option<String>,
}

pub fn resolve(
	config: &CanonicalConfig,
	selectors: &[String],
) -> Result<ResolvedSelection, String> {
	if selectors.is_empty() {
		return Err("selection cannot be empty".to_string());
	}
	let mut resource_ids = BTreeSet::new();
	let mut lifecycle_intent = None;
	let mut artifact_set = None;
	for selector in selectors {
		if let Some(name) = selector.strip_prefix("operation:") {
			let set = config
				.spec
				.operation_sets
				.get(name)
				.ok_or_else(|| format!("operation set {name} was not found"))?;
			if let Some(intent) = set.lifecycle_intent {
				match &lifecycle_intent {
					Some(existing) if *existing != intent => {
						return Err("selected operation sets have conflicting lifecycle intents".to_string());
					}
					None => lifecycle_intent = Some(intent),
					_ => {}
				}
			}
			if let Some(ref art) = set.artifact_set {
				match &artifact_set {
					Some(existing) if existing != art => {
						return Err("selected operation sets have conflicting artifact sets".to_string());
					}
					None => artifact_set = Some(art.clone()),
					_ => {}
				}
			}
			for nested in &set.selectors {
				if nested.starts_with("operation:") {
					return Err(format!("operation set {name} may not include another operation set"));
				}
				expand_one(config, nested, &mut resource_ids)?;
			}
		} else {
			expand_one(config, selector, &mut resource_ids)?;
		}
	}
	Ok(ResolvedSelection { resource_ids, lifecycle_intent, artifact_set })
}

fn expand_one(
	config: &CanonicalConfig,
	selector: &str,
	result: &mut BTreeSet<String>,
) -> Result<(), String> {
	let mut matches = BTreeSet::new();
	if let Some(id) = selector.strip_prefix("resource:") {
		if config.spec.resources.iter().any(|resource| resource_id(resource) == id) {
			matches.insert(id.to_string());
		}
	} else if let Some(host) = selector.strip_prefix("target:") {
		let id = format!("deployment-target/{host}");
		if config.spec.resources.iter().any(|resource| resource_id(resource) == id) {
			matches.insert(id);
		}
	} else if let Some(pattern) = selector.strip_prefix("glob:") {
		for resource in &config.spec.resources {
			if let Resource::DeploymentTarget(target) = resource {
				let host = target.id.strip_prefix("deployment-target/").unwrap_or(&target.id);
				if glob_matches(pattern, host) {
					matches.insert(target.id.clone());
				}
			}
		}
	} else if let Some(role) = selector.strip_prefix("role:") {
		for resource in &config.spec.resources {
			if let Resource::DeploymentTarget(target) = resource
				&& target.metadata.role.as_deref() == Some(role)
			{
				matches.insert(target.id.clone());
			}
		}
	} else if let Some(kind) = selector.strip_prefix("kind:") {
		for resource in &config.spec.resources {
			let value = serde_json::to_value(resource)
				.map_err(|error| format!("failed to inspect resource kind: {error}"))?;
			if value.get("kind").and_then(serde_json::Value::as_str) == Some(kind) {
				matches.insert(resource_id(resource).to_string());
			}
		}
	} else if let Some(provider) = selector.strip_prefix("provider:") {
		for resource in &config.spec.resources {
			let value = serde_json::to_value(resource)
				.map_err(|error| format!("failed to inspect resource provider: {error}"))?;
			if value.get("provider").and_then(serde_json::Value::as_str) == Some(provider) {
				matches.insert(resource_id(resource).to_string());
			}
		}
	} else if let Some(label) = selector.strip_prefix("label:") {
		let (key, expected) =
			label.split_once('=').map_or((label, None), |(key, value)| (key, Some(value)));
		if key.is_empty() || expected == Some("") {
			return Err(format!("invalid label selector {selector}"));
		}
		for resource in &config.spec.resources {
			let labels = match resource {
				Resource::Machine(value) => Some(&value.labels),
				Resource::DeploymentTarget(value) => Some(&value.labels),
				_ => None,
			};
			if labels.is_some_and(|labels| {
				labels.get(key).is_some_and(|value| expected.is_none_or(|expected| value == expected))
			}) {
				matches.insert(resource_id(resource).to_string());
			}
		}
	} else {
		if selector.contains(':') {
			return Err(format!("unsupported selector {selector}"));
		}
		let bare_matches = config
			.spec
			.resources
			.iter()
			.filter(|resource| {
				let id = resource_id(resource);
				id == selector || id.rsplit('/').next() == Some(selector)
			})
			.map(|resource| resource_id(resource).to_string())
			.collect::<BTreeSet<_>>();
		if bare_matches.len() > 1 {
			return Err(format!("selector {selector} is ambiguous; use resource: or target:"));
		}
		matches.extend(bare_matches);
	}
	if matches.is_empty() {
		return Err(format!("selector {selector} matched no resources"));
	}
	result.extend(matches);
	Ok(())
}

fn resource_id(resource: &Resource) -> &str {
	crate::contract::resource_id(resource)
}

fn glob_matches(pattern: &str, value: &str) -> bool {
	fn matches(pattern: &[u8], value: &[u8]) -> bool {
		match pattern {
			[] => value.is_empty(),
			[b'*', rest @ ..] => {
				matches(rest, value) || (!value.is_empty() && matches(pattern, &value[1..]))
			}
			[b'?', rest @ ..] => !value.is_empty() && matches(rest, &value[1..]),
			[head, rest @ ..] => !value.is_empty() && *head == value[0] && matches(rest, &value[1..]),
		}
	}
	!pattern.is_empty() && matches(pattern.as_bytes(), value.as_bytes())
}

#[cfg(test)]
mod tests;