consortium-cli 0.3.1

CLI tools for consortium — claw, molt, pinch
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

use consortium_cli::tree::{render, NodeStatus, OutputFormat, TreeNode};

struct N {
    label: String,
    status: Option<NodeStatus>,
    meta: Vec<(String, String)>,
    kids: Vec<N>,
}
impl N {
    fn n(s: &str) -> Self {
        Self {
            label: s.into(),
            status: None,
            meta: vec![],
            kids: vec![],
        }
    }
    fn st(mut self, s: NodeStatus) -> Self {
        self.status = Some(s);
        self
    }
    fn m(mut self, k: &str, v: &str) -> Self {
        self.meta.push((k.into(), v.into()));
        self
    }
    fn k(mut self, ks: Vec<N>) -> Self {
        self.kids = ks;
        self
    }
}
impl TreeNode for N {
    fn label(&self) -> String {
        self.label.clone()
    }
    fn status(&self) -> Option<NodeStatus> {
        self.status.clone()
    }
    fn metadata(&self) -> Vec<(String, String)> {
        self.meta.clone()
    }
    fn children(&self) -> Vec<&dyn TreeNode> {
        self.kids.iter().map(|c| c as &dyn TreeNode).collect()
    }
}

fn main() {
    let cascade = N::n("seir (build host)")
        .st(NodeStatus::Ok)
        .m("round", "0")
        .k(vec![
            N::n("hp01")
                .st(NodeStatus::Ok)
                .m("round", "1")
                .m("dur", "12ms")
                .k(vec![
                    N::n("mm01")
                        .st(NodeStatus::Ok)
                        .m("round", "2")
                        .k(vec![N::n("mm05").st(NodeStatus::Ok).m("round", "3")]),
                    N::n("mm02").st(NodeStatus::InProgress).m("round", "2"),
                ]),
            N::n("hp02")
                .st(NodeStatus::Ok)
                .m("round", "1")
                .m("dur", "18ms")
                .k(vec![
                    N::n("hp03")
                        .st(NodeStatus::Failed)
                        .m("round", "2")
                        .m("err", "disk-full"),
                    N::n("contra").st(NodeStatus::Pending),
                ]),
        ]);

    println!("\n=== tree (color, no depth limit) ===\n");
    print!(
        "{}",
        render(
            &cascade,
            &OutputFormat::Tree {
                max_depth: None,
                color: true
            }
        )
    );

    println!("\n=== tree -L 2 (colorless) ===\n");
    print!(
        "{}",
        render(
            &cascade,
            &OutputFormat::Tree {
                max_depth: Some(2),
                color: false
            }
        )
    );

    println!("\n=== json ===\n");
    print!("{}", render(&cascade, &OutputFormat::Json));

    println!("\n\n=== yaml ===\n");
    print!("{}", render(&cascade, &OutputFormat::Yaml));

    println!("\n=== toml ===\n");
    print!("{}", render(&cascade, &OutputFormat::Toml));
}