nethermit 0.1.4

A CLI tool to convert Jsonnet to YAML
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

use anyhow::{Context, Result};
use clap::{Parser, Subcommand};
use std::{
    fs,
    io::{self, Read},
    path::{Path, PathBuf},
};
use tabled::Table;

#[derive(Parser)]
#[command(author, version, about)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Install resources from a Jsonnet file
    Install {
        /// The Jsonnet file to process
        file: Option<PathBuf>,

        /// Name of the set to install
        #[arg(long, required = true)]
        set: String,
    },

    /// List installed sets
    List,

    /// Delete a set and all its resources
    Delete {
        /// Name of the set to delete
        name: String,
    },
}

fn process_jsonnet_file(path: &PathBuf) -> Result<String> {
    let content = fs::read_to_string(path)
        .with_context(|| format!("Failed to read file: {}", path.display()))?;

    // Add the parent directory of the input file to the import paths
    let import_paths = if let Some(parent) = path.parent() {
        vec![parent.to_path_buf()]
    } else {
        vec![]
    };

    nethermit::jsonnet_to_yaml(&content, &import_paths)
}

fn process_stdin() -> Result<String> {
    let mut buffer = String::new();
    io::stdin()
        .read_to_string(&mut buffer)
        .context("Failed to read from stdin")?;

    // When reading from stdin, use current directory for imports
    let import_paths = vec![PathBuf::from(".")];
    nethermit::jsonnet_to_yaml(&buffer, &import_paths)
}

#[tokio::main]
async fn main() -> Result<()> {
    let cli = Cli::parse();
    let client = nethermit::RealKubeClient::new().await?;

    match cli.command {
        Commands::Install { file, set } => {
            // Check if set already exists
            if nethermit::set_exists(&client, &set).await? {
                return Err(anyhow::anyhow!(
                    "{}",
                    nethermit::format_error(&format!("Set '{}' already exists", set))
                ));
            }

            // Process input
            let yaml = match file {
                Some(ref path) if path == Path::new("-") => process_stdin()?,
                Some(ref path) => process_jsonnet_file(path)?,
                None => process_stdin()?,
            };

            println!(
                "{}",
                nethermit::format_info("Generated YAML configuration:")
            );
            println!("{yaml}");

            println!(
                "{}",
                nethermit::format_info("Applying configuration to Kubernetes cluster...")
            );
            let pb = nethermit::create_spinner("Installing resources");
            nethermit::apply_kubernetes(&yaml, Some(&set)).await?;
            pb.finish_with_message(nethermit::format_success(&format!(
                "Successfully installed set '{}'",
                set
            )));
        }

        Commands::List => {
            let sets = nethermit::list_sets_info(&client).await?;
            if sets.is_empty() {
                println!("{}", nethermit::format_info("No sets installed"));
            } else {
                println!("{}", nethermit::format_info("Installed sets:"));
                let table = Table::new(sets).to_string();
                println!("{table}");
            }
        }

        Commands::Delete { name } => {
            let pb = nethermit::create_spinner(&format!("Deleting resources for set '{}'", name));
            match nethermit::delete_set_resources(&client, &name).await {
                Ok(_) => {
                    pb.finish_with_message(nethermit::format_success(&format!(
                        "Successfully deleted set '{}'",
                        name
                    )));
                }
                Err(e) => {
                    pb.finish_with_message(nethermit::format_error(&format!(
                        "Failed to delete set '{}': {}",
                        name, e
                    )));
                    return Err(e);
                }
            }
        }
    }

    Ok(())
}