holdon 0.1.1

Wait for anything. Know why if it doesn't.
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
124
125
126

#![allow(clippy::unused_self)]

use std::io::{self, Write};
use std::time::SystemTime;

use serde_json::{Value, json};

use holdon::Target;
use holdon::diagnostic::{Stage, StageResult};
use holdon::runner::{Event, Report, TargetReport};
use holdon::util::duration_ms;

const VERSION: u8 = 1;

fn now_unix_ms() -> u64 {
    SystemTime::now()
        .duration_since(SystemTime::UNIX_EPOCH)
        .map_or(0, |d| u64::try_from(d.as_millis()).unwrap_or(u64::MAX))
}

#[derive(Debug)]
pub(crate) struct Json;

impl Json {
    pub(crate) const fn new() -> Self {
        Self
    }

    pub(crate) fn banner(&self, targets: &[Target]) {
        emit(&json!({
            "v": VERSION,
            "ts_unix_ms": now_unix_ms(),
            "event": "start",
            "targets": targets.iter().map(ToString::to_string).collect::<Vec<_>>(),
        }));
    }

    pub(crate) fn event(&self, ev: &Event) {
        if let Event::Attempt {
            target,
            attempt,
            latency,
            ready,
            ..
        } = ev
        {
            emit(&json!({
                "v": VERSION,
                "ts_unix_ms": now_unix_ms(),
                "event": "attempt",
                "target": target.to_string(),
                "attempt": attempt,
                "latency_ms": duration_ms(*latency),
                "ready": ready,
            }));
        }
    }

    pub(crate) fn summary(&self, report: &Report) {
        for r in &report.results {
            emit(&target_event(r));
        }
        let ready_targets: Vec<String> = report
            .results
            .iter()
            .filter(|r| r.satisfied)
            .map(|r| r.target.to_string())
            .collect();
        let failed_targets: Vec<String> = report
            .results
            .iter()
            .filter(|r| !r.satisfied)
            .map(|r| r.target.to_string())
            .collect();
        emit(&json!({
            "v": VERSION,
            "ts_unix_ms": now_unix_ms(),
            "event": "end",
            "ready": report.all_ready(),
            "elapsed_ms": duration_ms(report.elapsed),
            "total": report.results.len(),
            "ready_targets": ready_targets,
            "failed_targets": failed_targets,
        }));
    }
}

fn target_event(r: &TargetReport) -> Value {
    json!({
        "v": VERSION,
        "ts_unix_ms": now_unix_ms(),
        "event": "target",
        "target": r.target.to_string(),
        "satisfied": r.satisfied,
        "ready": r.final_outcome.is_ready(),
        "attempts": r.attempts,
        "elapsed_ms": duration_ms(r.final_outcome.total),
        "stages": r.final_outcome.stages.iter().map(stage_value).collect::<Vec<_>>(),
    })
}

fn stage_value(s: &Stage) -> Value {
    let (status, message, hint) = if let StageResult::Err { message, hint } = &s.result {
        (
            "err",
            Some(message.as_ref()),
            hint.as_ref().map(AsRef::as_ref),
        )
    } else {
        ("ok", None, None)
    };
    json!({
        "kind": s.kind.as_str(),
        "status": status,
        "took_ms": duration_ms(s.took),
        "message": message,
        "hint": hint,
    })
}

fn emit(v: &Value) {
    let mut stdout = io::stdout().lock();
    if let Ok(s) = serde_json::to_string(v) {
        let _ = writeln!(stdout, "{s}");
    }
}