dpm-engine 0.1.0

Command/query execution engine for DPM
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

//! Resolving a run's source references to exact commits the plan supports.

use super::RunError;
use dpm_model::{
    Artifact, ArtifactKind, AssetId, AssetKind, ExactSource, Plan, RunSource, WorkItem,
    is_exact_commit,
};

/// Resolve one source reference to the exact commit it names, or refuse it.
///
/// A named commit must belong to a Git repository asset the task requires. Evidence must be a
/// `GitCommit` artifact attached to this task whose `commit` and `asset_id` metadata and
/// `git:asset:ASSET@COMMIT` URI agree on one exact commit of such an asset: a kind tag alone, or a
/// mutable locator such as a branch, proves nothing about what the run executes against.
pub(super) fn resolve(
    plan: &Plan,
    work: &WorkItem,
    source: &RunSource,
) -> Result<ExactSource, RunError> {
    match source {
        RunSource::GitCommit { asset, commit } => {
            repository(plan, work, *asset)?;
            Ok(ExactSource {
                asset: *asset,
                commit: commit.clone(),
                artifact: None,
            })
        }
        RunSource::Artifact { artifact } => {
            let found = plan
                .artifacts
                .get(artifact)
                .ok_or_else(|| unsupported(format!("artifact {artifact} is not in the plan")))?;
            if !work.execution.artifact_ids.contains(artifact) {
                return Err(unsupported(format!(
                    "artifact {artifact} is not attached to {}",
                    work.key
                )));
            }
            let (asset, commit) = evidence(artifact.to_string(), found)?;
            repository(plan, work, asset)?;
            Ok(ExactSource {
                asset,
                commit,
                artifact: Some(*artifact),
            })
        }
    }
}

/// The asset and commit a `GitCommit` artifact consistently names.
fn evidence(label: String, found: &Artifact) -> Result<(AssetId, String), RunError> {
    if found.kind != ArtifactKind::GitCommit {
        return Err(unsupported(format!(
            "artifact {label} is not Git commit evidence"
        )));
    }
    let metadata = |name: &str| {
        found
            .metadata
            .get(name)
            .ok_or_else(|| unsupported(format!("artifact {label} has no `{name}` metadata")))
    };
    let commit = metadata("commit")?;
    if !is_exact_commit(commit) {
        return Err(unsupported(format!(
            "artifact {label} names {commit:?}, not a full commit; a branch or abbreviation is not an exact source"
        )));
    }
    let asset: AssetId = metadata("asset_id")?
        .parse()
        .map_err(|_| unsupported(format!("artifact {label} has an invalid `asset_id`")))?;
    if found.uri != format!("git:asset:{asset}@{commit}") {
        return Err(unsupported(format!(
            "artifact {label} locator {:?} disagrees with its commit and asset",
            found.uri
        )));
    }
    Ok((asset, commit.clone()))
}

/// The asset must be a Git repository the task's contract requires.
fn repository(plan: &Plan, work: &WorkItem, asset: AssetId) -> Result<(), RunError> {
    if !work.contract.assets.iter().any(|need| need.asset == asset) {
        return Err(unsupported(format!(
            "asset {asset} is not required by {}",
            work.key
        )));
    }
    match plan.assets.get(&asset).map(|found| &found.kind) {
        Some(AssetKind::GitRepository { .. }) => Ok(()),
        Some(_) => Err(unsupported(format!(
            "asset {asset} is not a Git repository"
        ))),
        None => Err(unsupported(format!("asset {asset} is not in the plan"))),
    }
}

fn unsupported(reason: String) -> RunError {
    RunError::UnsupportedSource(reason)
}