ferrodock 1.9.0

A fast, native container manager for Docker, written in Rust.
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

//! The Inspect view: environment, labels, restart policy and health, then
//! the raw `docker inspect` JSON.

use eframe::egui::{self, RichText};

use super::details;
use crate::app::store::Store;
use crate::docker::{Inspection, looks_secret};
use crate::theme::Palette;

/// Whether the inspect output of `id` still has to be asked for.
pub fn needs_loading(store: &Store, id: &str) -> bool {
    store.inspecting.as_deref() != Some(id)
}

/// Draws the inspect output of `id` from the store, or a spinner while
/// it loads.
pub fn show(ui: &mut egui::Ui, p: &Palette, store: &Store, id: &str) {
    let result = store
        .inspection
        .as_ref()
        .filter(|_| store.inspecting.as_deref() == Some(id));
    match result {
        None => {
            ui.add_space(20.0);
            ui.vertical_centered(|ui| ui.spinner());
        }
        Some(Err(message)) => {
            ui.label(RichText::new(message).color(p.danger));
        }
        Some(Ok(inspection)) => sections(ui, p, inspection),
    }
}

fn sections(ui: &mut egui::Ui, p: &Palette, i: &Inspection) {
    if i.restart_policy.is_some() || i.health.is_some() {
        details::section(ui, p, "Runtime", |ui| {
            if let Some(policy) = &i.restart_policy {
                details::field(ui, p, "Restart", policy);
            }
            if let Some(health) = &i.health {
                let color = match health.status.as_str() {
                    "healthy" => p.success,
                    "unhealthy" => p.danger,
                    _ => p.warning,
                };
                ui.label(RichText::new("Health").color(p.muted));
                ui.label(RichText::new(&health.status).color(color));
                ui.end_row();
                if health.failing_streak > 0 {
                    details::field(
                        ui,
                        p,
                        "Failing",
                        &format!("{} checks in a row", health.failing_streak),
                    );
                }
                if !health.last_output.is_empty() {
                    details::field(ui, p, "Last check", &health.last_output);
                }
            }
        });
    }

    if !i.env.is_empty() {
        let reveal_id = ui.scope_id().with(("reveal-env", &i.id));
        let mut reveal = ui.data(|d| d.get_temp::<bool>(reveal_id).unwrap_or(false));
        ui.horizontal(|ui| {
            ui.label(RichText::new("ENVIRONMENT").size(11.0).color(p.muted));
            if i.env.iter().any(|(k, _)| looks_secret(k)) {
                ui.checkbox(&mut reveal, RichText::new("Show secrets").size(12.0));
            }
        });
        ui.data_mut(|d| d.insert_temp(reveal_id, reveal));
        key_values(ui, p, "env", &i.env, |key| !reveal && looks_secret(key));
    }

    if !i.labels.is_empty() {
        ui.label(RichText::new("LABELS").size(11.0).color(p.muted));
        key_values(ui, p, "labels", &i.labels, |_| false);
    }

    egui::CollapsingHeader::new(RichText::new("Raw JSON").color(p.muted))
        .id_salt(("inspect-json", &i.id))
        .show(ui, |ui| {
            if ui.small_button("Copy JSON").clicked() {
                ui.ctx().copy_text(i.json.clone());
            }
            ui.add(
                egui::Label::new(RichText::new(&i.json).monospace().size(11.5).color(p.text))
                    .wrap_mode(egui::TextWrapMode::Extend),
            );
        });
}

/// A card of `key  value` rows. Values for which `hide` says so show as
/// dots. Clicking a row copies `KEY=value`.
fn key_values(
    ui: &mut egui::Ui,
    p: &Palette,
    salt: &str,
    rows: &[(String, String)],
    hide: impl Fn(&str) -> bool,
) {
    egui::Frame::new()
        .fill(p.bg)
        .stroke(egui::Stroke::new(1.0, p.border))
        .corner_radius(egui::CornerRadius::same(8))
        .inner_margin(egui::Margin::same(10))
        .show(ui, |ui| {
            ui.set_width(ui.available_width());
            egui::Grid::new(salt)
                .num_columns(2)
                .spacing([12.0, 4.0])
                .show(ui, |ui| {
                    for (key, value) in rows {
                        ui.label(RichText::new(key).monospace().size(12.0).color(p.muted));
                        let shown = if hide(key) {
                            "••••••••"
                        } else {
                            value.as_str()
                        };
                        let response = ui
                            .add(
                                egui::Label::new(
                                    RichText::new(shown).monospace().size(12.0).color(p.text),
                                )
                                .truncate()
                                .sense(egui::Sense::click()),
                            )
                            .on_hover_text("Click to copy");
                        if response.clicked() {
                            ui.ctx().copy_text(format!("{key}={value}"));
                        }
                        ui.end_row();
                    }
                });
        });
    ui.add_space(14.0);
}