use std::collections::BTreeMap;
use std::fs;
use std::path::{Path, PathBuf};
use serde::{Deserialize, Serialize};
use thiserror::Error;
use crate::configuration::{ExecutionConfigurationError, WorkspaceConfiguration};
use crate::configuration_validation::validate_configuration;
use crate::diagnostics::{Diagnostic, DiagnosticPath};
use crate::ir::{Fingerprint, InputFingerprint, Repository, TargetReference};
use crate::paths::{
PathResolutionError, PathResolutionErrorKind, ResolvedRepositoryPaths, portable_relative_path,
resolve_input_file, resolve_workspace_paths,
};
mod fingerprints;
mod observations;
pub use fingerprints::fingerprint_bytes;
pub use observations::*;
pub const PANACHE_VERSION: &str = env!("DIPLODOCUS_PANACHE_VERSION");
pub fn builtin_tools() -> BTreeMap<String, String> {
BTreeMap::from([
("diplodocus".into(), env!("CARGO_PKG_VERSION").into()),
("panache-parser".into(), PANACHE_VERSION.into()),
])
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct DeclaredSourceInputs {
pub extraction: BTreeMap<TargetReference, Vec<PathBuf>>,
pub package_documentation: BTreeMap<String, Vec<PathBuf>>,
pub content: BTreeMap<String, Vec<PathBuf>>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StaticProvenance {
pub repositories: BTreeMap<String, Repository>,
pub revisions: BTreeMap<String, RepositoryObservation>,
pub inputs: BTreeMap<String, BTreeMap<DiagnosticPath, Fingerprint>>,
pub declared_environment_inputs: BTreeMap<String, Vec<InputFingerprint>>,
pub tools: BTreeMap<String, String>,
}
#[derive(Debug, Error)]
pub enum ProvenanceError {
#[error("invalid workspace configuration")]
Configuration {
diagnostics: Vec<Diagnostic>,
},
#[error("invalid execution declaration for collection `{collection}`: {source}")]
Execution {
collection: String,
source: ExecutionConfigurationError,
},
#[error(transparent)]
Path(#[from] PathResolutionError),
#[error("input selection names undeclared {kind} `{id}`")]
UnknownSelection {
kind: &'static str,
id: String,
},
#[error("input changed during collection: `{repository}` `{}`", path.as_str())]
InputChanged {
repository: String,
path: DiagnosticPath,
},
}
pub fn collect_static_provenance(
configuration_path: impl AsRef<Path>,
configuration: &WorkspaceConfiguration,
selections: &DeclaredSourceInputs,
) -> Result<StaticProvenance, ProvenanceError> {
let configuration_path = configuration_path.as_ref();
let diagnostics = validate_configuration(configuration);
if !diagnostics.is_empty() {
return Err(ProvenanceError::Configuration { diagnostics });
}
for collection in &configuration.content {
collection
.validate_execution()
.map_err(|source| ProvenanceError::Execution {
collection: collection.id.clone(),
source,
})?;
}
validate_selections(configuration, selections)?;
let resolved = resolve_workspace_paths(configuration_path, configuration)?;
let mut result = StaticProvenance {
repositories: BTreeMap::new(),
revisions: BTreeMap::new(),
inputs: BTreeMap::new(),
declared_environment_inputs: BTreeMap::new(),
tools: builtin_tools(),
};
let mut complete = vec![true; resolved.repositories.len()];
for repository in &resolved.repositories {
result.inputs.insert(repository.id.clone(), BTreeMap::new());
}
for package in &resolved.packages {
let repository = &resolved.repositories[package.repository_index];
result.insert(read_input(
configuration_path,
repository,
&package.metadata_path,
None,
)?)?;
for target in &package.targets {
let key = TargetReference {
package: package.id.clone(),
target: target.id.clone(),
};
if let Some(files) = selections.extraction.get(&key) {
for file in sorted(files) {
let path = resolve_input_file(
configuration_path,
"extraction.inputs",
file,
&package.path,
)?;
result.insert(read_input(configuration_path, repository, &path, None)?)?;
}
} else {
complete[package.repository_index] = false;
}
}
}
for repository in &resolved.repositories {
if let Some(files) = selections.package_documentation.get(&repository.id) {
for file in sorted(files) {
let path = resolve_input_file(
configuration_path,
"package.documentation",
file,
&repository.path,
)?;
result.insert(read_input(configuration_path, repository, &path, None)?)?;
}
}
}
for (collection, declaration) in resolved.content.iter().zip(&configuration.content) {
let repository = &resolved.repositories[collection.repository_index];
if let Some(files) = selections.content.get(&collection.id) {
for file in sorted(files) {
let path = resolve_input_file(
configuration_path,
"content.inputs",
file,
&collection.source_root,
)?;
if collection.path != collection.source_root && path != collection.path {
return Err(PathResolutionError {
configuration_path: configuration_path.to_owned(),
field: "content.inputs".into(),
kind: PathResolutionErrorKind::InvalidPath {
path: file.to_owned(),
reason: "single-file collections select only their declared file",
},
}
.into());
}
result.insert(read_input(configuration_path, repository, &path, None)?)?;
}
} else {
complete[collection.repository_index] = false;
}
let mut environment = BTreeMap::new();
for declared in sorted(&declaration.execution.declared_environment_inputs) {
let field = "content.execution.declared_environment_inputs";
let path = resolve_input_file(configuration_path, field, declared, &repository.path)?;
let portable = portable_relative_path(configuration_path, field, declared)?;
let normalized = resolve_input_file(
configuration_path,
field,
Path::new(portable.as_str()),
&repository.path,
)?;
if normalized != path {
return Err(PathResolutionError {
configuration_path: configuration_path.to_owned(),
field: field.into(),
kind: PathResolutionErrorKind::InvalidPath {
path: declared.to_owned(),
reason: "normalization changes the declared symlink/parent traversal",
},
}
.into());
}
let input = read_input(
configuration_path,
repository,
&path,
Some(portable.clone()),
)?;
result.insert(input.clone())?;
environment.insert(portable, input);
}
for path in &collection.julia_environment_inputs {
let input = read_input(configuration_path, repository, path, None)?;
result.insert(input.clone())?;
environment.insert(input.source.path.clone(), input);
}
result
.declared_environment_inputs
.insert(collection.id.clone(), environment.into_values().collect());
}
for (index, (repository, declaration)) in resolved
.repositories
.iter()
.zip(&configuration.repositories)
.enumerate()
{
let observation = observe_repository(repository, declaration.revision.as_deref());
result.repositories.insert(
repository.id.clone(),
Repository {
canonical_url: declaration.url.clone(),
source_link_template: declaration.source_link_template.clone(),
revision: observation
.declared
.clone()
.or_else(|| observation.observed.clone()),
dirty: observation.dirty,
declared_input_fingerprint: complete[index].then(|| {
fingerprints::fingerprint_manifest(
&repository.id,
&result.inputs[&repository.id],
)
}),
},
);
result.revisions.insert(repository.id.clone(), observation);
}
Ok(result)
}
impl StaticProvenance {
fn insert(&mut self, input: InputFingerprint) -> Result<(), ProvenanceError> {
let inputs = self
.inputs
.get_mut(&input.source.repository)
.expect("declared repository");
if let Some(previous) = inputs.insert(input.source.path.clone(), input.fingerprint.clone())
&& previous != input.fingerprint
{
return Err(ProvenanceError::InputChanged {
repository: input.source.repository,
path: input.source.path,
});
}
Ok(())
}
}
fn sorted(files: &[PathBuf]) -> Vec<&PathBuf> {
let mut files: Vec<_> = files.iter().collect();
files.sort();
files.dedup();
files
}
fn validate_selections(
configuration: &WorkspaceConfiguration,
selections: &DeclaredSourceInputs,
) -> Result<(), ProvenanceError> {
for key in selections.extraction.keys() {
if !configuration.packages.iter().any(|package| {
package.id == key.package
&& package.targets.iter().any(|target| target.id == key.target)
}) {
return Err(ProvenanceError::UnknownSelection {
kind: "target",
id: format!("{}::{}", key.package, key.target),
});
}
}
for key in selections.package_documentation.keys() {
if !configuration
.repositories
.iter()
.any(|repository| repository.id == *key)
{
return Err(ProvenanceError::UnknownSelection {
kind: "repository",
id: key.clone(),
});
}
}
for key in selections.content.keys() {
if !configuration
.content
.iter()
.any(|collection| collection.id == *key)
{
return Err(ProvenanceError::UnknownSelection {
kind: "collection",
id: key.clone(),
});
}
}
Ok(())
}
fn read_input(
configuration_path: &Path,
repository: &ResolvedRepositoryPaths,
path: &Path,
declared: Option<DiagnosticPath>,
) -> Result<InputFingerprint, ProvenanceError> {
let mut source = repository.source_location(path, None)?;
let canonical = repository.path.join(source.path.as_str());
let bytes = fs::read(&canonical).map_err(|source| PathResolutionError {
configuration_path: configuration_path.to_owned(),
field: "provenance.inputs".into(),
kind: PathResolutionErrorKind::FileSystem {
path: canonical,
source,
},
})?;
if let Some(path) = declared {
source.path = path;
}
Ok(InputFingerprint {
source,
fingerprint: fingerprint_bytes(&bytes),
})
}