mgt 0.2.1

Command line tool to analyze the WildFly management model.
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257

//! Terminal progress bars, step headers, and status reporting.

use console::{Emoji, style, truncate_str};
use indicatif::{HumanDuration, MultiProgress, ProgressBar, ProgressStyle};
use std::process::Output;
use std::time::Duration;
use tokio::io::{AsyncBufReadExt, BufReader, Lines};
use tokio::process::ChildStderr;
use tokio::time::Instant;

/// Column width for left-aligning progress bar names.
const NAME_WIDTH: usize = 30;

static COG: Emoji<'_, '_> = Emoji("\u{2699}\u{fe0f}  ", ""); // step 1: prepare
static MAG: Emoji<'_, '_> = Emoji("\u{1f50d}  ", ""); // step 2: analyze
static PACKAGE: Emoji<'_, '_> = Emoji("\u{1f4e6}  ", ""); // step 3: build
static BROOM: Emoji<'_, '_> = Emoji("\u{1f9f9}  ", ""); // step 4: cleanup
static SPARKLE: Emoji<'_, '_> = Emoji("\u{2728}  ", ":-)  "); // done

/// Prints a numbered step header with an emoji prefix (e.g. `[1/4] wrench Preparing...`).
pub fn step_header(step: u32, total: u32, description: &str) {
    let emoji = match step {
        1 => COG,
        2 => MAG,
        3 => PACKAGE,
        4 => BROOM,
        _ => COG,
    };
    println!(
        "{} {}{}",
        style(format!("[{}/{}]", step, total)).bold().dim(),
        emoji,
        description
    );
}

/// Prints elapsed time since `instant` as a "Done in ..." message.
pub fn done(instant: Instant) {
    println!(
        "\n{}Done in {}",
        SPARKLE,
        style(HumanDuration(instant.elapsed())).cyan()
    );
}

// ------------------------------------------------------ analysis status

/// Captures the outcome of a container operation for summary reporting.
#[derive(Clone)]
pub struct CommandStatus {
    pub identifier: String,
    pub success: bool,
    pub error_message: String,
}

impl CommandStatus {
    /// Creates a successful status.
    pub fn success(identifier: &str) -> Self {
        CommandStatus {
            identifier: identifier.to_string(),
            success: true,
            error_message: String::new(),
        }
    }

    /// Creates a failed status with an error message.
    pub fn error(identifier: &str, error_message: &str) -> Self {
        CommandStatus {
            identifier: identifier.to_string(),
            success: false,
            error_message: error_message.to_string(),
        }
    }

    /// Creates a status from a `Result`, mapping `Err` to an error status.
    pub fn from_result<T>(identifier: &str, result: &anyhow::Result<T>) -> Self {
        match result {
            Ok(_) => Self::success(identifier),
            Err(e) => Self::error(identifier, &e.to_string()),
        }
    }
}

/// Prints a summary of failed operations, if any.
pub fn summary(count: usize, status: &[CommandStatus]) {
    let failed: Vec<_> = status.iter().filter(|s| !s.success).collect();
    if !failed.is_empty() {
        println!();
        for s in &failed {
            println!(
                "  {} {} {}",
                style("\u{2717}").red().bold(),
                style(&s.identifier).cyan(),
                style(&s.error_message).red()
            );
        }
        println!(
            "\n  {} of {} resource(s) failed",
            style(failed.len()).red().bold(),
            style(count).cyan()
        );
    }
}

// ------------------------------------------------------ progress

/// A named spinner progress bar for tracking long-running operations.
#[derive(Clone)]
pub struct Progress {
    name: String,
    bar: ProgressBar,
}

impl Progress {
    /// Creates a progress bar and adds it to a `MultiProgress` group.
    pub fn join(multi_progress: &MultiProgress, name: &str) -> Progress {
        let progress = Progress {
            name: name.to_string(),
            bar: Self::spinner(),
        };
        progress.bar.enable_steady_tick(Duration::from_millis(100));
        multi_progress.add(progress.bar.clone());
        progress.bar.set_message(style(name).cyan().to_string());
        progress
    }

    /// Creates a hidden progress bar that produces no terminal output.
    pub fn hidden(name: &str) -> Progress {
        Progress {
            name: name.to_string(),
            bar: ProgressBar::hidden(),
        }
    }

    /// Creates a standalone progress bar.
    pub fn new(name: &str) -> Progress {
        let progress = Progress {
            name: name.to_string(),
            bar: Self::spinner(),
        };
        progress.bar.enable_steady_tick(Duration::from_millis(100));
        progress.bar.set_message(style(name).cyan().to_string());
        progress
    }

    /// Creates a braille-style spinner progress bar.
    fn spinner() -> ProgressBar {
        ProgressBar::new_spinner().with_style(
            ProgressStyle::default_spinner()
                .tick_strings(&[
                    "\u{280b}", "\u{2819}", "\u{2839}", "\u{2838}", "\u{283c}", "\u{2834}",
                    "\u{2826}", "\u{2827}", "\u{2807}", "\u{280f}", " ",
                ])
                .template("  {spinner:.dim.bold} {wide_msg}")
                .expect("Invalid spinner template"),
        )
    }

    /// Returns the style used when a spinner has finished (no tick animation).
    fn finished_style() -> ProgressStyle {
        ProgressStyle::default_spinner()
            .template("  {wide_msg}")
            .expect("Invalid template")
    }

    /// Reads lines from an async reader and updates the spinner message with each line.
    pub async fn trace_progress<R>(&self, mut reader: Lines<BufReader<R>>)
    where
        R: tokio::io::AsyncRead + Unpin,
    {
        while let Some(line) = reader
            .next_line()
            .await
            .expect("Unable to read output from command.")
        {
            self.show_progress(line.as_str());
        }
    }

    /// Finishes the spinner based on the command output, returning a [`CommandStatus`].
    pub fn finish_output(
        &self,
        output: std::io::Result<Output>,
        status: Option<&str>,
    ) -> CommandStatus {
        match output {
            Ok(output) => {
                if output.status.success() {
                    self.finish_success(status);
                    CommandStatus::success(&self.name)
                } else {
                    let msg = String::from_utf8_lossy(&output.stderr).replace('\n', " ");
                    self.finish_error(&msg);
                    CommandStatus::error(&self.name, &msg)
                }
            }
            Err(e) => {
                let msg = e.to_string();
                self.finish_error(&msg);
                CommandStatus::error(&self.name, &msg)
            }
        }
    }

    /// Updates the spinner message with the current operation status.
    pub fn show_progress(&self, text: &str) {
        let padded = format!("{:<width$}", self.name, width = NAME_WIDTH);
        self.bar.set_message(format!(
            "{} {}",
            style(padded).cyan(),
            style(truncate_str(text, 80, "...")).dim()
        ));
    }

    /// Finishes the spinner with a green checkmark and optional status text.
    pub fn finish_success(&self, status: Option<&str>) {
        self.bar.set_style(Self::finished_style());
        let padded = format!("{:<width$}", self.name, width = NAME_WIDTH);
        let msg = match status {
            Some(s) => format!(
                "{} {} {}",
                style("\u{2713}").green().bold(),
                style(padded).cyan(),
                style(s).dim()
            ),
            None => format!(
                "{} {}",
                style("\u{2713}").green().bold(),
                style(padded).cyan()
            ),
        };
        self.bar.finish_with_message(msg);
    }

    /// Abandons the spinner with a red cross and error message.
    pub fn finish_error(&self, err: &str) {
        self.bar.set_style(Self::finished_style());
        let padded = format!("{:<width$}", self.name, width = NAME_WIDTH);
        self.bar.abandon_with_message(format!(
            "{} {} {}",
            style("\u{2717}").red().bold(),
            style(padded).cyan(),
            style(err).red()
        ));
    }
}

// ------------------------------------------------------ stderr

/// Takes stderr from a child process and returns a line-buffered async reader.
pub fn stderr_reader(child: &mut tokio::process::Child) -> Lines<BufReader<ChildStderr>> {
    let stderr = child
        .stderr
        .take()
        .expect("Command did not have a handle to stderr.");
    BufReader::new(stderr).lines()
}