vade-cli 0.1.0

A command-line tool to deploy applications on Linux servers
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

use crate::app_name::AppName;
use crate::cli::{OverrideScope, VarOverride};
use crate::config::AppConfig;
use crate::config::TemplateAndUserVars;
use crate::config::TomlSource;
use crate::templating::BuiltinTemplateKind;
use crate::util::{RelativePathResolver, ResolvedPath, diagnostic_with_help};
use miette::{Report, miette};

pub struct AppDeployment {
    pub artifacts: Option<ResolvedPath>,
    pub caddyfile: Option<TemplateAndUserVars>,
    pub systemd_units: Vec<SystemdUnit>,
}

pub struct SystemdUnit {
    pub name: String,
    pub template: TemplateAndUserVars,
}

impl AppDeployment {
    pub fn from_config(
        app_name: &AppName,
        config: AppConfig,
        config_source: &TomlSource,
        overrides: &[VarOverride],
        path_resolver: &RelativePathResolver,
    ) -> Result<Self, Report> {
        let artifacts_dir = config
            .artifacts()
            .map(|artifacts| (artifacts, path_resolver.resolve(&artifacts.path.value)));

        // Sanity check artifacts dir
        if let Some((raw_artifacts, artifacts_dir)) = &artifacts_dir
            && !artifacts_dir.is_dir()
        {
            return Err(diagnostic_with_help(
                "failed to locate artifacts",
                "the provided path does not exist or is not a directory".to_string(),
                format!(
                    "the artifacts path resolved to `{}`",
                    artifacts_dir.display()
                ),
                raw_artifacts.span().into(),
                config_source.to_named_source(),
            ));
        }

        // Load Caddyfile
        let mut caddyfile = config
            .caddyfile()
            .map(|c| {
                c.template().load_template_source(
                    config_source,
                    path_resolver,
                    BuiltinTemplateKind::Caddyfile,
                )
            })
            .transpose()?;

        // Load systemd units
        let mut systemd_units = Vec::new();
        for c in config.systemd_units() {
            let template = c.template().load_template_source(
                config_source,
                path_resolver,
                BuiltinTemplateKind::SystemdUnit,
            )?;
            systemd_units.push(SystemdUnit {
                name: c.filename(app_name.as_str()),
                template,
            });
        }

        // Apply overrides on top of the user-provided variables from the config
        apply_overrides(overrides, caddyfile.as_mut(), &mut systemd_units)?;

        Ok(AppDeployment {
            artifacts: artifacts_dir.map(|(_, a)| a),
            caddyfile,
            systemd_units,
        })
    }
}

fn apply_overrides(
    overrides: &[VarOverride],
    mut caddyfile: Option<&mut TemplateAndUserVars>,
    systemd_units: &mut [SystemdUnit],
) -> Result<(), Report> {
    for var_override in overrides {
        let user_vars = match var_override.scope {
            OverrideScope::Caddyfile => {
                &mut caddyfile
                    .as_deref_mut()
                    .ok_or_else(|| {
                        miette!(
                            "--set targets `caddyfile`, but the configuration does not have a `[caddyfile]` section"
                        )
                    })?
                    .user_vars
            }
            OverrideScope::SystemdUnit(index) => {
                let systemd_units_len = systemd_units.len();
                &mut systemd_units
                    .get_mut(index)
                    .ok_or_else(|| {
                        miette!(
                            "--set targets `systemd-unit[{index}]`, but the configuration does not have a systemd unit at that index (the total number of systemd units is {})", systemd_units_len)
                    })?
                    .template
                    .user_vars
            }
        };

        user_vars.set(var_override.name.clone(), var_override.value.clone());
    }

    Ok(())
}