phora 0.6.0

A git-based artifact package manager and multiplexer for content-addressed file distribution
Documentation
use std::collections::{BTreeMap, BTreeSet};

use crate::projection::model::Projection;
use crate::sync::model::{
    ChangeSet, ConflictKind, ManagedArtifact, ManagedCondition, ObservedArtifact, ObservedEntry,
    ObservedProjectState, ReconciliationPolicy, RemovalReason, SyncChange, SyncError,
};

type Key = (String, String, String);

pub fn reconcile<R>(
    projection: &Projection,
    observed: &ObservedProjectState<R>,
    policy: &ReconciliationPolicy,
) -> Result<ChangeSet, SyncError> {
    let observations: BTreeMap<Key, &ObservedArtifact<R>> = observed
        .artifacts
        .iter()
        .map(|entry| (key_of(entry), &entry.observation))
        .collect();

    let mut changes = Vec::new();
    let mut matched: BTreeSet<Key> = BTreeSet::new();
    for desired in desired_artifacts(projection) {
        let key = (
            desired.target.clone(),
            desired.source.clone(),
            desired.artifact.clone(),
        );
        let Some(observation) = observations.get(&key) else {
            return Err(SyncError::UnmatchedArtifact {
                target: desired.target,
                source: desired.source,
                artifact: desired.artifact,
            });
        };
        matched.insert(key);
        if let Some(change) = classify_desired(desired, observation, *policy) {
            changes.push(change);
        }
    }

    for entry in &observed.artifacts {
        if matched.contains(&key_of(entry)) {
            continue;
        }
        if let Some(change) = classify_orphan(entry, *policy) {
            changes.push(change);
        }
    }

    Ok(ChangeSet { changes })
}

pub(super) fn add_history_retirement_conflicts<R>(
    changeset: &mut ChangeSet,
    retirements: &[ObservedEntry<R>],
    policy: ReconciliationPolicy,
) {
    if policy.force {
        return;
    }
    for entry in retirements {
        let Some(kind) = retirement_conflict(&entry.observation) else {
            continue;
        };
        changeset.changes.push(SyncChange::Conflict {
            target: entry.target.clone(),
            source: entry.source.clone(),
            artifact: entry.artifact.clone(),
            kind,
        });
    }
}

fn retirement_conflict<R>(observation: &ObservedArtifact<R>) -> Option<ConflictKind> {
    match observation {
        ObservedArtifact::Managed(ManagedArtifact {
            condition: ManagedCondition::Modified { changed },
            ..
        }) => Some(ConflictKind::Modified {
            changed: changed.clone(),
        }),
        ObservedArtifact::Foreign(_) => Some(ConflictKind::Foreign),
        ObservedArtifact::Missing | ObservedArtifact::Ejected | ObservedArtifact::Managed(_) => {
            None
        }
    }
}

fn classify_desired<R>(
    desired: DesiredArtifact,
    observation: &ObservedArtifact<R>,
    policy: ReconciliationPolicy,
) -> Option<SyncChange> {
    match observation {
        ObservedArtifact::Missing => Some(deploy(desired)),
        ObservedArtifact::Foreign(_) => Some(collision(desired, ConflictKind::Foreign, policy)),
        ObservedArtifact::Ejected => None,
        ObservedArtifact::Managed(managed) => match &managed.condition {
            ManagedCondition::Outdated => Some(deploy(desired)),
            ManagedCondition::Modified { changed } => Some(collision(
                desired,
                ConflictKind::Modified {
                    changed: changed.clone(),
                },
                policy,
            )),
            ManagedCondition::Replaced | ManagedCondition::Repointed => {
                Some(collision(desired, ConflictKind::Foreign, policy))
            }
            ManagedCondition::Clean | ManagedCondition::MetadataChangedButContentClean { .. }
                if managed.overlay_stale =>
            {
                Some(SyncChange::RewriteOverlay {
                    target: desired.target,
                    source: desired.source,
                    artifact: desired.artifact,
                })
            }
            ManagedCondition::Clean
            | ManagedCondition::MetadataChangedButContentClean { .. }
            | ManagedCondition::Linked => None,
        },
    }
}

fn classify_orphan<R>(
    entry: &ObservedEntry<R>,
    policy: ReconciliationPolicy,
) -> Option<SyncChange> {
    let ObservedArtifact::Managed(managed) = &entry.observation else {
        return None;
    };
    let reason = match managed.dropped {
        Some(reason) => reason,
        None if policy.prune => RemovalReason::Pruned,
        None => return None,
    };
    Some(match managed.condition.to_local_change() {
        Some(change) if !policy.force => SyncChange::RemoveConflict {
            target: entry.target.clone(),
            source: entry.source.clone(),
            artifact: entry.artifact.clone(),
            change,
            reason,
        },
        _ => SyncChange::Remove {
            target: entry.target.clone(),
            source: entry.source.clone(),
            artifact: entry.artifact.clone(),
            reason,
        },
    })
}

fn deploy(desired: DesiredArtifact) -> SyncChange {
    SyncChange::Deploy {
        target: desired.target,
        source: desired.source,
        artifact: desired.artifact,
    }
}

fn collision(
    desired: DesiredArtifact,
    kind: ConflictKind,
    policy: ReconciliationPolicy,
) -> SyncChange {
    if policy.force {
        SyncChange::Overwrite {
            target: desired.target,
            source: desired.source,
            artifact: desired.artifact,
        }
    } else {
        SyncChange::Conflict {
            target: desired.target,
            source: desired.source,
            artifact: desired.artifact,
            kind,
        }
    }
}

fn key_of<R>(entry: &ObservedEntry<R>) -> Key {
    (
        entry.target.clone(),
        entry.source.clone(),
        entry.artifact.clone(),
    )
}

pub(super) fn desired_keys(projection: &Projection) -> BTreeSet<Key> {
    desired_artifacts(projection)
        .map(|desired| (desired.target, desired.source, desired.artifact))
        .collect()
}

struct DesiredArtifact {
    target: String,
    source: String,
    artifact: String,
}

fn desired_artifacts(projection: &Projection) -> impl Iterator<Item = DesiredArtifact> + '_ {
    projection.targets.iter().flat_map(|target| {
        target.bindings.iter().flat_map(move |binding| {
            binding
                .artifacts
                .iter()
                .map(move |artifact| DesiredArtifact {
                    target: target.target.clone(),
                    source: binding.identity.clone(),
                    artifact: artifact.materialization.published_key().to_owned(),
                })
        })
    })
}