kx 1.3.0

Interactively switch between kubernetes contexts without any external dependencies
Documentation 
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

use clap::Parser;
use kx::Config;
use skim::prelude::*;
use std::fs;
use std::io::Cursor;
use std::path::PathBuf;
use std::process;

#[derive(Parser, Debug)]
#[command(version, about, long_about = None)]
struct Args {
    /// Switches to context <NAME>
    #[arg()]
    name: Option<String>,
    /// Shows the current context
    #[arg(short = 'c', long = "current")]
    current: bool,
    /// Unsets the current context
    #[arg(short = 'u', long = "unset")]
    unset: bool,
}

fn main() {
    let args = Args::parse();

    let home_dir = dirs::home_dir().unwrap_or_else(|| {
        eprintln!("error: cannot find HOME directory");
        process::exit(1);
    });

    let config_path = &home_dir.join(".kube").join("config");

    let contents = &fs::read_to_string(config_path).unwrap_or_else(|_| {
        eprintln!("error: cannot read kube config");
        process::exit(1);
    });

    let contents = contents.lines().collect::<Vec<&str>>();

    let config = &mut Config::load(contents);

    if args.current {
        let current_context = config.get_current_context().unwrap_or_else(|err| {
            eprintln!("error: {}", err);
            process::exit(1);
        });

        println!("{}", current_context);
        return;
    }

    if args.unset {
        unset_current_context(config_path, config);

        println!("current-context unset");
        return;
    }

    if let Some(selected_context) = args.name {
        match config.check_context(&selected_context) {
            Ok(res) => {
                if !res {
                    eprintln!(
                        "error: no context exists with the name: \"{}\"",
                        selected_context
                    );
                    process::exit(1);
                }
            }
            Err(e) => {
                eprintln!("error: {}", e);
                process::exit(1);
            }
        };

        let new_context = format!("current-context: {}", &selected_context);
        set_current_context(config_path, config, &new_context);

        println!("Switched to context \"{}\"", selected_context);

        return;
    }

    let contexts = config.list_contexts().unwrap_or_else(|e| {
        eprintln!("error: {}", e);
        process::exit(1);
    });

    let options = SkimOptionsBuilder::default()
        .height(Some("100%"))
        .multi(true)
        .build()
        .unwrap_or_else(|e| {
            eprintln!("error: cannot show contexts");
            eprintln!("{e}");
            process::exit(1);
        });

    let item_reader = SkimItemReader::default();
    let items = item_reader.of_bufread(Cursor::new(contexts));

    let output = Skim::run_with(&options, Some(items)).unwrap();

    if output.is_abort {
        println!("context is not changed");
        process::exit(0);
    }

    let selected_context = output
        .selected_items
        .first()
        .unwrap_or_else(|| {
            eprintln!("error: cannot pick context");
            process::exit(1);
        })
        .output();

    let new_context = format!("current-context: {}", &selected_context);
    set_current_context(config_path, config, &new_context);

    println!("Switched to context \"{}\"", selected_context);
}

fn set_current_context<'a>(config_path: &'a PathBuf, config: &'a Config<'a>, new_context: &'a str) {
    config.set_current_context(new_context).unwrap_or_else(|_| {
        eprintln!("error: cannot set current-context");
        process::exit(1);
    });

    fs::write(config_path, config.get_config()).unwrap_or_else(|_| {
        eprintln!("error: cannot save kube config");
        process::exit(1);
    });
}

fn unset_current_context<'a>(config_path: &'a PathBuf, config: &'a Config<'a>) {
    config.unset_current_context().unwrap_or_else(|_| {
        eprintln!("error: cannot unset current-context");
        process::exit(1);
    });

    fs::write(config_path, config.get_config()).unwrap_or_else(|_| {
        eprintln!("error: cannot save kube config");
        process::exit(1);
    });
}