cellos-ctl 0.5.2

cellctl — kubectl-style CLI for CellOS execution cells and formations. Thin HTTP client over cellos-server with apply/get/describe/logs/events/webui.
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

//! `cellctl describe formation|cell <name>` — verbose human-readable detail.

use owo_colors::OwoColorize;

use crate::client::{formation_path, CellosClient};
use crate::exit::CtlResult;
use crate::model::{Cell, Formation};

pub async fn formation(client: &CellosClient, name: &str) -> CtlResult<()> {
    // CTL-002: route to `/v1/formations/{uuid}` or
    // `/v1/formations/by-name/{name}` depending on whether the operator
    // supplied a UUID or a kubectl-style name.
    let f: Formation = client.get_json(&formation_path(name)).await?;
    print_formation(&f);
    Ok(())
}

pub async fn cell(client: &CellosClient, name: &str) -> CtlResult<()> {
    let c: Cell = client
        .get_json(&format!("/v1/cells/{}", urlencode(name)))
        .await?;
    print_cell(&c);
    Ok(())
}

fn print_formation(f: &Formation) {
    let title = format!("Formation: {}", display_name(&f.name, &f.id));
    println!("{}", title.bold());
    field("ID", &f.id);
    field("State", &f.state);
    field("Tenant", f.tenant.as_deref().unwrap_or("-"));
    field("Created", f.created_at.as_deref().unwrap_or("-"));
    field("Updated", f.updated_at.as_deref().unwrap_or("-"));
    println!();
    println!("{}", "Cells:".bold());
    if f.cells.is_empty() {
        println!("  (none reported)");
    } else {
        for c in &f.cells {
            println!(
                "  - {} [{}] critical={}",
                display_name(&c.name, &c.id),
                c.state,
                c.critical
                    .map(|b| if b { "true" } else { "false" })
                    .unwrap_or("-"),
            );
        }
    }
    if !f.extra.is_empty() {
        println!();
        println!("{}", "Extra:".bold());
        println!(
            "  {}",
            serde_json::to_string_pretty(&f.extra).unwrap_or_default()
        );
    }
}

fn print_cell(c: &Cell) {
    let title = format!("Cell: {}", display_name(&c.name, &c.id));
    println!("{}", title.bold());
    field("ID", &c.id);
    field("State", &c.state);
    field("Formation", c.formation_id.as_deref().unwrap_or("-"));
    field("Image", c.image.as_deref().unwrap_or("-"));
    field(
        "Critical",
        c.critical
            .map(|b| if b { "true" } else { "false" })
            .unwrap_or("-"),
    );
    field("Created", c.created_at.as_deref().unwrap_or("-"));
    field("Started", c.started_at.as_deref().unwrap_or("-"));
    field("Finished", c.finished_at.as_deref().unwrap_or("-"));
    field("Outcome", c.outcome.as_deref().unwrap_or("-"));
    if !c.extra.is_empty() {
        println!();
        println!("{}", "Extra:".bold());
        println!(
            "  {}",
            serde_json::to_string_pretty(&c.extra).unwrap_or_default()
        );
    }
}

fn field(label: &str, value: &str) {
    println!("  {:<10} {}", format!("{}:", label), value);
}

fn display_name(name: &str, id: &str) -> String {
    if !name.is_empty() {
        name.to_string()
    } else {
        id.to_string()
    }
}

fn urlencode(s: &str) -> String {
    url::form_urlencoded::byte_serialize(s.as_bytes()).collect()
}