use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};
use crate::config::DeployMode;
use crate::error::{Error, Result};
use crate::projection::model::Projection;
use crate::source::{
SourceStore, WorktreeAdminId, WorktreeMirrorAddress, WorktreeObservationLevel,
WorktreeObservationLock, WorktreeObservationRequest, WorktreeObservationResult,
};
use crate::sync::inspect::inspect;
use crate::sync::model::{
ManagedArtifact, ManagedCondition, ObservedArtifact, ObservedEntry, ObservedProjectState,
};
use crate::sync::state::{ArtifactKey, ArtifactRecord, StateStore};
use super::target::{self, ArtifactEntry, TargetRun};
use super::{DeployAll, PrunePolicy, target_run};
type ObservationKey = (String, String, String);
pub(super) fn observe_workspace<R>(
ctx: &DeployAll<'_, R>,
projection: &Projection,
) -> Result<ObservedProjectState<ArtifactRecord>>
where
R: StateStore,
{
let registry: &dyn StateStore = ctx.registry;
let store: &dyn StateStore = ctx.registry;
let mut observations: BTreeMap<ObservationKey, ObservedEntry<ArtifactRecord>> = BTreeMap::new();
let mut all_records: Option<Vec<ArtifactRecord>> = None;
let mut desired: Option<BTreeSet<ObservationKey>> = None;
for (target_name, target) in &ctx.config.targets {
let Some(target_projection) = projection
.targets
.iter()
.find(|tp| &tp.target == target_name)
else {
continue;
};
let run = target_run(ctx, target_name, target);
target::walk_projection_target(run, target_projection, registry, |run, entry| {
let mut observation = observe_entry(run, entry, registry, store, ctx.backend)?;
if matches!(observation, ObservedArtifact::Foreign(_)) {
if all_records.is_none() {
all_records = Some(ctx.records()?);
}
let records = all_records.as_deref().unwrap_or_default();
let desired =
desired.get_or_insert_with(|| super::reconcile::desired_keys(projection));
let binding = (run.target_name, entry.identity);
if let Some(adopted) =
adopt_undesired_record(ctx, binding, entry, records, desired, store)?
{
observation = adopted;
}
}
let published_key = entry.item.materialization.published_key().to_owned();
let triplet = (
run.target_name.to_owned(),
entry.identity.to_owned(),
published_key.clone(),
);
let record = ObservedEntry {
target: run.target_name.to_owned(),
source: entry.identity.to_owned(),
artifact: published_key,
observation,
};
if observations.insert(triplet.clone(), record).is_some() {
return Err(Error::Sync(format!(
"duplicate observed artifact {}:{} in target {}",
triplet.1, triplet.2, triplet.0
)));
}
Ok(false)
})?;
}
let list_all = || all_records.map_or_else(|| ctx.records(), Ok);
let dropped = ctx
.dropped
.iter()
.map(|drop| (drop.record.clone(), Some(drop.reason)));
let pruned = registry_only_records(&ctx.input.options().prune_policy, list_all)?
.into_iter()
.map(|record| (record, None));
let live_paths = super::prune::live_paths_by_source(projection, ctx.config);
for (record, dropped) in dropped.chain(pruned) {
let triplet = (
record.key.target.clone(),
record.key.source.clone(),
record.key.artifact.clone(),
);
if observations.contains_key(&triplet) {
continue;
}
let condition = observe_orphan_condition(ctx, &record, &live_paths)?;
observations.insert(
triplet,
ObservedEntry {
target: record.key.target.clone(),
source: record.key.source.clone(),
artifact: record.key.artifact.clone(),
observation: ObservedArtifact::Managed(ManagedArtifact {
record,
condition,
overlay_stale: false,
dropped,
}),
},
);
}
Ok(ObservedProjectState {
artifacts: observations.into_values().collect(),
})
}
pub(super) fn observe_history_retirements<R>(
ctx: &DeployAll<'_, R>,
) -> Result<Vec<ObservedEntry<ArtifactRecord>>>
where
R: StateStore,
{
let mut retirements = Vec::new();
for record in ctx.records()? {
if !record.history {
continue;
}
let Some(target) = ctx.config.targets.get(&record.key.target) else {
continue;
};
let Some(binding) = target
.resolve_sources(ctx.parsed)
.into_iter()
.find(|binding| binding.identity == record.key.source && !binding.history)
else {
continue;
};
let path = super::prune::removal_destination(target, &record);
let ejected = ctx.registry.ejections(&record.key.target)?;
let observation = inspect(
&path,
binding.identity,
&record.commit,
&ejected,
ctx.registry,
&record.key,
None,
)?;
retirements.push(ObservedEntry {
target: record.key.target.clone(),
source: record.key.source.clone(),
artifact: record.key.artifact.clone(),
observation,
});
}
Ok(retirements)
}
fn observe_orphan_condition<R>(
ctx: &DeployAll<'_, R>,
record: &ArtifactRecord,
live_paths: &super::prune::LivePathsBySource,
) -> Result<ManagedCondition>
where
R: StateStore,
{
if super::prune::is_ejected(record, ctx.registry)? {
return Ok(ManagedCondition::Clean);
}
let Ok(Some(path)) = super::prune::locate_removal(ctx.config, record, ctx.protected) else {
return Ok(ManagedCondition::Clean);
};
if super::prune::overlaps_any_live_path(&path, live_paths) {
return Ok(ManagedCondition::Clean);
}
Ok(
super::prune::detect_local_change(record, &path, ctx.registry)?
.map_or(ManagedCondition::Clean, ManagedCondition::from),
)
}
fn registry_only_records(
prune: &PrunePolicy,
list_all: impl FnOnce() -> Result<Vec<ArtifactRecord>>,
) -> Result<Vec<ArtifactRecord>> {
if !prune.prunes() {
return Ok(Vec::new());
}
Ok(list_all()?
.into_iter()
.filter(|record| prune.removes(record))
.collect())
}
fn adopt_undesired_record<R>(
ctx: &DeployAll<'_, R>,
(target_name, identity): (&str, &str),
entry: &ArtifactEntry<'_>,
records: &[ArtifactRecord],
desired: &BTreeSet<ObservationKey>,
store: &dyn StateStore,
) -> Result<Option<ObservedArtifact<ArtifactRecord>>>
where
R: StateStore,
{
let destination: PathBuf = entry.artifact_dst.components().collect();
for orphan in records.iter().filter(|record| {
!record.history
&& (record.key.target.as_str(), record.key.source.as_str()) != (target_name, identity)
&& !desired.contains(&(
record.key.target.clone(),
record.key.source.clone(),
record.key.artifact.clone(),
))
&& recorded_destination(ctx, record).as_ref() == Some(&destination)
}) {
if orphan_matches_destination(orphan, entry, store)? {
return Ok(Some(ObservedArtifact::Managed(ManagedArtifact {
record: orphan.clone(),
condition: ManagedCondition::Outdated,
overlay_stale: false,
dropped: None,
})));
}
}
Ok(None)
}
fn orphan_matches_destination(
orphan: &ArtifactRecord,
entry: &ArtifactEntry<'_>,
store: &dyn StateStore,
) -> Result<bool> {
if orphan.linked {
return Ok(entry.source.deploy_mode() == DeployMode::Link
&& std::fs::read_link(entry.artifact_dst)
.is_ok_and(|link| link == target::link_target(entry)));
}
let observation = inspect(
entry.artifact_dst,
&orphan.key.source,
&orphan.commit,
&[],
store,
&orphan.key,
None,
)?;
Ok(matches!(
observation,
ObservedArtifact::Managed(ManagedArtifact {
condition: ManagedCondition::Clean
| ManagedCondition::MetadataChangedButContentClean { .. }
| ManagedCondition::Outdated,
..
})
))
}
fn recorded_destination<R>(ctx: &DeployAll<'_, R>, record: &ArtifactRecord) -> Option<PathBuf> {
match ctx.config.targets.get(&record.key.target) {
Some(target) => Some(
super::prune::removal_destination(target, record)
.components()
.collect(),
),
None => super::prune::orphan_artifact_path(record),
}
}
fn observe_entry(
run: &TargetRun<'_>,
entry: &ArtifactEntry<'_>,
registry: &dyn StateStore,
store: &dyn StateStore,
backend: &dyn SourceStore,
) -> Result<ObservedArtifact<ArtifactRecord>> {
let key = ArtifactKey {
target: run.target_name.to_owned(),
source: entry.identity.to_owned(),
artifact: entry.item.materialization.published_key().to_owned(),
};
let vars_digest = target::expected_vars_digest(entry, registry, &key, run.vars)?;
let observation = inspect(
entry.artifact_dst,
entry.identity,
entry.commit,
entry.ejected,
store,
&key,
vars_digest.as_deref(),
)?;
let observation = absorb_mode_transition(observation, entry.mode_transition);
observe_overlay(backend, entry, observation)
}
fn observe_overlay(
backend: &dyn SourceStore,
entry: &ArtifactEntry<'_>,
observation: ObservedArtifact<ArtifactRecord>,
) -> Result<ObservedArtifact<ArtifactRecord>> {
let ObservedArtifact::Managed(mut managed) = observation else {
return Ok(observation);
};
let Some(request) = history_observation_request(
&managed.record,
entry.resolved.name.clone(),
entry.artifact_dst,
WorktreeObservationLock::Wait,
WorktreeObservationLevel::Semantic,
)?
else {
return Ok(ObservedArtifact::Managed(managed));
};
managed.overlay_stale = backend.observe_worktree(&request)? == WorktreeObservationResult::Stale;
Ok(ObservedArtifact::Managed(managed))
}
pub(crate) fn history_observation_request(
record: &ArtifactRecord,
source: crate::source::SourceName,
deploy_root: &Path,
lock: WorktreeObservationLock,
level: WorktreeObservationLevel,
) -> Result<Option<WorktreeObservationRequest>> {
if record.linked {
return Ok(None);
}
let Some((address, admin_id)) = history_address(record)? else {
return Ok(None);
};
let deploy_root = normalize_history_deploy_root(deploy_root)?;
match std::fs::symlink_metadata(&deploy_root) {
Ok(metadata) if metadata.is_dir() => {}
Ok(_) => return Ok(None),
Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
Err(error) => {
return Err(Error::Sync(format!(
"stat history deployment root {}: {error}",
deploy_root.display()
)));
}
}
let expected_commit = record.commit.parse().map_err(|error| {
Error::Sync(format!(
"parse history record commit {}: {error}",
record.commit
))
})?;
Ok(Some(WorktreeObservationRequest {
source,
address,
admin_id,
deploy_root,
expected_commit,
lock,
level,
}))
}
pub(crate) fn normalize_history_deploy_root(deploy_root: &Path) -> Result<PathBuf> {
Ok(normalize_history_deploy_root_at(
&super::target::project_root()?,
deploy_root,
))
}
pub(crate) fn normalize_history_deploy_root_at(project_root: &Path, deploy_root: &Path) -> PathBuf {
if deploy_root.is_absolute() {
deploy_root.to_path_buf()
} else {
project_root.join(deploy_root)
}
}
pub(crate) fn history_address(
record: &ArtifactRecord,
) -> Result<Option<(WorktreeMirrorAddress, WorktreeAdminId)>> {
if !record.history {
return Ok(None);
}
let (Some(cache_git_root), Some(mirror_key), Some(worktree_admin_id)) = (
record.cache_git_root.as_deref(),
record.mirror_key.as_deref(),
record.worktree_admin_id.as_deref(),
) else {
return Ok(None);
};
let cache_git_root = PathBuf::from(cache_git_root);
if !cache_git_root.is_absolute() {
return Err(Error::Sync(format!(
"history cache git root must be absolute: {}",
cache_git_root.display()
)));
}
let key = mirror_key
.parse()
.map_err(|error| Error::Sync(format!("parse history mirror key {mirror_key}: {error}")))?;
let admin_id = worktree_admin_id.parse().map_err(|error| {
Error::Sync(format!(
"parse history worktree administration ID {worktree_admin_id}: {error}"
))
})?;
Ok(Some((
WorktreeMirrorAddress {
cache_git_root,
key,
},
admin_id,
)))
}
pub(super) fn absorb_mode_transition<R>(
observation: ObservedArtifact<R>,
mode_transition: bool,
) -> ObservedArtifact<R> {
match observation {
ObservedArtifact::Managed(managed)
if mode_transition
&& matches!(
managed.condition,
ManagedCondition::Clean
| ManagedCondition::Linked
| ManagedCondition::MetadataChangedButContentClean { .. }
) =>
{
ObservedArtifact::Managed(ManagedArtifact {
record: managed.record,
condition: ManagedCondition::Outdated,
overlay_stale: managed.overlay_stale,
dropped: managed.dropped,
})
}
other => other,
}
}