ambient-ci 0.14.0

A continuous integration engine
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use std::path::PathBuf;

use clap::Parser;
use serde::Serialize;

use ambient_ci::{
    plan::{construct_all_plans, construct_runnable_plan, RunnablePlan},
    project::{ProjectError, Projects, State},
    runlog::RunLog,
};

use super::{AmbientError, Config, Leaf};

/// Prepare image.
#[derive(Debug, Parser)]
pub struct Plan {
    /// Project specification file. May contain any number of projects.
    #[clap(long)]
    projects: Option<PathBuf>,

    /// Which project to show plan for?
    project: String,

    /// rsync target for publishing artifacts with rsync program.
    #[clap(long, aliases = ["rsync", "target"])]
    rsync_target: Option<String>,

    /// dput target for publishing .deb package.
    #[clap(long, alias = "dput")]
    dput_target: Option<String>,

    /// Output as YAML. Default is JSON.
    #[clap(long)]
    yaml: bool,

    /// Output runnable plan for `ambient-exeucte-plan`.
    #[clap(long)]
    runnable: bool,
}

impl Leaf for Plan {
    fn run(&self, config: &Config, _runlog: &mut RunLog) -> Result<(), AmbientError> {
        let projects = if let Some(filename) = &self.projects {
            filename.to_path_buf()
        } else {
            config.projects().into()
        };

        let projects =
            Projects::from_file(&projects).map_err(|err| PlanError::FromFile(projects, err))?;
        let project = projects
            .get(&self.project)
            .ok_or(PlanError::NoSuchProject(self.project.clone()))?;

        config.lint(&projects)?;

        if self.runnable {
            let runnable = construct_runnable_plan(project.plan()).map_err(PlanError::Runnable)?;
            let text = if self.yaml {
                serde_norway::to_string(&runnable).map_err(PlanError::ToYaml)?
            } else {
                serde_json::to_string_pretty(&runnable).map_err(PlanError::ToJson)?
            };
            println!("{text}");
        } else {
            let mut config = config.clone();
            if let Some(s) = &self.dput_target {
                config.set_dput_target(s);
            };
            if let Some(s) = &self.rsync_target {
                config.set_rsync_target(s);
            };

            let state =
                State::from_file(config.state(), &self.project).map_err(PlanError::State)?;

            let (pre_plan, plan, post_plan) =
                construct_all_plans(&config, &self.project, project, &state)?;
            let plans = Plans {
                pre_plan,
                plan,
                post_plan,
            };

            let text = if self.yaml {
                serde_norway::to_string(&plans).map_err(PlanError::ToYaml)?
            } else {
                serde_json::to_string_pretty(&plans).map_err(PlanError::ToJson)?
            };
            println!("{text}");
        }

        Ok(())
    }
}

#[derive(Serialize)]
struct Plans {
    pre_plan: RunnablePlan,
    plan: RunnablePlan,
    post_plan: RunnablePlan,
}

#[derive(Debug, thiserror::Error)]
pub enum PlanError {
    #[error("failed to load project list from file {0}")]
    FromFile(PathBuf, #[source] ProjectError),

    #[error("failed to serialize plans to JSON")]
    ToJson(#[source] serde_json::Error),

    #[error("failed to serialize plans to YAML")]
    ToYaml(#[source] serde_norway::Error),

    #[error("can't find project {0}")]
    NoSuchProject(String),

    #[error("can't construct runnable plan")]
    Runnable(#[source] ambient_ci::plan::PlanError),

    #[error("can't load project state")]
    State(#[source] ambient_ci::project::ProjectError),
}