use std::collections::BTreeMap;
use std::path::Path;
use crate::config::{Config, DeployMode, ParsedSource, Target};
use crate::error::{Error, Result};
use crate::lock::encode_ref;
use crate::source::{SourceInventory, SourceStore};
use super::discover::discover_working_tree_leaves;
use super::remote_for;
use super::resolve::ResolvedSourceMap;
use crate::projection::build::{build_workspace, project_target};
use crate::projection::model::{
BindingProjectionInput, CollapsePreference, LayoutSpec, MaterializationPolicy, OfferSpec,
Projection, ResolvedSourceRef, TakeSpec, TargetProjection, TemplatePolicy,
WorkspaceTargetInput,
};
pub fn plan_target(
target_name: &str,
target: &Target,
parsed: &BTreeMap<String, ParsedSource>,
remotes: &BTreeMap<String, String>,
store: &dyn SourceStore,
resolved_commits: &BTreeMap<(String, String), String>,
resolved_sources: &ResolvedSourceMap,
) -> Result<TargetProjection> {
let discovery = discover_target(
target,
parsed,
remotes,
store,
resolved_commits,
resolved_sources,
)?;
Ok(project_target(target_name, &binding_inputs(&discovery))?)
}
struct TargetDiscovery {
layout: LayoutSpec,
discovered: Vec<DiscoveredBinding>,
}
fn discover_target(
target: &Target,
parsed: &BTreeMap<String, ParsedSource>,
remotes: &BTreeMap<String, String>,
store: &dyn SourceStore,
resolved_commits: &BTreeMap<(String, String), String>,
resolved_sources: &ResolvedSourceMap,
) -> Result<TargetDiscovery> {
let layout = LayoutSpec::from(&target.layout());
let mut discovered = Vec::new();
for binding in target.resolve_sources(parsed) {
let source = parsed.get(binding.source).ok_or_else(|| {
Error::Config(format!(
"target references undefined source: {}",
binding.source
))
})?;
let commit_key = (
binding.source.to_owned(),
encode_ref(&binding.effective_ref),
);
let commit = resolved_commits
.get(&commit_key)
.ok_or_else(|| {
Error::Sync(format!(
"no resolved commit for {} at {}",
binding.source, binding.effective_ref
))
})?
.clone();
let resolved = resolved_sources
.get(&(binding.source.to_owned(), commit.clone()))
.ok_or_else(|| {
Error::Sync(format!(
"no resolved snapshot for {} at {commit}",
binding.source
))
})?;
let leaves = discover_binding_leaves(source, binding.source, remotes, store, resolved)?;
discovered.push(DiscoveredBinding {
identity: binding.identity.to_owned(),
source: ResolvedSourceRef::new(binding.source, commit),
inventory: SourceInventory::from_paths(leaves)?,
offer: OfferSpec::from(source.offer()),
take: TakeSpec::from_entries(binding.take),
composed_take: binding
.composed_take
.map(|take| TakeSpec::from_entries(Some(take))),
history: binding.history,
materialization: MaterializationPolicy::from(&source.deploy_mode()),
collapse: CollapsePreference::from(binding.collapse),
templates: TemplatePolicy::from(&binding.template_opt_in),
});
}
Ok(TargetDiscovery { layout, discovered })
}
fn binding_inputs(discovery: &TargetDiscovery) -> Vec<BindingProjectionInput<'_>> {
discovery
.discovered
.iter()
.map(|d| BindingProjectionInput {
identity: &d.identity,
source: &d.source,
offer: &d.offer,
inventory: &d.inventory,
take: &d.take,
composed_take: d.composed_take.as_ref(),
collapse: d.collapse,
history: d.history,
materialization: d.materialization,
layout: &discovery.layout,
templates: &d.templates,
})
.collect()
}
struct DiscoveredBinding {
identity: String,
source: ResolvedSourceRef,
inventory: SourceInventory,
offer: OfferSpec,
take: TakeSpec,
composed_take: Option<TakeSpec>,
history: bool,
materialization: MaterializationPolicy,
collapse: CollapsePreference,
templates: TemplatePolicy,
}
fn discover_binding_leaves(
source: &ParsedSource,
source_name: &str,
remotes: &BTreeMap<String, String>,
store: &dyn SourceStore,
resolved: &crate::source::ResolvedSource,
) -> Result<Vec<String>> {
let git = remote_for(remotes, source_name)?;
match source.deploy_mode() {
DeployMode::Link => Ok(discover_working_tree_leaves(
Path::new(git),
None,
source.export_policy(false).allow_symlinks,
)?),
DeployMode::Copy => Ok(store
.inventory(&resolved.snapshot, None)?
.entries
.into_iter()
.map(|entry| entry.path.to_string())
.collect()),
}
}
#[must_use = "a projection describes deployments but performs none; consume the returned Projection"]
pub fn project_workspace(
config: &Config,
parsed: &BTreeMap<String, ParsedSource>,
remotes: &BTreeMap<String, String>,
store: &dyn SourceStore,
resolved_commits: &BTreeMap<(String, String), String>,
resolved_sources: &ResolvedSourceMap,
) -> Result<Projection> {
let discoveries = config
.targets
.iter()
.map(|(name, target)| {
Ok((
name.as_str(),
discover_target(
target,
parsed,
remotes,
store,
resolved_commits,
resolved_sources,
)?,
))
})
.collect::<Result<Vec<_>>>()?;
let workspace: Vec<WorkspaceTargetInput<'_>> = discoveries
.iter()
.map(|(name, discovery)| WorkspaceTargetInput {
target: name,
bindings: binding_inputs(discovery),
})
.collect();
Ok(build_workspace(&workspace)?)
}