kubie 0.28.0

A more powerful alternative to kubectx and kubens.
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

use std::env;
use std::fmt::Display;
use std::path::PathBuf;
use std::process::Command;

use anyhow::{anyhow, Context, Result};
use which::which;

use crate::cmd::{select_or_list_context, SelectResult};
use crate::kubeconfig;
use crate::settings::Settings;

struct EditorCommand {
    executable: PathBuf,
    args: Vec<String>,
}

impl Display for EditorCommand {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if self.args.is_empty() {
            return write!(f, "{}", self.executable.display());
        }
        write!(f, "{} {}", self.executable.display(), self.args.join(" "))
    }
}

fn parse_editor_command(raw: &str) -> Result<EditorCommand> {
    let mut parts = raw.split_whitespace();
    let executable = parts.next().context("executable is empty")?.into();
    let args: Vec<String> = parts.map(String::from).collect();
    Ok(EditorCommand { executable, args })
}

fn get_editor(settings: &Settings) -> Result<EditorCommand> {
    settings
        .default_editor
        .as_deref()
        .map(|editor| {
            parse_editor_command(editor)
                .with_context(|| format!("unable to parse default_editor command {}", editor))
        })
        .or_else(|| {
            env::var("EDITOR").ok().map(|editor| {
                parse_editor_command(&editor)
                    .with_context(|| format!("unable to parse EDITOR command {}", editor))
            })
        })
        .transpose()?
        .or_else(|| {
            ["nvim", "vim", "emacs", "vi", "nano"].iter().find_map(|editor| {
                which(editor).ok().map(|path| EditorCommand {
                    executable: path,
                    args: vec![],
                })
            })
        })
        .ok_or_else(|| anyhow!("Could not find any editor to use"))
}

pub fn edit_context(settings: &Settings, context_name: Option<String>) -> Result<()> {
    let mut installed = kubeconfig::get_installed_contexts(settings)?;
    installed.contexts.sort_by(|a, b| a.item.name.cmp(&b.item.name));

    let context_name = match context_name {
        Some(context_name) => context_name,
        None => match select_or_list_context(&settings.fzf, &mut installed)? {
            SelectResult::Selected(x) => x,
            _ => return Ok(()),
        },
    };

    let context_src = installed
        .find_context_by_name(&context_name)
        .ok_or_else(|| anyhow!("Could not find context {}", context_name))?;

    let command = get_editor(settings)?;

    let mut job = Command::new(&command.executable)
        .args(&command.args)
        .arg(context_src.source.as_ref())
        .spawn()
        .context(format!("Failed to spawn editor command '{}'", command))?;
    job.wait()?;

    Ok(())
}

pub fn edit_config(settings: &Settings) -> Result<()> {
    let command = get_editor(settings)?;
    let settings_path = Settings::path();

    let mut job = Command::new(&command.executable)
        .args(&command.args)
        .arg(settings_path)
        .spawn()
        .context(format!("Failed to spawn editor command '{}'", command))?;
    job.wait()?;

    Ok(())
}