forklaunch 1.18.0

Launch faster with forklaunch
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

use std::io::Write;

use anyhow::Result;
use clap::{Arg, ArgAction, ArgMatches, Command};
use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};

use crate::{
    CliCommand,
    core::command::command,
    managed::{
        client::{
            Missing, extract_list, get_value, print_dryrun, require_managed_mode,
            resolve_managed_auth,
        },
        types::{FleetRollout, dash},
    },
};

#[derive(Debug)]
pub(super) struct ListCommand;

impl ListCommand {
    pub(super) fn new() -> Self {
        Self
    }
}

impl CliCommand for ListCommand {
    fn command(&self) -> Command {
        command("list", "List fleet rollouts, newest first")
            .arg(
                Arg::new("template")
                    .long("template")
                    .help("Only rollouts of this template"),
            )
            .arg(
                Arg::new("dryrun")
                    .long("dryrun")
                    .help("Print the request that would be sent without sending it")
                    .action(ArgAction::SetTrue),
            )
            .arg(
                Arg::new("json")
                    .long("json")
                    .help("Output raw JSON instead of formatted terminal output")
                    .action(ArgAction::SetTrue),
            )
    }

    fn handler(&self, matches: &ArgMatches) -> Result<()> {
        if matches.get_flag("dryrun") {
            return print_dryrun("GET", "/rollouts", None);
        }
        let auth_mode = resolve_managed_auth()?;
        require_managed_mode(&auth_mode)?;

        let value = get_value(&auth_mode, "/rollouts", Missing::Endpoint)?;
        let template_filter = matches.get_one::<String>("template");
        let rollouts: Vec<FleetRollout> = extract_list::<FleetRollout>(value, &["rollouts"])?
            .into_iter()
            .filter(|rollout| match (template_filter, &rollout.template_slug) {
                (Some(wanted), Some(actual)) => actual == wanted,
                (Some(_), None) => false,
                (None, _) => true,
            })
            .collect();

        if matches.get_flag("json") {
            println!("{}", serde_json::to_string_pretty(&rollouts)?);
            return Ok(());
        }

        let mut stdout = StandardStream::stdout(ColorChoice::Always);
        writeln!(stdout)?;
        stdout.set_color(ColorSpec::new().set_fg(Some(Color::Cyan)).set_bold(true))?;
        writeln!(stdout, "Fleet rollouts")?;
        stdout.reset()?;
        writeln!(stdout)?;
        if rollouts.is_empty() {
            writeln!(
                stdout,
                "  No rollouts yet. Start one with `forklaunch managed rollout start`."
            )?;
            writeln!(stdout)?;
            return Ok(());
        }
        stdout.set_color(ColorSpec::new().set_bold(true))?;
        writeln!(
            stdout,
            "  {:<38} {:<18} {:<10} {:<12} {:<8} {}",
            "ID", "TEMPLATE", "TARGET", "STATE", "WAVE", "ITEMS"
        )?;
        stdout.reset()?;
        for rollout in &rollouts {
            let mut counts = std::collections::BTreeMap::new();
            for item in &rollout.items {
                *counts
                    .entry(item.state.as_deref().unwrap_or("-"))
                    .or_insert(0u32) += 1;
            }
            let items: Vec<String> = counts.iter().map(|(k, v)| format!("{} {}", v, k)).collect();
            writeln!(
                stdout,
                "  {:<38} {:<18} {:<10} {:<12} {:<8} {}",
                dash(&rollout.id),
                dash(&rollout.template_slug),
                dash(&rollout.target_version_semver),
                dash(&rollout.state),
                format!(
                    "{}/{}",
                    rollout
                        .current_wave
                        .map(|w| (w + 1).min(rollout.wave_percents.len() as u64))
                        .unwrap_or(0),
                    rollout.wave_percents.len()
                ),
                items.join(", ")
            )?;
        }
        writeln!(stdout)?;
        Ok(())
    }
}