#[cfg(test)]
use std::cell::RefCell;
use std::collections::{BTreeMap, BTreeSet};
use std::fs;
use std::os::unix::fs as unix_fs;
use std::path::{Path, PathBuf};
use serde::Serialize;
use crate::error::{DaloError, DaloResult};
use crate::inventory::{SkillDelivery, SkillDeliveryMode};
use crate::resolver::{
BlockedSkill, ClosureBlockReason, Resolution, ResolutionDiagnostic, ResolutionDiagnosticCode,
ResolvedSkill, closure_block_reason_name,
};
use crate::store::{self, OwnedSkillState, StateFile, StorePaths};
#[cfg(test)]
thread_local! {
static TEST_APPLY_FAILURE_PATH: RefCell<Option<PathBuf>> = const { RefCell::new(None) };
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct DegradedSource {
pub id: String,
pub path: PathBuf,
pub reason: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct MissingSkillCommand {
pub source_ref: String,
pub command: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub compatibility: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct SyncReport {
pub store: PathBuf,
pub dry_run: bool,
pub linked_targets: usize,
pub operations: Vec<MaterializeOperation>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub deliveries: Vec<SkillDeliveryReport>,
pub resolution: Resolution,
pub degraded_sources: Vec<DegradedSource>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub inventory_warnings: Vec<crate::inventory::InventoryWarning>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub missing_commands: Vec<MissingSkillCommand>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub unrefreshed_tracking_sources: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub manifest_catalogs: Vec<crate::team_manifest::ManifestCatalogSyncReport>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub instruction_operations: Vec<crate::instructions::InstructionSyncOperation>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub instruction_removal_operations: Vec<crate::instructions::InstructionRemovalOperation>,
pub unselected_catalogs: Vec<UnselectedCatalog>,
#[serde(skip_serializing_if = "Option::is_none")]
pub installation_plan: Option<crate::plan::InstallationPlan>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub hook_targets: Vec<crate::hook_sync::HookTargetReport>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub plugin_targets: Vec<crate::plugin_projection::PluginTargetReport>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct SkillDeliveryReport {
pub target_ids: Vec<String>,
pub source_ref: String,
pub link_path: PathBuf,
pub mode: SkillDeliveryMode,
#[serde(skip_serializing_if = "Option::is_none")]
pub provider: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub artifact_path: Option<PathBuf>,
#[serde(skip_serializing_if = "Option::is_none")]
pub planned_output: Option<PathBuf>,
#[serde(skip_serializing_if = "Option::is_none")]
pub fingerprint: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cache_state: Option<crate::delivery::GeneratedCacheState>,
#[serde(skip_serializing_if = "Option::is_none")]
pub derivation_hash: Option<String>,
pub blocked: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct UnselectedCatalog {
pub source_id: String,
pub available_skills: usize,
}
#[derive(Debug)]
pub struct MaterializationRollback {
state: StateFile,
links: Vec<LinkSnapshot>,
}
#[derive(Debug)]
struct LinkSnapshot {
path: PathBuf,
target: Option<PathBuf>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct MaterializeOperation {
pub kind: MaterializeOperationKind,
pub link_path: PathBuf,
pub desired_path: Option<PathBuf>,
pub status: MaterializeOperationStatus,
pub reason: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum MaterializeOperationKind {
Create,
Relink,
Remove,
DropRecord,
Conflict,
Keep,
NoOp,
}
impl MaterializeOperationKind {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Create => "create",
Self::Relink => "relink",
Self::Remove => "remove",
Self::DropRecord => "drop_record",
Self::Conflict => "conflict",
Self::Keep => "keep",
Self::NoOp => "noop",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum MaterializeOperationStatus {
Planned,
Applied,
Existing,
Blocked,
}
impl MaterializeOperationStatus {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Planned => "planned",
Self::Applied => "applied",
Self::Existing => "existing",
Self::Blocked => "blocked",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct DesiredLink {
target_id: String,
target_ids: Vec<String>,
source_ref: String,
slot_name: String,
link_path: PathBuf,
store_path: PathBuf,
delivery_mode: SkillDeliveryMode,
provider: Option<String>,
fingerprint: Option<String>,
cache_state: Option<crate::delivery::GeneratedCacheState>,
derivation_hash: Option<String>,
planned_output: Option<PathBuf>,
blocked_reason: Option<String>,
withdraw_on_block: bool,
}
pub(crate) fn materialize_assistant(
paths: &StorePaths,
target: &str,
) -> DaloResult<Vec<MaterializeOperation>> {
materialize_assistant_using(paths, target, store::write_user_lock)
}
fn materialize_assistant_using(
paths: &StorePaths,
target: &str,
write_lock: impl FnOnce(&StorePaths, &crate::lockfile::UserLock) -> DaloResult<()>,
) -> DaloResult<Vec<MaterializeOperation>> {
let mut state = store::read_state(paths)?;
let mut lock = store::read_user_lock(paths)?;
let links = state
.materialization_dirs
.iter()
.filter(|dir| dir.logical_targets.iter().any(|id| id == target))
.map(|dir| DesiredLink {
target_id: dir.logical_targets[0].clone(),
target_ids: dir.logical_targets.clone(),
source_ref: "local:dalo".to_owned(),
slot_name: "dalo".to_owned(),
link_path: dir.path.join("dalo"),
store_path: paths.local_skills_dir.join("dalo"),
delivery_mode: SkillDeliveryMode::Direct,
provider: None,
fingerprint: None,
cache_state: None,
derivation_hash: None,
planned_output: None,
blocked_reason: None,
withdraw_on_block: false,
})
.collect::<Vec<_>>();
let mut scoped_state = state.clone();
scoped_state
.owned_skills
.retain(|owned| links.iter().any(|link| link.link_path == owned.link_path));
let mut operations = build_plan(paths, &scoped_state, &links, &[])?;
let rollback = Some(MaterializationRollback {
state: state.clone(),
links: snapshot_links(&operations)?,
});
if let Err(error) = apply_plan(paths, &mut scoped_state, &mut operations, &links) {
return Err(rollback_materialization_failure(paths, rollback, error));
}
state
.owned_skills
.retain(|owned| !links.iter().any(|link| link.link_path == owned.link_path));
state.owned_skills.extend(scoped_state.owned_skills);
if let Err(error) = store::write_state(paths, &state) {
return Err(rollback_materialization_failure(paths, rollback, error));
}
if operations.iter().any(|operation| {
matches!(
operation.kind,
MaterializeOperationKind::Create | MaterializeOperationKind::NoOp
) && operation.status != MaterializeOperationStatus::Blocked
}) {
if !lock
.active_skills
.iter()
.any(|skill| skill.source_ref == "local:dalo")
{
lock.active_skills.push(crate::lockfile::LockedSkill {
source_ref: "local:dalo".to_owned(),
slot_name: "dalo".to_owned(),
id: None,
source_id: "local".to_owned(),
source_kind: crate::source::SourceKind::Local,
delivery: None,
reason: None,
});
lock.active_skills
.sort_by(|left, right| left.source_ref.cmp(&right.source_ref));
}
if !lock.sources.iter().any(|source| source.id == "local") {
lock.sources.push(crate::lockfile::LockedSource {
id: "local".to_owned(),
kind: crate::source::SourceKind::Local,
path: paths.local_dir.clone(),
subpath: None,
commit: crate::git::rev_parse_head(&paths.local_dir).ok(),
});
lock.sources.sort_by(|left, right| left.id.cmp(&right.id));
}
lock.target_materializations.retain(|entry| {
!operations
.iter()
.any(|operation| operation.link_path == entry.link_path)
});
lock.target_materializations
.extend(operations.iter().map(|operation| {
crate::lockfile::LockedTargetMaterialization {
link_path: operation.link_path.clone(),
desired_path: operation.desired_path.clone(),
kind: operation.kind.as_str().to_owned(),
status: operation.status.as_str().to_owned(),
reason: operation.reason.clone(),
}
}));
lock.target_materializations
.sort_by(|left, right| left.link_path.cmp(&right.link_path));
if let Err(error) = write_lock(paths, &lock) {
return Err(rollback_materialization_failure(paths, rollback, error));
}
}
Ok(operations)
}
pub fn materialize(
paths: &StorePaths,
resolution: &Resolution,
dry_run: bool,
) -> DaloResult<SyncReport> {
materialize_with_degraded_sources(paths, resolution, dry_run, &[])
}
pub fn materialize_with_degraded_sources(
paths: &StorePaths,
resolution: &Resolution,
dry_run: bool,
degraded_sources: &[DegradedSource],
) -> DaloResult<SyncReport> {
let (report, _) =
materialize_with_degraded_sources_rollback(paths, resolution, dry_run, degraded_sources)?;
Ok(report)
}
pub fn materialize_with_degraded_sources_rollback(
paths: &StorePaths,
resolution: &Resolution,
dry_run: bool,
degraded_sources: &[DegradedSource],
) -> DaloResult<(SyncReport, Option<MaterializationRollback>)> {
let mut state = store::read_state(paths)?;
let mut resolution = resolution.clone();
let all_skills = resolution.active_skills.clone();
let revoked_generated = revoked_generated_deliveries(paths, &resolution)?;
let needed_generated = needed_generated_deliveries(&state, &resolution);
let generated = crate::delivery::prepare_generated_artifacts(
paths,
&resolution,
&needed_generated,
dry_run,
)?;
let all_links = desired_links(&state, &resolution, &generated, &revoked_generated);
let mut suppressed_links = BTreeSet::new();
let mut protected_suppressed_links = BTreeSet::new();
let mut suppressed_link_reasons = BTreeMap::new();
let mut links = all_links.clone();
let mut operations = build_plan(paths, &state, &links, degraded_sources)?;
while block_link_time_dependents(
&mut resolution,
&all_skills,
&all_links,
&operations,
&mut suppressed_links,
&mut protected_suppressed_links,
&mut suppressed_link_reasons,
) {
links = desired_links(&state, &resolution, &generated, &revoked_generated)
.into_iter()
.filter(|link| !suppressed_links.contains(&link.link_path))
.collect();
operations = build_plan(paths, &state, &links, degraded_sources)?;
}
let rollback = if dry_run {
None
} else {
Some(MaterializationRollback {
state: state.clone(),
links: snapshot_links(&operations)?,
})
};
if dry_run {
for operation in &mut operations {
if operation.status != MaterializeOperationStatus::Blocked
&& operation.status != MaterializeOperationStatus::Existing
{
operation.status = MaterializeOperationStatus::Planned;
}
}
} else {
loop {
if let Err(error) = apply_plan(paths, &mut state, &mut operations, &links) {
return Err(rollback_materialization_failure(paths, rollback, error));
}
if !block_link_time_dependents(
&mut resolution,
&all_skills,
&all_links,
&operations,
&mut suppressed_links,
&mut protected_suppressed_links,
&mut suppressed_link_reasons,
) {
break;
}
links = desired_links(&state, &resolution, &generated, &revoked_generated)
.into_iter()
.filter(|link| !suppressed_links.contains(&link.link_path))
.collect();
operations = match build_plan(paths, &state, &links, degraded_sources) {
Ok(operations) => operations,
Err(error) => {
if let Some(rollback) = rollback
&& let Err(rollback_error) = rollback.restore(paths)
{
return Err(std::io::Error::other(format!(
"{error}; additionally failed to roll back sync: {rollback_error}"
))
.into());
}
return Err(error);
}
};
}
if let Err(error) = crate::delivery::verify_generated_source_snapshots(paths, &resolution) {
return Err(rollback_materialization_failure(paths, rollback, error));
}
if let Err(error) = store::write_state(paths, &state) {
if let Some(rollback) = rollback
&& let Err(rollback_error) = rollback.restore(paths)
{
return Err(std::io::Error::other(format!(
"{error}; additionally failed to roll back sync: {rollback_error}"
))
.into());
}
return Err(error);
}
}
append_closure_operations(
&mut operations,
&all_links,
&suppressed_links,
&protected_suppressed_links,
&suppressed_link_reasons,
);
let deliveries = delivery_reports(&all_links, &operations);
Ok((
SyncReport {
store: paths.root.clone(),
dry_run,
linked_targets: state.targets.iter().filter(|target| target.enabled).count(),
operations,
deliveries,
resolution,
degraded_sources: degraded_sources.to_vec(),
inventory_warnings: Vec::new(),
missing_commands: Vec::new(),
unrefreshed_tracking_sources: Vec::new(),
manifest_catalogs: Vec::new(),
instruction_operations: Vec::new(),
instruction_removal_operations: Vec::new(),
unselected_catalogs: Vec::new(),
installation_plan: None,
hook_targets: Vec::new(),
plugin_targets: Vec::new(),
},
rollback,
))
}
pub(crate) fn missing_skill_commands<'a>(
active_skills: &[ResolvedSkill],
inventories: impl IntoIterator<Item = &'a crate::inventory::SourceInventory>,
) -> Vec<MissingSkillCommand> {
let mut missing = Vec::new();
for check in crate::inventory::check_declared_commands(active_skills, inventories) {
for command in check.missing {
missing.push(MissingSkillCommand {
source_ref: check.source_ref.clone(),
command,
compatibility: check.compatibility.clone(),
});
}
}
missing
}
fn delivery_reports(
desired_links: &[DesiredLink],
operations: &[MaterializeOperation],
) -> Vec<SkillDeliveryReport> {
let mut reports = desired_links
.iter()
.map(|desired| {
let operation = operations
.iter()
.find(|operation| operation.link_path == desired.link_path);
let blocked = desired.blocked_reason.is_some()
|| operation.is_some_and(|operation| {
operation.status == MaterializeOperationStatus::Blocked
});
SkillDeliveryReport {
target_ids: desired.target_ids.clone(),
source_ref: desired.source_ref.clone(),
link_path: desired.link_path.clone(),
mode: desired.delivery_mode,
provider: (!blocked).then(|| desired.provider.clone()).flatten(),
artifact_path: (!blocked).then(|| desired.store_path.clone()),
planned_output: desired.planned_output.clone(),
fingerprint: (desired.delivery_mode == SkillDeliveryMode::Generated || !blocked)
.then(|| desired.fingerprint.clone())
.flatten(),
cache_state: desired.cache_state,
derivation_hash: desired.derivation_hash.clone(),
blocked,
reason: desired.blocked_reason.clone().or_else(|| {
operation
.filter(|operation| operation.status == MaterializeOperationStatus::Blocked)
.and_then(|operation| operation.reason.clone())
}),
}
})
.collect::<Vec<_>>();
reports.sort_by(|left, right| left.link_path.cmp(&right.link_path));
reports
}
impl MaterializationRollback {
pub fn restore(self, paths: &StorePaths) -> DaloResult<()> {
for snapshot in self.links {
match fs::symlink_metadata(&snapshot.path) {
Ok(metadata) if metadata.file_type().is_symlink() => {
fs::remove_file(&snapshot.path)?
}
Ok(_) => {
return Err(std::io::Error::other(format!(
"cannot roll back {}; it was replaced with a non-symlink entry",
snapshot.path.display()
))
.into());
}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
Err(error) => return Err(error.into()),
}
if let Some(target) = snapshot.target {
if let Some(parent) = snapshot.path.parent() {
fs::create_dir_all(parent)?;
}
unix_fs::symlink(target, snapshot.path)?;
}
}
store::write_state(paths, &self.state)
}
}
fn snapshot_links(operations: &[MaterializeOperation]) -> DaloResult<Vec<LinkSnapshot>> {
let mut snapshots = Vec::new();
let mut seen = BTreeSet::new();
for operation in operations.iter().filter(|operation| {
matches!(
operation.kind,
MaterializeOperationKind::Create
| MaterializeOperationKind::Relink
| MaterializeOperationKind::Remove
| MaterializeOperationKind::NoOp
) && operation.status != MaterializeOperationStatus::Blocked
}) {
if !seen.insert(operation.link_path.clone()) {
continue;
}
let target = match fs::symlink_metadata(&operation.link_path) {
Ok(metadata) if metadata.file_type().is_symlink() => {
Some(fs::read_link(&operation.link_path)?)
}
Ok(_) => {
return Err(std::io::Error::other(format!(
"cannot snapshot non-symlink materialization path {}",
operation.link_path.display()
))
.into());
}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => None,
Err(error) => return Err(error.into()),
};
snapshots.push(LinkSnapshot {
path: operation.link_path.clone(),
target,
});
}
Ok(snapshots)
}
fn block_link_time_dependents(
resolution: &mut Resolution,
all_skills: &[ResolvedSkill],
all_links: &[DesiredLink],
operations: &[MaterializeOperation],
suppressed_links: &mut BTreeSet<PathBuf>,
protected_suppressed_links: &mut BTreeSet<PathBuf>,
suppressed_link_reasons: &mut BTreeMap<PathBuf, String>,
) -> bool {
let direct_blocked = operations
.iter()
.filter(|operation| operation.status == MaterializeOperationStatus::Blocked)
.filter_map(|operation| {
all_links
.iter()
.find(|desired| desired.link_path == operation.link_path)
})
.filter_map(|desired| {
all_skills
.iter()
.find(|skill| {
skill.slot_name == desired.slot_name && skill.path == desired.store_path
})
.map(|skill| (link_scope(desired), skill.source_ref.clone()))
})
.collect::<BTreeSet<_>>();
let direct_protected = operations
.iter()
.filter(|operation| operation.kind == MaterializeOperationKind::Keep)
.filter_map(|operation| {
all_links
.iter()
.find(|desired| desired.link_path == operation.link_path)
})
.filter_map(|desired| {
all_skills
.iter()
.find(|skill| {
skill.slot_name == desired.slot_name && skill.path == desired.store_path
})
.map(|skill| (link_scope(desired), skill.source_ref.clone()))
})
.collect::<BTreeSet<_>>();
let direct_unavailable = direct_blocked
.union(&direct_protected)
.cloned()
.collect::<BTreeSet<_>>();
if direct_unavailable.is_empty() {
return false;
}
let mut unavailable = direct_unavailable;
let mut protected_unavailable = direct_protected;
for desired in all_links
.iter()
.filter(|desired| suppressed_links.contains(&desired.link_path))
{
if let Some(skill) = all_skills
.iter()
.find(|skill| skill.slot_name == desired.slot_name && skill.path == desired.store_path)
{
let key = (link_scope(desired), skill.source_ref.clone());
unavailable.insert(key.clone());
if protected_suppressed_links.contains(&desired.link_path) {
protected_unavailable.insert(key);
}
}
}
let mut block_causes = BTreeMap::new();
let mut links_changed = false;
loop {
let mut pass_changed = false;
for desired in all_links {
if suppressed_links.contains(&desired.link_path) {
continue;
}
let Some(dependent) = all_skills.iter().find(|skill| {
skill.slot_name == desired.slot_name && skill.path == desired.store_path
}) else {
continue;
};
let scope = link_scope(desired);
let Some((requirement, required_ref, reason, protected_chain)) =
dependent.requires.iter().find_map(|requirement| {
let required = all_skills.iter().find(|candidate| {
candidate.source_id == dependent.source_id
&& requirement_matches_skill(requirement, dependent, candidate)
})?;
let required_key = (scope.clone(), required.source_ref.clone());
if dependent.source_ref == required.source_ref
|| !unavailable.contains(&required_key)
{
return None;
}
let reason = if direct_blocked.contains(&required_key) {
ClosureBlockReason::SameNameBlocked
} else {
ClosureBlockReason::Unlinked
};
let protected_chain = protected_unavailable.contains(&required_key);
Some((
requirement.clone(),
required.source_ref.clone(),
reason,
protected_chain,
))
})
else {
continue;
};
suppressed_links.insert(desired.link_path.clone());
suppressed_link_reasons.insert(
desired.link_path.clone(),
format!(
"required closure blocked: `{requirement}` is {} at this target",
closure_block_reason_name(reason)
),
);
let dependent_key = (scope.clone(), dependent.source_ref.clone());
unavailable.insert(dependent_key.clone());
if protected_chain {
protected_unavailable.insert(dependent_key);
protected_suppressed_links.insert(desired.link_path.clone());
}
block_causes.insert(
(scope, dependent.source_ref.clone()),
(requirement, required_ref, reason, protected_chain),
);
pass_changed = true;
links_changed = true;
}
if !pass_changed {
break;
}
}
let mut new_blocks = Vec::new();
let mut index = 0;
while index < resolution.active_skills.len() {
let skill = &resolution.active_skills[index];
let skill_links = all_links
.iter()
.filter(|desired| {
desired.slot_name == skill.slot_name && desired.store_path == skill.path
})
.collect::<Vec<_>>();
if skill_links.is_empty()
|| !skill_links
.iter()
.all(|desired| suppressed_links.contains(&desired.link_path))
{
index += 1;
continue;
}
let cause = skill_links
.iter()
.filter_map(|desired| {
block_causes.get(&(link_scope(desired), skill.source_ref.clone()))
})
.find(|(_, _, _, protected_chain)| !protected_chain);
let Some((requirement, _, reason, _)) = cause.cloned() else {
index += 1;
continue;
};
let skill = resolution.active_skills.remove(index);
new_blocks.push(BlockedSkill {
skill,
requirement,
reason,
});
}
if new_blocks.is_empty() {
return links_changed;
}
for block in new_blocks {
resolution.diagnostics.push(ResolutionDiagnostic {
code: ResolutionDiagnosticCode::RequiredBlocked,
message: format!(
"skill `{}` is blocked: requirement `{}` is {}",
block.skill.source_ref,
block.requirement,
closure_block_reason_name(block.reason)
),
source_ref: Some(block.skill.source_ref.clone()),
});
resolution.blocked_skills.push(block);
}
resolution
.blocked_skills
.sort_by(|left, right| left.skill.source_ref.cmp(&right.skill.source_ref));
resolution.diagnostics.sort_by(|left, right| {
left.source_ref
.cmp(&right.source_ref)
.then_with(|| left.message.cmp(&right.message))
});
true
}
fn append_closure_operations(
operations: &mut Vec<MaterializeOperation>,
all_links: &[DesiredLink],
suppressed_links: &BTreeSet<PathBuf>,
protected_suppressed_links: &BTreeSet<PathBuf>,
suppressed_link_reasons: &BTreeMap<PathBuf, String>,
) {
let existing_paths = operations
.iter()
.map(|operation| operation.link_path.clone())
.collect::<BTreeSet<_>>();
for desired in all_links.iter().filter(|desired| {
suppressed_links.contains(&desired.link_path)
&& !existing_paths.contains(&desired.link_path)
}) {
let protected = protected_suppressed_links.contains(&desired.link_path);
operations.push(MaterializeOperation {
kind: if protected {
MaterializeOperationKind::Keep
} else {
MaterializeOperationKind::Conflict
},
link_path: desired.link_path.clone(),
desired_path: Some(desired.store_path.clone()),
status: if protected {
MaterializeOperationStatus::Existing
} else {
MaterializeOperationStatus::Blocked
},
reason: Some(if protected {
"required closure kept because a required slot is protected".to_owned()
} else {
suppressed_link_reasons
.get(&desired.link_path)
.cloned()
.unwrap_or_else(|| "required closure blocked at this target".to_owned())
}),
});
}
operations.sort_by(|left, right| left.link_path.cmp(&right.link_path));
}
fn link_scope(desired: &DesiredLink) -> PathBuf {
desired
.link_path
.parent()
.map_or_else(PathBuf::new, Path::to_path_buf)
}
fn requirement_matches_skill(
requirement: &str,
dependent: &ResolvedSkill,
candidate: &ResolvedSkill,
) -> bool {
candidate.slot_name
== crate::resolver::materialized_slot_name(
dependent.source_namespace.as_deref(),
requirement,
)
|| candidate.source_ref == requirement
|| candidate.id.as_deref() == Some(requirement)
}
fn needed_generated_deliveries(state: &StateFile, resolution: &Resolution) -> BTreeSet<String> {
let mut needed = BTreeSet::new();
for dir in &state.materialization_dirs {
for skill in &resolution.active_skills {
let SkillDelivery::Generated { providers, .. } = &skill.delivery else {
continue;
};
let outputs = dir
.logical_targets
.iter()
.map(|target| providers.get(target))
.collect::<Option<BTreeSet<_>>>();
if outputs.is_some_and(|outputs| outputs.len() == 1) {
needed.insert(skill.source_ref.clone());
}
}
}
needed
}
fn revoked_generated_deliveries(
paths: &StorePaths,
resolution: &Resolution,
) -> DaloResult<BTreeSet<String>> {
let approvals = store::read_approvals(paths)?;
Ok(resolution
.active_skills
.iter()
.filter_map(|skill| {
let SkillDelivery::Generated {
source_commit,
recipe_approved,
..
} = &skill.delivery
else {
return None;
};
let stable_ref = skill
.id
.as_ref()
.map(|id| format!("{}:{id}", skill.source_id))?;
(source_commit.is_some()
&& !recipe_approved
&& !crate::delivery::approval_is_recorded_for_delivery(
&approvals.approvals,
&skill.source_ref,
&stable_ref,
))
.then(|| skill.source_ref.clone())
})
.collect())
}
fn desired_links(
state: &StateFile,
resolution: &Resolution,
generated: &BTreeMap<String, crate::delivery::GeneratedArtifactSet>,
revoked_generated: &BTreeSet<String>,
) -> Vec<DesiredLink> {
let mut links = Vec::new();
for dir in &state.materialization_dirs {
let Some(target_id) = dir.logical_targets.first() else {
continue;
};
for skill in &resolution.active_skills {
if let SkillDelivery::Generated {
providers,
recipe_hash,
source_commit,
recipe_approved,
generator_approved,
generator,
..
} = &skill.delivery
{
let selected = dir
.logical_targets
.iter()
.map(|target| (target, providers.get(target)))
.collect::<Vec<_>>();
let missing = selected
.iter()
.filter(|(_, output)| output.is_none())
.map(|(target, _)| (*target).clone())
.collect::<Vec<_>>();
let outputs = selected
.iter()
.filter_map(|(_, output)| output.as_ref().copied())
.collect::<BTreeSet<_>>();
let prepared = generated.get(&skill.source_ref);
let artifact = selected
.first()
.and_then(|(target, _)| prepared.and_then(|set| set.providers.get(*target)));
let blocked_reason = if !missing.is_empty() {
format!(
"generated delivery for `{}` has no output mapping for target{} {}",
skill.source_ref,
if missing.len() == 1 { "" } else { "s" },
missing.join(", ")
)
} else if outputs.len() > 1 {
format!(
"logical targets {} share one physical directory but `{}` declares different generated outputs",
dir.logical_targets.join(", "),
skill.source_ref
)
} else if source_commit.is_none() {
format!(
"generated delivery for `{}` requires immutable Git source provenance",
skill.source_ref
)
} else if !recipe_approved {
format!(
"generated delivery recipe for `{}` requires approval; run `dalo approve delivery {}`",
skill.source_ref, skill.source_ref
)
} else if !generator_approved {
format!(
"generated delivery for `{}` requires approval of generator tool `{generator}`; run `dalo approve tool {generator}`",
skill.source_ref,
)
} else if prepared.is_some_and(|set| {
set.cache_state == crate::delivery::GeneratedCacheState::Miss
}) {
format!(
"generated delivery for `{}` has no cached output; a real sync will execute the approved generator",
skill.source_ref
)
} else if artifact.is_none() {
format!(
"generated delivery for `{}` has no verified provider artifact",
skill.source_ref
)
} else {
String::new()
};
links.push(DesiredLink {
target_id: target_id.clone(),
target_ids: dir.logical_targets.clone(),
source_ref: skill.source_ref.clone(),
slot_name: skill.slot_name.clone(),
link_path: dir.path.join(&skill.slot_name),
store_path: artifact.map_or_else(
|| prepared.map_or_else(|| skill.path.clone(), |set| set.root.clone()),
|artifact| artifact.path.clone(),
),
delivery_mode: SkillDeliveryMode::Generated,
provider: selected
.first()
.and_then(|(target, output)| output.map(|_| (*target).clone())),
fingerprint: artifact
.map(|artifact| artifact.fingerprint.clone())
.or_else(|| Some(format!("sha256:{recipe_hash}"))),
cache_state: prepared.map(|set| set.cache_state),
derivation_hash: prepared.map(|set| set.derivation_hash.clone()),
planned_output: outputs.first().map(|path| (*path).clone()),
blocked_reason: (!blocked_reason.is_empty()).then_some(blocked_reason),
withdraw_on_block: revoked_generated.contains(&skill.source_ref),
});
continue;
}
let selected = dir
.logical_targets
.iter()
.map(|target| (target, skill.delivery.artifact_for(target, &skill.path)))
.collect::<Vec<_>>();
let missing = selected
.iter()
.filter(|(_, artifact)| artifact.is_none())
.map(|(target, _)| (*target).clone())
.collect::<Vec<_>>();
let artifacts = selected
.iter()
.filter_map(|(_, artifact)| artifact.as_ref())
.collect::<Vec<_>>();
let artifact_paths = artifacts
.iter()
.map(|artifact| artifact.path.clone())
.collect::<BTreeSet<_>>();
let blocked_reason = if !missing.is_empty() {
Some(format!(
"prebuilt delivery for `{}` has no mapping for target{} {}; add provider mapping{} or enable universal_fallback",
skill.source_ref,
if missing.len() == 1 { "" } else { "s" },
missing.join(", "),
if missing.len() == 1 { "" } else { "s" }
))
} else if artifact_paths.len() > 1 {
Some(format!(
"logical targets {} share one physical directory but `{}` selects different provider artifacts",
dir.logical_targets.join(", "),
skill.source_ref
))
} else {
None
};
let artifact = artifacts.first().copied();
let provider = artifact.and_then(|first| {
artifacts
.iter()
.all(|artifact| artifact.provider == first.provider)
.then(|| first.provider.clone())
.flatten()
});
links.push(DesiredLink {
target_id: target_id.clone(),
target_ids: dir.logical_targets.clone(),
source_ref: skill.source_ref.clone(),
slot_name: skill.slot_name.clone(),
link_path: dir.path.join(&skill.slot_name),
store_path: artifact.map_or_else(|| skill.path.clone(), |item| item.path.clone()),
delivery_mode: skill.delivery.mode(),
provider,
fingerprint: artifact.and_then(|item| item.fingerprint.clone()),
cache_state: None,
derivation_hash: None,
planned_output: None,
blocked_reason,
withdraw_on_block: false,
});
}
}
links.sort_by(|left, right| left.link_path.cmp(&right.link_path));
links
}
fn build_plan(
paths: &StorePaths,
state: &StateFile,
desired_links: &[DesiredLink],
degraded_sources: &[DegradedSource],
) -> DaloResult<Vec<MaterializeOperation>> {
let desired_by_link = desired_links
.iter()
.map(|desired| (desired.link_path.clone(), desired))
.collect::<BTreeMap<_, _>>();
let recorded_by_link = state
.owned_skills
.iter()
.map(|record| (record.link_path.clone(), record))
.collect::<BTreeMap<_, _>>();
let all_links = desired_by_link
.keys()
.chain(recorded_by_link.keys())
.cloned()
.collect::<BTreeSet<_>>();
let mut operations = Vec::new();
for link_path in all_links {
if let Some(desired) = desired_by_link.get(&link_path)
&& let Some(reason) = &desired.blocked_reason
{
if desired.withdraw_on_block
&& let Some(recorded) = recorded_by_link.get(&link_path)
{
operations.push(plan_undesired_recorded(paths, recorded, degraded_sources)?);
} else {
operations.push(MaterializeOperation {
kind: MaterializeOperationKind::Conflict,
link_path: desired.link_path.clone(),
desired_path: None,
status: MaterializeOperationStatus::Blocked,
reason: Some(reason.clone()),
});
}
continue;
}
match (
desired_by_link.get(&link_path),
recorded_by_link.get(&link_path),
) {
(Some(desired), Some(_)) => {
operations.push(plan_desired_recorded(
paths,
desired,
desired_is_protected(state, desired),
)?);
}
(Some(desired), None) => {
operations.push(plan_desired_unrecorded(
desired,
desired_is_protected(state, desired),
)?);
}
(None, Some(recorded)) => {
operations.push(plan_undesired_recorded(paths, recorded, degraded_sources)?);
}
(None, None) => {}
}
}
Ok(operations)
}
fn plan_desired_recorded(
paths: &StorePaths,
desired: &DesiredLink,
protected: bool,
) -> DaloResult<MaterializeOperation> {
let actual = actual_link_state(&desired.link_path)?;
let operation = match actual {
ActualLinkState::Absent => MaterializeOperation {
kind: MaterializeOperationKind::Create,
link_path: desired.link_path.clone(),
desired_path: Some(desired.store_path.clone()),
status: MaterializeOperationStatus::Applied,
reason: Some("recorded symlink is missing".to_owned()),
},
ActualLinkState::Symlink(target)
if link_target_matches(&desired.link_path, &target, &desired.store_path) =>
{
MaterializeOperation {
kind: MaterializeOperationKind::NoOp,
link_path: desired.link_path.clone(),
desired_path: Some(desired.store_path.clone()),
status: MaterializeOperationStatus::Existing,
reason: None,
}
}
ActualLinkState::Symlink(target)
if is_owned_link_target(paths, &desired.link_path, &desired.store_path, &target) =>
{
MaterializeOperation {
kind: MaterializeOperationKind::Relink,
link_path: desired.link_path.clone(),
desired_path: Some(desired.store_path.clone()),
status: MaterializeOperationStatus::Applied,
reason: Some(format!("owned symlink points to `{}`", target.display())),
}
}
ActualLinkState::Symlink(target) => MaterializeOperation {
kind: MaterializeOperationKind::Conflict,
link_path: desired.link_path.clone(),
desired_path: Some(desired.store_path.clone()),
status: MaterializeOperationStatus::Blocked,
reason: Some(format!("foreign symlink points to `{}`", target.display())),
},
ActualLinkState::RealEntry if protected => MaterializeOperation {
kind: MaterializeOperationKind::Keep,
link_path: desired.link_path.clone(),
desired_path: Some(desired.store_path.clone()),
status: MaterializeOperationStatus::Existing,
reason: Some("protected unmanaged entry kept".to_owned()),
},
ActualLinkState::RealEntry => MaterializeOperation {
kind: MaterializeOperationKind::Conflict,
link_path: desired.link_path.clone(),
desired_path: Some(desired.store_path.clone()),
status: MaterializeOperationStatus::Blocked,
reason: Some("real unmanaged entry exists at target slot".to_owned()),
},
};
Ok(operation)
}
fn plan_desired_unrecorded(
desired: &DesiredLink,
protected: bool,
) -> DaloResult<MaterializeOperation> {
let actual = actual_link_state(&desired.link_path)?;
let operation = match actual {
ActualLinkState::Absent => MaterializeOperation {
kind: MaterializeOperationKind::Create,
link_path: desired.link_path.clone(),
desired_path: Some(desired.store_path.clone()),
status: MaterializeOperationStatus::Applied,
reason: None,
},
ActualLinkState::Symlink(target)
if link_target_matches(&desired.link_path, &target, &desired.store_path) =>
{
MaterializeOperation {
kind: MaterializeOperationKind::Relink,
link_path: desired.link_path.clone(),
desired_path: Some(desired.store_path.clone()),
status: MaterializeOperationStatus::Applied,
reason: Some(format!(
"unrecorded matching symlink points to `{}`",
target.display()
)),
}
}
ActualLinkState::Symlink(target) => MaterializeOperation {
kind: MaterializeOperationKind::Conflict,
link_path: desired.link_path.clone(),
desired_path: Some(desired.store_path.clone()),
status: MaterializeOperationStatus::Blocked,
reason: Some(format!("foreign symlink points to `{}`", target.display())),
},
ActualLinkState::RealEntry if protected => MaterializeOperation {
kind: MaterializeOperationKind::Keep,
link_path: desired.link_path.clone(),
desired_path: Some(desired.store_path.clone()),
status: MaterializeOperationStatus::Existing,
reason: Some("protected unmanaged entry kept".to_owned()),
},
ActualLinkState::RealEntry => MaterializeOperation {
kind: MaterializeOperationKind::Conflict,
link_path: desired.link_path.clone(),
desired_path: Some(desired.store_path.clone()),
status: MaterializeOperationStatus::Blocked,
reason: Some("real unmanaged entry exists at target slot".to_owned()),
},
};
Ok(operation)
}
fn plan_undesired_recorded(
paths: &StorePaths,
recorded: &OwnedSkillState,
degraded_sources: &[DegradedSource],
) -> DaloResult<MaterializeOperation> {
if let Some(source) = degraded_sources
.iter()
.find(|source| recorded.store_path.starts_with(&source.path))
{
return Ok(MaterializeOperation {
kind: MaterializeOperationKind::Conflict,
link_path: recorded.link_path.clone(),
desired_path: Some(recorded.store_path.clone()),
status: MaterializeOperationStatus::Blocked,
reason: Some(format!(
"source `{}` scan degraded; preserving recorded owned link",
source.id
)),
});
}
let operation = match actual_link_state(&recorded.link_path) {
Ok(ActualLinkState::Symlink(target))
if is_owned_link_target(paths, &recorded.link_path, &recorded.store_path, &target) =>
{
MaterializeOperation {
kind: MaterializeOperationKind::Remove,
link_path: recorded.link_path.clone(),
desired_path: Some(recorded.store_path.clone()),
status: MaterializeOperationStatus::Applied,
reason: Some("recorded skill is no longer desired".to_owned()),
}
}
Ok(ActualLinkState::Symlink(target)) => MaterializeOperation {
kind: MaterializeOperationKind::DropRecord,
link_path: recorded.link_path.clone(),
desired_path: Some(recorded.store_path.clone()),
status: MaterializeOperationStatus::Applied,
reason: Some(format!(
"recorded slot now contains foreign symlink to `{}`",
target.display()
)),
},
Ok(ActualLinkState::Absent) => MaterializeOperation {
kind: MaterializeOperationKind::DropRecord,
link_path: recorded.link_path.clone(),
desired_path: None,
status: MaterializeOperationStatus::Applied,
reason: Some("recorded symlink is already absent".to_owned()),
},
Ok(ActualLinkState::RealEntry) => MaterializeOperation {
kind: MaterializeOperationKind::DropRecord,
link_path: recorded.link_path.clone(),
desired_path: None,
status: MaterializeOperationStatus::Applied,
reason: Some("recorded slot is no longer owned".to_owned()),
},
Err(error) => MaterializeOperation {
kind: MaterializeOperationKind::Conflict,
link_path: recorded.link_path.clone(),
desired_path: Some(recorded.store_path.clone()),
status: MaterializeOperationStatus::Blocked,
reason: Some(format!(
"could not inspect recorded slot `{}`: {error}",
recorded.link_path.display()
)),
},
};
Ok(operation)
}
fn apply_plan(
paths: &StorePaths,
state: &mut StateFile,
operations: &mut [MaterializeOperation],
desired_links: &[DesiredLink],
) -> DaloResult<()> {
let previous_owned_skills = state.owned_skills.clone();
for operation in operations.iter_mut() {
let kind = operation.kind;
let recorded = previous_owned_skills
.iter()
.any(|record| record.link_path == operation.link_path);
if let Err(error) = apply_operation(paths, operation, recorded) {
return Err(std::io::Error::other(format!(
"failed to apply {} operation at `{}`: {error}",
kind.as_str(),
operation.link_path.display()
))
.into());
}
}
state.owned_skills = desired_links
.iter()
.filter(|desired| {
!operations.iter().any(|operation| {
operation.link_path == desired.link_path
&& matches!(
operation.kind,
MaterializeOperationKind::Conflict
| MaterializeOperationKind::Keep
| MaterializeOperationKind::Remove
)
})
})
.map(|desired| {
let mut extra = previous_owned_skills
.iter()
.find(|record| record.link_path == desired.link_path)
.map(|record| record.extra.clone())
.unwrap_or_default();
extra.insert(
"delivery_mode".to_owned(),
toml::Value::String(desired.delivery_mode.as_str().to_owned()),
);
extra.insert(
"source_ref".to_owned(),
toml::Value::String(desired.source_ref.clone()),
);
if let Some(provider) = &desired.provider {
extra.insert(
"delivery_provider".to_owned(),
toml::Value::String(provider.clone()),
);
} else {
extra.remove("delivery_provider");
}
if let Some(fingerprint) = &desired.fingerprint {
extra.insert(
"delivery_fingerprint".to_owned(),
toml::Value::String(fingerprint.clone()),
);
} else {
extra.remove("delivery_fingerprint");
}
if let Some(derivation_hash) = &desired.derivation_hash {
extra.insert(
"delivery_derivation".to_owned(),
toml::Value::String(derivation_hash.clone()),
);
} else {
extra.remove("delivery_derivation");
}
OwnedSkillState {
target_id: desired.target_id.clone(),
slot_name: desired.slot_name.clone(),
link_path: desired.link_path.clone(),
store_path: desired.store_path.clone(),
extra,
}
})
.collect();
for operation in operations
.iter()
.filter(|operation| should_preserve_recorded_operation(operation))
{
let Some(preserved) = previous_owned_skills
.iter()
.find(|record| record.link_path == operation.link_path)
else {
continue;
};
if !state
.owned_skills
.iter()
.any(|record| record.link_path == preserved.link_path)
{
state.owned_skills.push(preserved.clone());
}
}
Ok(())
}
fn apply_operation(
paths: &StorePaths,
operation: &mut MaterializeOperation,
recorded: bool,
) -> DaloResult<()> {
#[cfg(test)]
if should_fail_apply_for_test(&operation.link_path) {
return Err(std::io::Error::other("injected apply failure").into());
}
match operation.kind {
MaterializeOperationKind::Create | MaterializeOperationKind::Relink => {
if operation.status == MaterializeOperationStatus::Blocked {
return Ok(());
}
match fs::symlink_metadata(&operation.link_path) {
Ok(metadata) if metadata.file_type().is_symlink() => {
let Some(desired_path) = operation.desired_path.as_ref() else {
return Ok(());
};
let target = fs::read_link(&operation.link_path)?;
let target_is_owned = if recorded {
is_owned_link_target(paths, &operation.link_path, desired_path, &target)
} else {
link_target_matches(&operation.link_path, &target, desired_path)
};
if !target_is_owned {
operation.kind = MaterializeOperationKind::Conflict;
operation.status = MaterializeOperationStatus::Blocked;
operation.reason =
Some("foreign symlink appeared at target slot".to_owned());
return Ok(());
}
fs::remove_file(&operation.link_path)?;
}
Ok(_) => {
operation.kind = MaterializeOperationKind::Conflict;
operation.status = MaterializeOperationStatus::Blocked;
operation.reason =
Some("real unmanaged entry appeared at target slot".to_owned());
return Ok(());
}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
Err(error) => return Err(error.into()),
}
if let Some(parent) = operation.link_path.parent() {
fs::create_dir_all(parent)?;
}
let Some(desired_path) = operation.desired_path.as_ref() else {
return Ok(());
};
unix_fs::symlink(desired_path, &operation.link_path)?;
}
MaterializeOperationKind::Remove => {
if let Some(recorded_store_path) = operation.desired_path.as_ref()
&& let ActualLinkState::Symlink(target) = actual_link_state(&operation.link_path)?
&& is_owned_link_target(paths, &operation.link_path, recorded_store_path, &target)
{
fs::remove_file(&operation.link_path)?;
}
}
MaterializeOperationKind::DropRecord
| MaterializeOperationKind::Conflict
| MaterializeOperationKind::Keep
| MaterializeOperationKind::NoOp => {}
}
Ok(())
}
#[cfg(test)]
fn should_fail_apply_for_test(link_path: &Path) -> bool {
TEST_APPLY_FAILURE_PATH.with(|failure_path| {
let mut failure_path = failure_path.borrow_mut();
if failure_path.as_deref() == Some(link_path) {
failure_path.take();
true
} else {
false
}
})
}
fn should_preserve_recorded_operation(operation: &MaterializeOperation) -> bool {
is_degraded_source_preserve(operation)
|| operation.reason.as_deref().is_some_and(|reason| {
operation.kind == MaterializeOperationKind::Conflict
&& operation.status == MaterializeOperationStatus::Blocked
&& (reason.starts_with("could not inspect recorded slot")
|| reason.starts_with("prebuilt delivery")
|| reason.starts_with("generated delivery")
|| reason.starts_with("logical targets"))
})
}
fn desired_is_protected(state: &StateFile, desired: &DesiredLink) -> bool {
let Some(scope) = desired.link_path.parent() else {
return false;
};
let Some(dir) = state
.materialization_dirs
.iter()
.find(|dir| dir.path == scope)
else {
return false;
};
state.protected_skills.iter().any(|protected| {
protected.slot_name == desired.slot_name
&& (dir.logical_targets.contains(&protected.target_id)
|| protected.path.as_ref() == Some(&desired.link_path))
})
}
fn rollback_materialization_failure(
paths: &StorePaths,
rollback: Option<MaterializationRollback>,
error: DaloError,
) -> DaloError {
let Some(rollback) = rollback else {
return error;
};
match rollback.restore(paths) {
Ok(()) => std::io::Error::other(format!("{error}; changes were rolled back")).into(),
Err(rollback_error) => std::io::Error::other(format!(
"{error}; additionally failed to roll back sync: {rollback_error}"
))
.into(),
}
}
fn link_target_matches(link_path: &Path, target: &Path, expected: &Path) -> bool {
store::comparable_path(&store::resolve_link_target(link_path, target))
== store::comparable_path(expected)
}
fn is_owned_link_target(
paths: &StorePaths,
link_path: &Path,
recorded_store_path: &Path,
target: &Path,
) -> bool {
link_target_matches(link_path, target, recorded_store_path)
|| store::path_is_same_or_descendant(
&store::resolve_link_target(link_path, target),
&paths.root,
)
}
fn is_degraded_source_preserve(operation: &MaterializeOperation) -> bool {
operation.kind == MaterializeOperationKind::Conflict
&& operation.status == MaterializeOperationStatus::Blocked
&& operation
.reason
.as_deref()
.is_some_and(|reason| reason.contains("scan degraded"))
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum ActualLinkState {
Absent,
Symlink(PathBuf),
RealEntry,
}
fn actual_link_state(link_path: &Path) -> DaloResult<ActualLinkState> {
match fs::symlink_metadata(link_path) {
Ok(metadata) if metadata.file_type().is_symlink() => {
Ok(ActualLinkState::Symlink(fs::read_link(link_path)?))
}
Ok(_) => Ok(ActualLinkState::RealEntry),
Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(ActualLinkState::Absent),
Err(error) => Err(error.into()),
}
}
#[cfg(test)]
mod tests {
use std::fs;
use super::*;
use crate::resolver::{Resolution, ResolvedSkill};
use crate::source::SourceKind;
use crate::store::{MaterializationDirState, TargetState};
#[test]
fn assistant_delivery_rolls_back_links_and_ownership_when_lock_commit_fails() {
let temporary = tempfile::tempdir().unwrap();
let store_root = temporary.path().join("store");
let target = temporary.path().join("target");
store::init_store(store_root.clone(), false).unwrap();
fs::create_dir_all(&target).unwrap();
fs::create_dir_all(store_root.join("local/skills/dalo")).unwrap();
write_state_with_target_id(&store_root, &target, "generic");
let paths = StorePaths::new(store_root);
let before = store::read_state(&paths).unwrap();
let lock = fs::read(&paths.lock_file).unwrap();
let error = materialize_assistant_using(&paths, "generic", |_, _| {
assert!(target.join("dalo").is_symlink());
Err(std::io::Error::other("injected lock commit failure").into())
})
.unwrap_err();
assert!(error.to_string().contains("changes were rolled back"));
assert!(!target.join("dalo").exists());
assert_eq!(store::read_state(&paths).unwrap(), before);
assert_eq!(fs::read(&paths.lock_file).unwrap(), lock);
}
#[test]
fn materialize_should_create_directory_symlink() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&target_dir).expect("target should be created");
let skill_dir = store_root.join("local/skills/review");
fs::create_dir_all(&skill_dir).expect("skill should be created");
write_state_with_target(&store_root, &target_dir);
let report = materialize(
&StorePaths::new(store_root),
&resolution_with_skill("review", &skill_dir),
false,
)
.expect("materialize should succeed");
assert_eq!(report.operations[0].kind, MaterializeOperationKind::Create);
assert!(
fs::symlink_metadata(target_dir.join("review"))
.expect("link should exist")
.file_type()
.is_symlink()
);
}
#[test]
fn materialize_should_select_prebuilt_artifact_per_logical_target() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
store::init_store(store_root.clone(), false).expect("init should succeed");
let logical = store_root.join("sources/catalog/impeccable");
let codex_artifact = store_root.join("sources/catalog/builds/codex/impeccable");
let claude_artifact = store_root.join("sources/catalog/builds/claude/impeccable");
for directory in [&logical, &codex_artifact, &claude_artifact] {
fs::create_dir_all(directory).expect("artifact directory should be created");
}
let codex_target = temp_dir.path().join("codex-skills");
let claude_target = temp_dir.path().join("claude-skills");
fs::create_dir_all(&codex_target).expect("codex target should be created");
fs::create_dir_all(&claude_target).expect("claude target should be created");
let paths = StorePaths::new(store_root);
let mut state = store::read_state(&paths).expect("state should be readable");
state.materialization_dirs = vec![
MaterializationDirState {
path: codex_target.clone(),
logical_targets: vec!["codex".to_owned()],
extra: Default::default(),
},
MaterializationDirState {
path: claude_target.clone(),
logical_targets: vec!["claude".to_owned()],
extra: Default::default(),
},
];
state.targets = vec![
TargetState {
id: "codex".to_owned(),
path: codex_target.clone(),
canonical_path: codex_target.clone(),
enabled: true,
extra: Default::default(),
},
TargetState {
id: "claude".to_owned(),
path: claude_target.clone(),
canonical_path: claude_target.clone(),
enabled: true,
extra: Default::default(),
},
];
store::write_state(&paths, &state).expect("state should be written");
let mut resolution = resolution_with_skill("impeccable", &logical);
resolution.active_skills[0].delivery =
prebuilt_delivery(&[("codex", &codex_artifact), ("claude", &claude_artifact)]);
let report = materialize(&paths, &resolution, false).expect("materialize should succeed");
assert_eq!(
fs::read_link(codex_target.join("impeccable")).expect("codex link should exist"),
codex_artifact
);
assert_eq!(
fs::read_link(claude_target.join("impeccable")).expect("claude link should exist"),
claude_artifact
);
assert_eq!(report.deliveries.len(), 2);
assert!(
report.deliveries.iter().all(|delivery| {
delivery.mode == SkillDeliveryMode::Prebuilt && !delivery.blocked
})
);
}
#[test]
fn materialize_should_block_missing_prebuilt_target_mapping() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target = temp_dir.path().join("claude-skills");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&target).expect("target should be created");
write_state_with_target_id(&store_root, &target, "claude");
let logical = store_root.join("sources/catalog/impeccable");
let codex_artifact = store_root.join("sources/catalog/builds/codex/impeccable");
fs::create_dir_all(&logical).expect("logical skill should be created");
fs::create_dir_all(&codex_artifact).expect("artifact should be created");
let mut resolution = resolution_with_skill("impeccable", &logical);
resolution.active_skills[0].delivery = prebuilt_delivery(&[("codex", &codex_artifact)]);
let report = materialize(&StorePaths::new(store_root), &resolution, true)
.expect("dry run should report the block");
assert_eq!(
report.operations[0].kind,
MaterializeOperationKind::Conflict
);
assert_eq!(
report.operations[0].status,
MaterializeOperationStatus::Blocked
);
assert!(
report.operations[0]
.reason
.as_deref()
.is_some_and(|reason| reason.contains("no mapping for target claude"))
);
assert!(report.deliveries[0].blocked);
assert!(!target.join("impeccable").exists());
}
#[test]
fn materialize_should_preserve_owned_link_when_prebuilt_mapping_becomes_missing() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target = temp_dir.path().join("skills");
let logical = store_root.join("local/skills/review");
let link = target.join("review");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&logical).expect("logical skill should be created");
fs::create_dir_all(&target).expect("target should be created");
unix_fs::symlink(&logical, &link).expect("old owned link should be created");
write_state_with_owned_skill(&store_root, &target, &link, &logical);
let mut resolution = resolution_with_skill("review", &logical);
resolution.active_skills[0].delivery =
prebuilt_delivery(&[("codex", &store_root.join("local/builds/codex/review"))]);
let paths = StorePaths::new(store_root);
let report = materialize(&paths, &resolution, false)
.expect("sync should report the blocked mapping safely");
assert_eq!(
report.operations[0].status,
MaterializeOperationStatus::Blocked
);
assert_eq!(
fs::read_link(&link).expect("old link should survive"),
logical
);
let state = store::read_state(&paths).expect("state should remain readable");
assert_eq!(state.owned_skills.len(), 1);
assert_eq!(state.owned_skills[0].link_path, link);
}
#[test]
fn materialize_should_block_different_artifacts_in_a_shared_target_directory() {
let shared = PathBuf::from("/agents/skills");
let state = StateFile {
schema_version: store::STATE_SCHEMA_VERSION,
targets: Vec::new(),
materialization_dirs: vec![MaterializationDirState {
path: shared,
logical_targets: vec!["codex".to_owned(), "openclaw".to_owned()],
extra: Default::default(),
}],
owned_skills: Vec::new(),
protected_skills: Vec::new(),
extra: Default::default(),
};
let mut resolution = resolution_with_skill("review", Path::new("/source/review"));
resolution.active_skills[0].delivery = prebuilt_delivery(&[
("codex", &PathBuf::from("/source/builds/codex/review")),
("openclaw", &PathBuf::from("/source/builds/openclaw/review")),
]);
let links = desired_links(&state, &resolution, &BTreeMap::new(), &BTreeSet::new());
let operations = build_plan(
&StorePaths::new(PathBuf::from("/store")),
&state,
&links,
&[],
)
.expect("planning should succeed");
assert_eq!(operations[0].kind, MaterializeOperationKind::Conflict);
assert!(
operations[0]
.reason
.as_deref()
.is_some_and(|reason| reason.contains("different provider artifacts"))
);
}
#[test]
fn materialize_should_block_unmanaged_real_directory() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(target_dir.join("review")).expect("unmanaged dir should be created");
let skill_dir = store_root.join("local/skills/review");
fs::create_dir_all(&skill_dir).expect("skill should be created");
write_state_with_target(&store_root, &target_dir);
let report = materialize(
&StorePaths::new(store_root),
&resolution_with_skill("review", &skill_dir),
false,
)
.expect("materialize should succeed");
assert_eq!(
report.operations[0].kind,
MaterializeOperationKind::Conflict
);
}
#[test]
fn materialize_should_block_dependent_when_requirement_has_target_conflict() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(target_dir.join("beta")).expect("unmanaged dir should be created");
let alpha_dir = store_root.join("team/skills/alpha");
let beta_dir = store_root.join("team/skills/beta");
fs::create_dir_all(&alpha_dir).expect("alpha should be created");
fs::create_dir_all(&beta_dir).expect("beta should be created");
write_state_with_target(&store_root, &target_dir);
let report = materialize(
&StorePaths::new(store_root),
&resolution_with_required_pair(&alpha_dir, &beta_dir),
false,
)
.expect("materialize should succeed");
assert!(!target_dir.join("alpha").exists());
assert!(target_dir.join("beta").is_dir());
assert_eq!(report.resolution.active_skills.len(), 1);
assert_eq!(
report.resolution.active_skills[0].source_ref,
"company:beta"
);
assert_eq!(report.resolution.blocked_skills.len(), 1);
assert_eq!(
report.resolution.blocked_skills[0].skill.source_ref,
"company:alpha"
);
assert_eq!(
report.resolution.blocked_skills[0].reason,
ClosureBlockReason::SameNameBlocked
);
}
#[test]
fn materialize_should_block_namespaced_dependent_when_requirement_has_target_conflict() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(target_dir.join("company__beta"))
.expect("unmanaged dir should be created");
let alpha_dir = store_root.join("team/skills/alpha");
let beta_dir = store_root.join("team/skills/beta");
fs::create_dir_all(&alpha_dir).expect("alpha should be created");
fs::create_dir_all(&beta_dir).expect("beta should be created");
write_state_with_target(&store_root, &target_dir);
let mut resolution = resolution_with_required_pair(&alpha_dir, &beta_dir);
for skill in &mut resolution.active_skills {
skill.slot_name = format!("company__{}", skill.slot_name);
skill.source_namespace = Some("company".to_owned());
}
let report = materialize(&StorePaths::new(store_root), &resolution, false)
.expect("materialize should succeed");
assert!(fs::symlink_metadata(target_dir.join("company__alpha")).is_err());
assert_eq!(report.resolution.blocked_skills.len(), 1);
assert_eq!(
report.resolution.blocked_skills[0].skill.source_ref,
"company:alpha"
);
}
#[test]
fn materialize_should_remove_existing_dependent_when_requirement_becomes_blocked() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&target_dir).expect("target should be created");
let alpha_dir = store_root.join("team/skills/alpha");
let beta_dir = store_root.join("team/skills/beta");
fs::create_dir_all(&alpha_dir).expect("alpha should be created");
fs::create_dir_all(&beta_dir).expect("beta should be created");
write_state_with_target(&store_root, &target_dir);
let paths = StorePaths::new(store_root);
let resolution = resolution_with_required_pair(&alpha_dir, &beta_dir);
materialize(&paths, &resolution, false).expect("first materialize should succeed");
fs::remove_file(target_dir.join("beta")).expect("beta link should be removed");
fs::create_dir(target_dir.join("beta")).expect("unmanaged beta should be created");
let report =
materialize(&paths, &resolution, false).expect("second materialize should succeed");
assert!(fs::symlink_metadata(target_dir.join("alpha")).is_err());
assert!(report.operations.iter().any(|operation| {
operation.link_path == target_dir.join("alpha")
&& operation.kind == MaterializeOperationKind::Remove
}));
assert_eq!(report.resolution.blocked_skills.len(), 1);
let state = store::read_state(&paths).expect("state should be readable");
assert!(state.owned_skills.is_empty());
}
#[test]
fn materialize_should_keep_dependent_in_unaffected_target() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let blocked_target = temp_dir.path().join("blocked-target");
let clean_target = temp_dir.path().join("clean-target");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(blocked_target.join("beta")).expect("unmanaged dir should be created");
fs::create_dir_all(&clean_target).expect("clean target should be created");
let alpha_dir = store_root.join("team/skills/alpha");
let beta_dir = store_root.join("team/skills/beta");
fs::create_dir_all(&alpha_dir).expect("alpha should be created");
fs::create_dir_all(&beta_dir).expect("beta should be created");
let paths = StorePaths::new(store_root);
let mut state = store::read_state(&paths).expect("state should be readable");
state.targets = vec![
TargetState {
id: "blocked".to_owned(),
path: blocked_target.clone(),
canonical_path: blocked_target.clone(),
enabled: true,
extra: Default::default(),
},
TargetState {
id: "clean".to_owned(),
path: clean_target.clone(),
canonical_path: clean_target.clone(),
enabled: true,
extra: Default::default(),
},
];
state.materialization_dirs = vec![
MaterializationDirState {
path: blocked_target.clone(),
logical_targets: vec!["blocked".to_owned()],
extra: Default::default(),
},
MaterializationDirState {
path: clean_target.clone(),
logical_targets: vec!["clean".to_owned()],
extra: Default::default(),
},
];
store::write_state(&paths, &state).expect("state should be written");
let report = materialize(
&paths,
&resolution_with_required_pair(&alpha_dir, &beta_dir),
false,
)
.expect("materialize should succeed");
assert!(!blocked_target.join("alpha").exists());
assert!(blocked_target.join("beta").is_dir());
assert!(
fs::symlink_metadata(clean_target.join("alpha"))
.expect("clean alpha link should exist")
.file_type()
.is_symlink()
);
assert!(
fs::symlink_metadata(clean_target.join("beta"))
.expect("clean beta link should exist")
.file_type()
.is_symlink()
);
assert_eq!(report.resolution.active_skills.len(), 2);
assert!(report.resolution.blocked_skills.is_empty());
assert!(report.operations.iter().any(|operation| {
operation.link_path == blocked_target.join("alpha")
&& operation.kind == MaterializeOperationKind::Conflict
&& operation.status == MaterializeOperationStatus::Blocked
&& operation
.reason
.as_deref()
.is_some_and(|reason| reason.starts_with("required closure blocked:"))
}));
}
#[test]
fn materialize_should_block_foreign_symlink() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
let foreign_dir = temp_dir.path().join("foreign");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&target_dir).expect("target should be created");
fs::create_dir_all(&foreign_dir).expect("foreign dir should be created");
let skill_dir = store_root.join("local/skills/review");
fs::create_dir_all(&skill_dir).expect("skill should be created");
unix_fs::symlink(&foreign_dir, target_dir.join("review"))
.expect("foreign symlink should be created");
write_state_with_target(&store_root, &target_dir);
let report = materialize(
&StorePaths::new(store_root),
&resolution_with_skill("review", &skill_dir),
false,
)
.expect("materialize should succeed");
assert_eq!(
report.operations[0].kind,
MaterializeOperationKind::Conflict
);
}
#[test]
fn materialize_should_block_dangling_foreign_symlink() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
let missing_foreign_dir = temp_dir.path().join("missing-foreign");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&target_dir).expect("target should be created");
let skill_dir = store_root.join("local/skills/review");
fs::create_dir_all(&skill_dir).expect("skill should be created");
unix_fs::symlink(&missing_foreign_dir, target_dir.join("review"))
.expect("dangling foreign symlink should be created");
write_state_with_target(&store_root, &target_dir);
let report = materialize(
&StorePaths::new(store_root),
&resolution_with_skill("review", &skill_dir),
false,
)
.expect("materialize should succeed");
assert_eq!(
report.operations[0].kind,
MaterializeOperationKind::Conflict
);
assert!(
fs::symlink_metadata(target_dir.join("review"))
.expect("dangling symlink should survive")
.file_type()
.is_symlink()
);
}
#[test]
fn materialize_should_relink_owned_symlink_pointing_elsewhere() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&target_dir).expect("target should be created");
let skill_dir = store_root.join("local/skills/review");
let stale_store_dir = store_root.join("local/skills/review-old");
fs::create_dir_all(&skill_dir).expect("skill should be created");
fs::create_dir_all(&stale_store_dir).expect("stale skill should be created");
let link_path = target_dir.join("review");
unix_fs::symlink(&stale_store_dir, &link_path).expect("owned symlink should be created");
write_state_with_owned_skill(&store_root, &target_dir, &link_path, &stale_store_dir);
let report = materialize(
&StorePaths::new(store_root),
&resolution_with_skill("review", &skill_dir),
false,
)
.expect("materialize should succeed");
assert_eq!(report.operations[0].kind, MaterializeOperationKind::Relink);
}
#[test]
fn materialize_should_relink_unrecorded_store_symlink() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&target_dir).expect("target should be created");
let skill_dir = store_root.join("local/skills/review");
fs::create_dir_all(&skill_dir).expect("skill should be created");
let link_path = target_dir.join("review");
unix_fs::symlink(&skill_dir, &link_path).expect("unrecorded store symlink should exist");
write_state_with_target(&store_root, &target_dir);
let paths = StorePaths::new(store_root);
let report = materialize(&paths, &resolution_with_skill("review", &skill_dir), false)
.expect("materialize should succeed");
assert_eq!(report.operations[0].kind, MaterializeOperationKind::Relink);
let state = store::read_state(&paths).expect("state should be readable");
assert_eq!(state.owned_skills.len(), 1);
assert_eq!(state.owned_skills[0].link_path, link_path);
assert_eq!(
fs::read_link(&state.owned_skills[0].link_path).expect("link should be readable"),
skill_dir
);
}
#[test]
fn materialize_should_block_unrecorded_store_symlink_to_a_different_target() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&target_dir).expect("target should be created");
let skill_dir = store_root.join("local/skills/review");
let foreign_store_dir = store_root.join("sources/other/checkout/skills/review-v2");
fs::create_dir_all(&skill_dir).expect("skill should be created");
fs::create_dir_all(&foreign_store_dir).expect("foreign store path should be created");
let link_path = target_dir.join("review");
unix_fs::symlink(&foreign_store_dir, &link_path)
.expect("foreign symlink should be created");
write_state_with_target(&store_root, &target_dir);
let paths = StorePaths::new(store_root);
let report = materialize(&paths, &resolution_with_skill("review", &skill_dir), false)
.expect("materialize should succeed");
assert_eq!(
report.operations[0].kind,
MaterializeOperationKind::Conflict
);
assert_eq!(
report.operations[0].status,
MaterializeOperationStatus::Blocked
);
assert_eq!(
fs::read_link(&link_path).expect("foreign symlink should survive"),
foreign_store_dir
);
assert!(
store::read_state(&paths)
.expect("state should be readable")
.owned_skills
.is_empty(),
"foreign symlink must not become an owned state record"
);
}
#[test]
fn materialize_should_be_idempotent() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&target_dir).expect("target should be created");
let skill_dir = store_root.join("local/skills/review");
fs::create_dir_all(&skill_dir).expect("skill should be created");
write_state_with_target(&store_root, &target_dir);
let paths = StorePaths::new(store_root);
let resolution = resolution_with_skill("review", &skill_dir);
materialize(&paths, &resolution, false).expect("first materialize should succeed");
let report =
materialize(&paths, &resolution, false).expect("second materialize should succeed");
assert_eq!(report.operations[0].kind, MaterializeOperationKind::NoOp);
}
#[test]
fn materialize_rollback_should_restore_links_and_state() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&target_dir).expect("target should be created");
let skill_dir = store_root.join("local/skills/review");
fs::create_dir_all(&skill_dir).expect("skill should be created");
write_state_with_target(&store_root, &target_dir);
let paths = StorePaths::new(store_root);
let (_, rollback) = materialize_with_degraded_sources_rollback(
&paths,
&resolution_with_skill("review", &skill_dir),
false,
&[],
)
.expect("materialize should succeed");
rollback
.expect("non-dry-run materialization should be reversible")
.restore(&paths)
.expect("rollback should succeed");
assert!(!target_dir.join("review").exists());
assert!(
store::read_state(&paths)
.expect("state should be readable")
.owned_skills
.is_empty()
);
}
#[test]
fn materialize_should_roll_back_links_when_apply_fails_midway() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let first_target = temp_dir.path().join("a-target");
let failing_target = temp_dir.path().join("z-target");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&first_target).expect("first target should be created");
fs::create_dir_all(&failing_target).expect("failing target should be created");
let skill_dir = store_root.join("local/skills/review");
fs::create_dir_all(&skill_dir).expect("skill should be created");
let paths = StorePaths::new(store_root);
let mut state = store::read_state(&paths).expect("state should be readable");
state.targets = vec![
TargetState {
id: "first".to_owned(),
path: first_target.clone(),
canonical_path: first_target.clone(),
enabled: true,
extra: Default::default(),
},
TargetState {
id: "failing".to_owned(),
path: failing_target.clone(),
canonical_path: failing_target.clone(),
enabled: true,
extra: Default::default(),
},
];
state.materialization_dirs = vec![
MaterializationDirState {
path: first_target.clone(),
logical_targets: vec!["first".to_owned()],
extra: Default::default(),
},
MaterializationDirState {
path: failing_target.clone(),
logical_targets: vec!["failing".to_owned()],
extra: Default::default(),
},
];
store::write_state(&paths, &state).expect("state should be written");
TEST_APPLY_FAILURE_PATH.with(|failure_path| {
*failure_path.borrow_mut() = Some(failing_target.join("review"));
});
let error = materialize(&paths, &resolution_with_skill("review", &skill_dir), false)
.expect_err("second target should fail during apply");
assert!(
error
.to_string()
.contains(&failing_target.join("review").display().to_string()),
"{error}"
);
assert!(
error.to_string().contains("changes were rolled back"),
"{error}"
);
assert!(!first_target.join("review").exists());
assert!(
store::read_state(&paths)
.expect("state should be readable")
.owned_skills
.is_empty()
);
}
#[test]
fn snapshot_links_should_fail_before_apply_when_a_path_cannot_be_inspected() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let parent = temp_dir.path().join("not-a-directory");
fs::write(&parent, "file").expect("parent file should be written");
let operations = vec![MaterializeOperation {
kind: MaterializeOperationKind::Create,
link_path: parent.join("review"),
desired_path: Some(PathBuf::from("/store/review")),
status: MaterializeOperationStatus::Applied,
reason: None,
}];
let error = snapshot_links(&operations)
.expect_err("an unreadable rollback path must prevent apply");
assert!(!error.to_string().is_empty());
}
#[test]
fn materialize_should_accept_owned_symlink_to_store_equivalent_path() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let store_alias = temp_dir.path().join("store-alias");
let target_dir = temp_dir.path().join("target");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&target_dir).expect("target should be created");
let skill_dir = store_root.join("local/skills/review");
fs::create_dir_all(&skill_dir).expect("skill should be created");
unix_fs::symlink(&store_root, &store_alias).expect("store alias should be created");
let link_path = target_dir.join("review");
unix_fs::symlink(store_alias.join("local/skills/review"), &link_path)
.expect("owned symlink should be created");
write_state_with_owned_skill(&store_root, &target_dir, &link_path, &skill_dir);
let report = materialize(
&StorePaths::new(store_root),
&resolution_with_skill("review", &skill_dir),
false,
)
.expect("materialize should succeed");
assert_eq!(report.operations[0].kind, MaterializeOperationKind::NoOp);
}
#[test]
fn apply_plan_should_not_replace_real_entry_at_create_slot() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let link_path = temp_dir.path().join("review");
fs::write(&link_path, "unmanaged user file").expect("real file should be written");
let store_path = temp_dir.path().join("store/review");
let operation = MaterializeOperation {
kind: MaterializeOperationKind::Create,
link_path: link_path.clone(),
desired_path: Some(store_path.clone()),
status: MaterializeOperationStatus::Applied,
reason: None,
};
let desired = DesiredLink {
target_id: "generic".to_owned(),
target_ids: vec!["generic".to_owned()],
source_ref: "local:review".to_owned(),
slot_name: "review".to_owned(),
link_path: link_path.clone(),
store_path,
delivery_mode: SkillDeliveryMode::Direct,
provider: None,
fingerprint: None,
cache_state: None,
derivation_hash: None,
planned_output: None,
blocked_reason: None,
withdraw_on_block: false,
};
let paths = StorePaths::new(temp_dir.path().join("store"));
let mut state = StateFile::empty();
let mut operations = vec![operation];
apply_plan(&paths, &mut state, &mut operations, &[desired]).expect("apply should succeed");
assert_eq!(operations[0].kind, MaterializeOperationKind::Conflict);
assert_eq!(operations[0].status, MaterializeOperationStatus::Blocked);
assert_eq!(
operations[0].reason.as_deref(),
Some("real unmanaged entry appeared at target slot")
);
assert!(state.owned_skills.is_empty());
assert!(
!fs::symlink_metadata(&link_path)
.expect("file should still exist")
.file_type()
.is_symlink()
);
}
#[test]
fn materialize_should_drop_record_without_removing_foreign_symlink_at_recorded_path() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
let foreign_dir = temp_dir.path().join("foreign");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&target_dir).expect("target should be created");
fs::create_dir_all(&foreign_dir).expect("foreign dir should be created");
let recorded_store_dir = store_root.join("local/skills/review");
fs::create_dir_all(&recorded_store_dir).expect("recorded store dir should be created");
let link_path = target_dir.join("review");
unix_fs::symlink(&foreign_dir, &link_path).expect("foreign symlink should be created");
write_state_with_owned_skill(&store_root, &target_dir, &link_path, &recorded_store_dir);
let report = materialize(
&StorePaths::new(store_root.clone()),
&empty_resolution(),
false,
)
.expect("materialize should succeed");
assert_eq!(
report.operations[0].kind,
MaterializeOperationKind::DropRecord
);
assert_eq!(
fs::read_link(&link_path).expect("foreign symlink should survive"),
foreign_dir
);
let state =
store::read_state(&StorePaths::new(store_root)).expect("state should be readable");
assert!(state.owned_skills.is_empty());
}
#[test]
fn materialize_should_preserve_record_on_metadata_errors() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_file = temp_dir.path().join("target-file");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::write(&target_file, "not a directory").expect("target file should be written");
let link_path = target_file.join("review");
let recorded_store_dir = store_root.join("local/skills/review");
fs::create_dir_all(&recorded_store_dir).expect("recorded store dir should be created");
write_state_with_owned_skill(&store_root, &target_file, &link_path, &recorded_store_dir);
let report = materialize(
&StorePaths::new(store_root.clone()),
&empty_resolution(),
false,
)
.expect("materialize should succeed");
assert_eq!(
report.operations[0].kind,
MaterializeOperationKind::Conflict
);
assert_eq!(
report.operations[0].status,
MaterializeOperationStatus::Blocked
);
assert!(
report.operations[0]
.reason
.as_deref()
.is_some_and(|reason| reason.contains("could not inspect recorded slot"))
);
let state =
store::read_state(&StorePaths::new(store_root)).expect("state should be readable");
assert_eq!(state.owned_skills.len(), 1);
assert_eq!(state.owned_skills[0].link_path, link_path);
}
#[test]
fn apply_plan_should_recheck_remove_target_before_unlinking() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
let foreign_dir = temp_dir.path().join("foreign");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&target_dir).expect("target should be created");
fs::create_dir_all(&foreign_dir).expect("foreign dir should be created");
let recorded_store_dir = store_root.join("local/skills/review");
fs::create_dir_all(&recorded_store_dir).expect("recorded store dir should be created");
let link_path = target_dir.join("review");
unix_fs::symlink(&foreign_dir, &link_path).expect("foreign symlink should be created");
let mut state = StateFile::empty();
state.owned_skills = vec![OwnedSkillState {
target_id: "generic".to_owned(),
slot_name: "review".to_owned(),
link_path: link_path.clone(),
store_path: recorded_store_dir.clone(),
extra: Default::default(),
}];
let operation = MaterializeOperation {
kind: MaterializeOperationKind::Remove,
link_path: link_path.clone(),
desired_path: Some(recorded_store_dir),
status: MaterializeOperationStatus::Applied,
reason: Some("recorded skill is no longer desired".to_owned()),
};
let mut operations = vec![operation];
apply_plan(
&StorePaths::new(store_root),
&mut state,
&mut operations,
&[],
)
.expect("apply should succeed");
assert_eq!(
fs::read_link(&link_path).expect("foreign symlink should survive"),
foreign_dir
);
assert!(state.owned_skills.is_empty());
}
#[test]
fn apply_plan_should_recheck_relink_target_before_unlinking() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
let foreign_dir = temp_dir.path().join("foreign");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&target_dir).expect("target should be created");
fs::create_dir_all(&foreign_dir).expect("foreign dir should be created");
let desired_store_dir = store_root.join("local/skills/review");
fs::create_dir_all(&desired_store_dir).expect("desired store dir should be created");
let link_path = target_dir.join("review");
unix_fs::symlink(&foreign_dir, &link_path).expect("foreign symlink should be created");
let mut state = StateFile::empty();
let operation = MaterializeOperation {
kind: MaterializeOperationKind::Relink,
link_path: link_path.clone(),
desired_path: Some(desired_store_dir),
status: MaterializeOperationStatus::Applied,
reason: Some("owned symlink points elsewhere".to_owned()),
};
let mut operations = vec![operation];
apply_plan(
&StorePaths::new(store_root),
&mut state,
&mut operations,
&[],
)
.expect("apply should succeed");
assert_eq!(operations[0].kind, MaterializeOperationKind::Conflict);
assert_eq!(operations[0].status, MaterializeOperationStatus::Blocked);
assert_eq!(
fs::read_link(&link_path).expect("foreign symlink should survive"),
foreign_dir
);
}
#[test]
fn apply_plan_should_preserve_unrecorded_relink_after_in_store_target_swap() {
let temp_dir = tempfile::tempdir().expect("tempdir should be created");
let store_root = temp_dir.path().join("store");
let target_dir = temp_dir.path().join("target");
store::init_store(store_root.clone(), false).expect("init should succeed");
fs::create_dir_all(&target_dir).expect("target should be created");
let desired_store_dir = store_root.join("local/skills/review");
let swapped_store_dir = store_root.join("sources/other/checkout/skills/review-v2");
fs::create_dir_all(&desired_store_dir).expect("desired store directory should be created");
fs::create_dir_all(&swapped_store_dir).expect("swapped store directory should be created");
let link_path = target_dir.join("review");
unix_fs::symlink(&desired_store_dir, &link_path)
.expect("desired unrecorded symlink should be created");
write_state_with_target(&store_root, &target_dir);
let paths = StorePaths::new(store_root);
let resolution = resolution_with_skill("review", &desired_store_dir);
let state = store::read_state(&paths).expect("state should be readable");
let desired_links = desired_links(&state, &resolution, &BTreeMap::new(), &BTreeSet::new());
let mut operations =
build_plan(&paths, &state, &desired_links, &[]).expect("plan should be created");
assert_eq!(operations[0].kind, MaterializeOperationKind::Relink);
let _rollback = MaterializationRollback {
state: state.clone(),
links: snapshot_links(&operations).expect("snapshot should succeed"),
};
fs::remove_file(&link_path).expect("desired symlink should be removed for the swap");
unix_fs::symlink(&swapped_store_dir, &link_path)
.expect("swapped foreign symlink should be created");
let mut state = state;
apply_plan(&paths, &mut state, &mut operations, &desired_links)
.expect("apply should succeed");
assert_eq!(operations[0].kind, MaterializeOperationKind::Conflict);
assert_eq!(operations[0].status, MaterializeOperationStatus::Blocked);
assert_eq!(
fs::read_link(&link_path).expect("swapped foreign symlink should survive"),
swapped_store_dir
);
assert!(state.owned_skills.is_empty());
}
#[test]
fn desired_links_should_pick_deterministic_target_id_for_shared_dir() {
let shared = PathBuf::from("/agents/skills");
let state = StateFile {
schema_version: store::STATE_SCHEMA_VERSION,
targets: vec![
TargetState {
id: "openclaw".to_owned(),
path: shared.clone(),
canonical_path: shared.clone(),
enabled: true,
extra: Default::default(),
},
TargetState {
id: "codex".to_owned(),
path: shared.clone(),
canonical_path: shared.clone(),
enabled: true,
extra: Default::default(),
},
],
materialization_dirs: vec![MaterializationDirState {
path: shared,
logical_targets: vec!["codex".to_owned(), "openclaw".to_owned()],
extra: Default::default(),
}],
owned_skills: Vec::new(),
protected_skills: Vec::new(),
extra: Default::default(),
};
let resolution = resolution_with_skill("review", Path::new("/store/review"));
let links = desired_links(&state, &resolution, &BTreeMap::new(), &BTreeSet::new());
assert_eq!(links[0].target_id, "codex");
}
fn write_state_with_target(store_root: &Path, target_dir: &Path) {
write_state_with_target_id(store_root, target_dir, "generic");
}
fn write_state_with_target_id(store_root: &Path, target_dir: &Path, target_id: &str) {
let paths = StorePaths::new(store_root.to_path_buf());
let mut state = store::read_state(&paths).expect("state should be readable");
state.targets = vec![TargetState {
id: target_id.to_owned(),
path: target_dir.to_path_buf(),
canonical_path: target_dir.to_path_buf(),
enabled: true,
extra: Default::default(),
}];
state.materialization_dirs = vec![MaterializationDirState {
path: target_dir.to_path_buf(),
logical_targets: vec![target_id.to_owned()],
extra: Default::default(),
}];
store::write_state(&paths, &state).expect("state should be written");
}
fn prebuilt_delivery(providers: &[(&str, &PathBuf)]) -> crate::inventory::SkillDelivery {
crate::inventory::SkillDelivery::Prebuilt {
providers: providers
.iter()
.map(|(provider, path)| {
(
(*provider).to_owned(),
crate::inventory::PrebuiltSkillArtifact {
path: (*path).clone(),
fingerprint: format!("sha256:{provider}"),
},
)
})
.collect(),
universal_fallback: false,
fallback_fingerprint: None,
manifest_path: PathBuf::from("/source/DELIVERY.toml"),
}
}
fn write_state_with_owned_skill(
store_root: &Path,
target_dir: &Path,
link_path: &Path,
store_path: &Path,
) {
let paths = StorePaths::new(store_root.to_path_buf());
let mut state = store::read_state(&paths).expect("state should be readable");
state.targets = vec![TargetState {
id: "generic".to_owned(),
path: target_dir.to_path_buf(),
canonical_path: target_dir.to_path_buf(),
enabled: true,
extra: Default::default(),
}];
state.materialization_dirs = vec![MaterializationDirState {
path: target_dir.to_path_buf(),
logical_targets: vec!["generic".to_owned()],
extra: Default::default(),
}];
state.owned_skills = vec![OwnedSkillState {
target_id: "generic".to_owned(),
slot_name: "review".to_owned(),
link_path: link_path.to_path_buf(),
store_path: store_path.to_path_buf(),
extra: Default::default(),
}];
store::write_state(&paths, &state).expect("state should be written");
}
fn resolution_with_skill(slot_name: &str, path: &Path) -> Resolution {
Resolution {
active_skills: vec![ResolvedSkill {
source_ref: format!("local:{slot_name}"),
slot_name: slot_name.to_owned(),
source_namespace: None,
id: None,
source_id: "local".to_owned(),
source_kind: SourceKind::Local,
source_priority: 0,
path: path.to_path_buf(),
delivery: crate::inventory::SkillDelivery::Direct,
compatibility: None,
binaries: Vec::new(),
local_override: false,
requires: Vec::new(),
}],
pending_approval_skills: Vec::new(),
unlinked_skills: Vec::new(),
blocked_skills: Vec::new(),
diagnostics: Vec::new(),
}
}
fn resolution_with_required_pair(alpha_path: &Path, beta_path: &Path) -> Resolution {
Resolution {
active_skills: vec![
ResolvedSkill {
source_ref: "company:alpha".to_owned(),
slot_name: "alpha".to_owned(),
source_namespace: None,
id: None,
source_id: "company".to_owned(),
source_kind: SourceKind::Team,
source_priority: 10,
path: alpha_path.to_path_buf(),
delivery: crate::inventory::SkillDelivery::Direct,
compatibility: None,
binaries: Vec::new(),
local_override: false,
requires: vec!["beta".to_owned()],
},
ResolvedSkill {
source_ref: "company:beta".to_owned(),
slot_name: "beta".to_owned(),
source_namespace: None,
id: None,
source_id: "company".to_owned(),
source_kind: SourceKind::Team,
source_priority: 10,
path: beta_path.to_path_buf(),
delivery: crate::inventory::SkillDelivery::Direct,
compatibility: None,
binaries: Vec::new(),
local_override: false,
requires: Vec::new(),
},
],
pending_approval_skills: Vec::new(),
unlinked_skills: Vec::new(),
blocked_skills: Vec::new(),
diagnostics: Vec::new(),
}
}
fn empty_resolution() -> Resolution {
Resolution {
active_skills: Vec::new(),
pending_approval_skills: Vec::new(),
unlinked_skills: Vec::new(),
blocked_skills: Vec::new(),
diagnostics: Vec::new(),
}
}
}