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
122
123
124
125
126
127
128
129
130
131

use std::io::Write;

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

use crate::{
    CliCommand,
    core::command::command,
    managed::{
        client::{Missing, delete_text, print_dryrun, require_managed_mode, resolve_managed_auth},
        template::vars::resolve_scope,
        types::VARIABLE_SCOPES,
    },
};

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

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

impl CliCommand for UnsetCommand {
    fn command(&self) -> Command {
        command("unset", "Remove a variable declaration from a template")
            .long_about(
                "Remove a variable declaration from a template.\n\n\
                 New instances stop receiving the variable. Instances already deployed keep\n\
                 whatever they were given until their next provision.\n\n\
                 --scope and --service identify WHICH declaration to remove, not just which\n\
                 key: the same key can be declared once application-wide and again for a\n\
                 single service, and those are different declarations. Both default to the\n\
                 application-scoped one.\n\n\
                 To clear one instance's value while leaving the declaration in place, use\n\
                 `forklaunch managed instance vars unset` instead.",
            )
            .arg(
                Arg::new("slug")
                    .long("slug")
                    .required(true)
                    .help("Slug of the template to remove the declaration from"),
            )
            .arg(
                Arg::new("key")
                    .long("key")
                    .required(true)
                    .help("Name of the variable to remove"),
            )
            .arg(
                Arg::new("scope")
                    .long("scope")
                    .value_parser(VARIABLE_SCOPES.to_vec())
                    .default_value("application")
                    .help("Which scope's declaration to remove"),
            )
            .arg(
                Arg::new("service").long("service").help(
                    "Which service's declaration to remove — required with `--scope service`",
                ),
            )
            .arg(
                Arg::new("dryrun")
                    .long("dryrun")
                    .help("Print the request that would be sent without sending it")
                    .action(ArgAction::SetTrue),
            )
    }

    fn handler(&self, matches: &ArgMatches) -> Result<()> {
        let mut stdout = StandardStream::stdout(ColorChoice::Always);

        let slug = matches
            .get_one::<String>("slug")
            .context("--slug is required")?;
        let key = matches
            .get_one::<String>("key")
            .context("--key is required")?;
        let scope = matches
            .get_one::<String>("scope")
            .map(String::as_str)
            .unwrap_or("application");
        let service = resolve_scope(
            scope,
            matches.get_one::<String>("service").map(String::as_str),
        )?;

        // Both the key and the scope go into the request — the key in the path, the
        // scope in the query — because a key alone does not identify a declaration.
        let mut path = format!(
            "/templates/{}/variables/{}?scope={}",
            urlencoding::encode(slug),
            urlencoding::encode(key),
            urlencoding::encode(scope)
        );
        if let Some(service) = service {
            path.push_str(&format!("&serviceName={}", urlencoding::encode(service)));
        }

        if matches.get_flag("dryrun") {
            return print_dryrun("DELETE", &path, None);
        }

        let auth_mode = resolve_managed_auth()?;
        require_managed_mode(&auth_mode)?;

        delete_text(
            &path,
            Missing::Resource(format!(
                "variable '{}' ({} scope) on template '{}'",
                key, scope, slug
            )),
        )?;

        log_ok!(
            stdout,
            "Removed the {}-scoped declaration of '{}' from template '{}'",
            scope,
            key,
            slug
        );
        log_info!(
            stdout,
            "New instances no longer receive it. Instances already deployed keep it until their next provision."
        );

        Ok(())
    }
}