forklaunch 1.16.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

use std::io::Write;

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

use crate::{
    CliCommand,
    core::command::command,
    managed::{
        client::{Missing, get_value, require_managed_mode, resolve_managed_auth},
        types::RelayConfig,
    },
};

/// Fetches the product's relay contract. Shared with `set` and `clear`, which print
/// the resulting routes the same way.
pub(super) fn fetch_relay_config(slug: &str) -> Result<RelayConfig> {
    let auth_mode = resolve_managed_auth()?;
    require_managed_mode(&auth_mode)?;
    let path = format!("/templates/{}/relay-config", urlencoding::encode(slug));
    let value = get_value(
        &auth_mode,
        &path,
        Missing::Resource(format!("template '{}'", slug)),
    )?;
    serde_json::from_value(value).context("Failed to parse the relay config")
}

pub(super) fn print_relay_config(slug: &str, config: &RelayConfig) -> Result<()> {
    let mut stdout = StandardStream::stdout(ColorChoice::Always);
    writeln!(stdout)?;
    stdout.set_color(ColorSpec::new().set_fg(Some(Color::Cyan)).set_bold(true))?;
    writeln!(stdout, "Relay for template '{}'", slug)?;
    stdout.reset()?;
    writeln!(stdout)?;
    if let Some(url) = &config.callback_url {
        writeln!(stdout, "  Register with the provider:  {}", url)?;
    }
    if let Some(state) = &config.state_format {
        writeln!(stdout, "  Instances mint state as:     {}", state)?;
    }
    writeln!(stdout)?;

    if config.routes.is_empty() {
        writeln!(
            stdout,
            "  No routes declared: the bare callback runs the legacy Epic exchange on the platform."
        )?;
        writeln!(
            stdout,
            "  Declare one with `forklaunch managed template relay set --slug {} --name default --component <service> --path </callback/path> --mode redirect`.",
            slug
        )?;
        writeln!(stdout)?;
        return Ok(());
    }

    stdout.set_color(ColorSpec::new().set_bold(true))?;
    writeln!(
        stdout,
        "  {:<16} {:<12} {:<24} {:<9} REGISTER THIS URL",
        "ROUTE", "COMPONENT", "PATH", "MODE"
    )?;
    stdout.reset()?;
    for route in &config.routes {
        writeln!(
            stdout,
            "  {:<16} {:<12} {:<24} {:<9} {}",
            route.name,
            route.component,
            route.path,
            route.mode,
            route.callback_url.as_deref().unwrap_or("-"),
        )?;
    }
    writeln!(stdout)?;
    Ok(())
}

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

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

impl CliCommand for ListCommand {
    fn command(&self) -> Command {
        command(
            "list",
            "Show the relay callback URL to register and the routes a template declares",
        )
        .arg(
            Arg::new("slug")
                .long("slug")
                .required(true)
                .help("Slug of the template"),
        )
        .arg(
            Arg::new("json")
                .long("json")
                .help("Output raw JSON instead of formatted terminal output")
                .action(ArgAction::SetTrue),
        )
    }

    fn handler(&self, matches: &ArgMatches) -> Result<()> {
        let slug = matches
            .get_one::<String>("slug")
            .context("--slug is required")?;
        let config = fetch_relay_config(slug)?;
        if matches.get_flag("json") {
            println!("{}", serde_json::to_string_pretty(&config)?);
            return Ok(());
        }
        print_relay_config(slug, &config)
    }
}