nxd_core/workspace/

source.rs

use crate::config;
use crate::process::Logger;
use std::fs;
use std::io::Write;
use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::time::{SystemTime, UNIX_EPOCH};

mod staging;

pub use staging::{
	ShortLivedTempDir, nix_store_add, stage_host_installer_input, stage_hosts_installer_input,
};

fn snapshot_git_files(source: &Path, destination: &Path) -> Result<(), Box<dyn std::error::Error>> {
	let files = crate::process::sanitized_command("git")
		.args(["ls-files", "-z", "--cached", "--others", "--exclude-standard"])
		.current_dir(source)
		.output()?;
	if !files.status.success() {
		return Err("Failed to list tracked and untracked Git source files.".into());
	}

	// Skip deleted tracked paths still listed by `git ls-files` until the index
	// is updated (dirty working trees mid-refactor).
	let mut present = Vec::new();
	for relative in files.stdout.split(|&byte| byte == 0) {
		if relative.is_empty() {
			continue;
		}
		let path = source.join(std::str::from_utf8(relative)?);
		if path.exists() {
			present.extend_from_slice(relative);
			present.push(0);
		}
	}

	let mut rsync = crate::process::sanitized_command("rsync")
		.args(["-a", "--from0", "--files-from=-", "./"])
		.arg(format!("{}/", destination.display()))
		.current_dir(source)
		.stdin(Stdio::piped())
		.spawn()?;
	rsync.stdin.take().ok_or("Failed to open rsync input")?.write_all(&present)?;
	if !rsync.wait()?.success() {
		return Err("Failed to snapshot tracked and untracked Git source files.".into());
	}
	Ok(())
}

fn metadata_source_cache_root() -> PathBuf {
	let cache_home = std::env::var("XDG_CACHE_HOME").map(PathBuf::from).unwrap_or_else(|_| {
		let home = std::env::var("HOME").unwrap_or_else(|_| "/tmp".to_string());
		PathBuf::from(home).join(".cache")
	});
	cache_home.join(config::APP_NAME).join("metadata-sources").join("v1")
}

fn git_output(source: &Path, args: &[&str]) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
	let output = crate::process::sanitized_command("git")
		.args(args)
		.current_dir(source)
		.output()
		.map_err(|error| format!("Failed to inspect Git metadata: {error}"))?;
	if !output.status.success() {
		return Err(
			format!("Git metadata inspection failed: {}", String::from_utf8_lossy(&output.stderr).trim())
				.into(),
		);
	}
	Ok(output.stdout)
}

fn append_untracked_content(
	source: &Path,
	paths: &[u8],
	fingerprint: &mut Vec<u8>,
) -> Result<(), Box<dyn std::error::Error>> {
	#[cfg(unix)]
	{
		use std::ffi::OsString;
		use std::os::unix::ffi::OsStringExt;

		for raw_path in paths.split(|byte| *byte == 0).filter(|path| !path.is_empty()) {
			let relative = PathBuf::from(OsString::from_vec(raw_path.to_vec()));
			if relative.is_absolute()
				|| relative.components().any(|component| {
					matches!(
						component,
						std::path::Component::ParentDir
							| std::path::Component::RootDir
							| std::path::Component::Prefix(_)
					)
				}) {
				return Err("Git returned an unsafe untracked source path.".into());
			}
			let path = source.join(&relative);
			let metadata = fs::symlink_metadata(&path)?;
			fingerprint.extend_from_slice(&(raw_path.len() as u64).to_be_bytes());
			fingerprint.extend_from_slice(raw_path);
			if metadata.file_type().is_symlink() {
				let target = fs::read_link(path)?;
				let target = target.as_os_str().as_encoded_bytes();
				fingerprint.extend_from_slice(&(target.len() as u64).to_be_bytes());
				fingerprint.extend_from_slice(target);
			} else if metadata.is_file() {
				let content = fs::read(path)?;
				fingerprint.extend_from_slice(&(content.len() as u64).to_be_bytes());
				fingerprint.extend_from_slice(&content);
			} else {
				return Err("Git source contains an unsupported untracked file type.".into());
			}
		}
		Ok(())
	}
	#[cfg(not(unix))]
	{
		let _ = (source, paths, fingerprint);
		Err("Git metadata snapshots require a Unix platform.".into())
	}
}

fn metadata_eval_source_ref_with_cache(
	source: &Path,
	cache_root: &Path,
) -> Result<String, Box<dyn std::error::Error>> {
	let head = git_output(source, &["rev-parse", "--verify", "HEAD"])?;
	let diff = git_output(source, &["diff", "--binary", "--no-ext-diff", "HEAD", "--"])?;
	let untracked = git_output(source, &["ls-files", "-z", "--others", "--exclude-standard"])?;

	if diff.is_empty() && untracked.is_empty() {
		let revision = String::from_utf8(head)?.trim().to_string();
		return Ok(format!("git+file://{}?rev={revision}", source.display()));
	}

	let mut fingerprint = b"nxd-metadata-source-v1\0".to_vec();
	fingerprint.extend_from_slice(&head);
	fingerprint.extend_from_slice(&diff);
	fingerprint.extend_from_slice(&untracked);
	append_untracked_content(source, &untracked, &mut fingerprint)?;
	let digest = crate::plan::sha256_hex_bytes(&fingerprint);
	let cache_entry = cache_root.join(&digest);
	let cached_source = cache_entry.join("source");
	let complete = cache_entry.join(".complete");
	if complete.is_file() && cached_source.join("flake.nix").is_file() {
		return Ok(format!("path:{}", cached_source.display()));
	}

	fs::create_dir_all(cache_root)?;
	#[cfg(unix)]
	{
		use std::os::unix::fs::PermissionsExt;
		fs::set_permissions(cache_root, fs::Permissions::from_mode(0o700))?;
	}

	let temporary =
		cache_root.join(format!(".{digest}-{}", crate::workspace::local::unique_suffix()));
	let temporary_source = temporary.join("source");
	fs::create_dir_all(&temporary_source)?;
	snapshot_git_files(source, &temporary_source)?;
	if !temporary_source.join("flake.nix").is_file() {
		let _ = fs::remove_dir_all(&temporary);
		return Err("Metadata source snapshot does not contain flake.nix.".into());
	}
	fs::write(temporary.join(".complete"), b"nxd-metadata-source-v1\n")?;

	match fs::rename(&temporary, &cache_entry) {
		Ok(()) => {}
		Err(_) if complete.is_file() && cached_source.join("flake.nix").is_file() => {
			let _ = fs::remove_dir_all(&temporary);
		}
		Err(error) => {
			let _ = fs::remove_dir_all(&temporary);
			return Err(format!("Failed to publish metadata source cache: {error}").into());
		}
	}

	Ok(format!("path:{}", cached_source.display()))
}

pub fn metadata_eval_source_ref(source: &Path) -> Result<String, Box<dyn std::error::Error>> {
	metadata_eval_source_ref_with_cache(source, &metadata_source_cache_root())
}

pub fn clean_stale_gc_roots(_logger: Logger) {
	let state_home = std::env::var("XDG_STATE_HOME").map(PathBuf::from).unwrap_or_else(|_| {
		let home = std::env::var("HOME").unwrap_or_else(|_| "/tmp".to_string());
		PathBuf::from(home).join(".local").join("state")
	});
	let gcroots_base = state_home.join(config::APP_NAME).join("gcroots");
	if !gcroots_base.exists() {
		return;
	}

	let Ok(entries) = fs::read_dir(&gcroots_base) else {
		return;
	};

	let seven_days = 7 * 24 * 60 * 60;
	let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs();

	for entry in entries.flatten() {
		let path = entry.path();
		if path.is_dir() {
			let marker = path.join("run.timestamp");
			let mut is_stale = false;
			if marker.exists() {
				if fs::read_to_string(&marker)
					.ok()
					.and_then(|c| c.trim().parse::<u64>().ok())
					.filter(|&timestamp| now > timestamp + seven_days)
					.is_some()
				{
					is_stale = true;
				}
			} else if fs::metadata(&path)
				.ok()
				.and_then(|m| m.modified().ok())
				.and_then(|t| SystemTime::now().duration_since(t).ok())
				.filter(|duration| duration.as_secs() > seven_days)
				.is_some()
			{
				is_stale = true;
			}

			if is_stale {
				eprintln!("Cleaning up stale local GC root directory: {}", path.display());
				let _ = fs::remove_dir_all(&path);
			}
		}
	}
}

#[cfg(test)]
mod tests;