orchestral-cli 0.1.0

Command line interface for running Orchestral workflows
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

use std::env;
use std::fs;
use std::path::Path;

use serde_json::json;

fn main() {
    match run() {
        Ok((report, code)) | Err((report, code)) => {
            println!(
                "{}",
                serde_json::to_string_pretty(&report).unwrap_or_else(|_| {
                    "{\"ok\":false,\"error\":\"failed to serialize verification report\"}"
                        .to_string()
                })
            );
            if code != 0 {
                std::process::exit(code);
            }
        }
    }
}

fn run() -> Result<(serde_json::Value, i32), (serde_json::Value, i32)> {
    let args = env::args().collect::<Vec<_>>();
    if args.len() != 2 {
        return Err((
            json!({
                "ok": false,
                "error": "usage: verify_structured_patch <path>",
            }),
            2,
        ));
    }

    let path = Path::new(&args[1]);
    let raw = fs::read_to_string(path).map_err(|err| {
        (
            json!({
                "ok": false,
                "path": path.display().to_string(),
                "error": format!("read failed: {}", err),
            }),
            1,
        )
    })?;
    let data: serde_json::Value = serde_json::from_str(&raw).map_err(|err| {
        (
            json!({
                "ok": false,
                "path": path.display().to_string(),
                "error": format!("parse json failed: {}", err),
            }),
            1,
        )
    })?;

    let mut failures = Vec::new();
    if data.pointer("/service/enabled") != Some(&json!(true)) {
        failures.push("service.enabled was not set to true".to_string());
    }
    if data.pointer("/service/port") != Some(&json!(9090)) {
        failures.push("service.port was not set to 9090".to_string());
    }
    if data.pointer("/owner") != Some(&json!("platform-team")) {
        failures.push("owner was not updated to platform-team".to_string());
    }
    if data.pointer("/features/audit") != Some(&json!(true)) {
        failures.push("features.audit was not set to true".to_string());
    }
    if data.pointer("/obsolete").is_some() {
        failures.push("obsolete key still exists".to_string());
    }

    let report = json!({
        "ok": failures.is_empty(),
        "path": path.display().to_string(),
        "service": data.get("service").cloned().unwrap_or(serde_json::Value::Null),
        "owner": data.get("owner").cloned().unwrap_or(serde_json::Value::Null),
        "features": data.get("features").cloned().unwrap_or(serde_json::Value::Null),
        "failures": failures,
    });
    if report
        .get("ok")
        .and_then(serde_json::Value::as_bool)
        .unwrap_or(false)
    {
        Ok((report, 0))
    } else {
        Err((report, 1))
    }
}