perspt-dashboard 0.5.8

Real-time web dashboard for Perspt agent monitoring
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use perspt_store::{
    EscalationReportRecord, PlanRevisionRow, RepairFootprintRow, RewriteRecordRow,
    SheafValidationRow, VerificationResultRow,
};

/// View model for the decisions trace page
pub struct DecisionsViewModel {
    pub session_id: String,
    pub escalations: Vec<EscalationRow>,
    pub sheaf_validations: Vec<SheafRow>,
    pub rewrites: Vec<RewriteRow>,
    pub plan_revisions: Vec<PlanRow>,
    pub repair_footprints: Vec<RepairRow>,
    pub verifications: Vec<VerificationRow>,
}

pub struct EscalationRow {
    pub node_id: String,
    pub category: String,
    pub action: String,
    pub evidence: String,
}

pub struct SheafRow {
    pub node_id: String,
    pub validator_class: String,
    pub passed: bool,
    pub evidence_summary: String,
    pub v_sheaf_contribution: f32,
}

pub struct RewriteRow {
    pub node_id: String,
    pub action: String,
    pub category: String,
    pub requeued_nodes: String,
    pub inserted_nodes: String,
}

pub struct PlanRow {
    pub revision_id: String,
    pub sequence: i32,
    pub reason: String,
    pub status: String,
}

pub struct RepairRow {
    pub node_id: String,
    pub attempt: i32,
    pub diagnosis: String,
    pub resolved: bool,
}

pub struct VerificationRow {
    pub node_id: String,
    pub syntax_ok: bool,
    pub build_ok: bool,
    pub tests_ok: bool,
    pub lint_ok: bool,
    pub tests_passed: i32,
    pub tests_failed: i32,
    pub degraded: bool,
    pub degraded_reason: String,
}

impl DecisionsViewModel {
    pub fn from_store(
        session_id: String,
        escalations: Vec<EscalationReportRecord>,
        sheaf_validations: Vec<SheafValidationRow>,
        rewrites: Vec<RewriteRecordRow>,
        plan_revisions: Vec<PlanRevisionRow>,
        repair_footprints: Vec<RepairFootprintRow>,
        verifications: Vec<VerificationResultRow>,
    ) -> Self {
        Self {
            session_id,
            escalations: escalations
                .into_iter()
                .map(|e| EscalationRow {
                    node_id: e.node_id,
                    category: e.category,
                    action: e.action,
                    evidence: e.evidence,
                })
                .collect(),
            sheaf_validations: sheaf_validations
                .into_iter()
                .map(|s| SheafRow {
                    node_id: s.node_id,
                    validator_class: s.validator_class,
                    passed: s.passed,
                    evidence_summary: s.evidence_summary,
                    v_sheaf_contribution: s.v_sheaf_contribution,
                })
                .collect(),
            rewrites: rewrites
                .into_iter()
                .map(|r| RewriteRow {
                    node_id: r.node_id,
                    action: r.action,
                    category: r.category,
                    requeued_nodes: r.requeued_nodes,
                    inserted_nodes: r.inserted_nodes,
                })
                .collect(),
            plan_revisions: plan_revisions
                .into_iter()
                .map(|p| PlanRow {
                    revision_id: p.revision_id,
                    sequence: p.sequence,
                    reason: p.reason,
                    status: p.status,
                })
                .collect(),
            repair_footprints: repair_footprints
                .into_iter()
                .map(|r| RepairRow {
                    node_id: r.node_id,
                    attempt: r.attempt,
                    diagnosis: r.diagnosis,
                    resolved: r.resolved,
                })
                .collect(),
            verifications: verifications
                .into_iter()
                .map(|v| VerificationRow {
                    node_id: v.node_id,
                    syntax_ok: v.syntax_ok,
                    build_ok: v.build_ok,
                    tests_ok: v.tests_ok,
                    lint_ok: v.lint_ok,
                    tests_passed: v.tests_passed,
                    tests_failed: v.tests_failed,
                    degraded: v.degraded,
                    degraded_reason: v.degraded_reason.unwrap_or_default(),
                })
                .collect(),
        }
    }
}