sherpack 0.4.0

The Kubernetes package manager with Jinja2 templates
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

//! Install command - deploy a pack to Kubernetes

use console::style;
use miette::IntoDiagnostic;
use sherpack_core::{LoadedPack, Values, parse_set_values};
use sherpack_kube::{
    InstallOptions, KubeClient,
    storage::{FileDriver, StorageConfig},
};
use std::path::Path;

use crate::error::Result;

/// Run the install command
#[allow(clippy::too_many_arguments)]
pub async fn run(
    name: &str,
    pack_path: &Path,
    values_files: &[std::path::PathBuf],
    set_values: &[String],
    namespace: &str,
    wait: bool,
    timeout: Option<u64>,
    atomic: bool,
    create_namespace: bool,
    dry_run: bool,
    show_diff: bool,
    skip_crds: bool,
) -> Result<()> {
    // Load the pack
    let pack = LoadedPack::load(pack_path).into_diagnostic()?;
    println!(
        "{} Installing pack {} version {}",
        style("→").blue().bold(),
        style(&pack.pack.metadata.name).cyan(),
        style(&pack.pack.metadata.version).yellow()
    );

    // Check for CRDs
    if pack.has_crds() {
        let crd_files = pack.crd_files().into_diagnostic()?;
        if skip_crds {
            println!(
                "{} Skipping {} CRD file(s) (--skip-crds)",
                style("⚠").yellow(),
                crd_files.len()
            );
        } else {
            println!(
                "{} Found {} CRD file(s) in crds/ directory",
                style("→").blue(),
                crd_files.len()
            );
        }
    }

    // Load and merge values
    let mut values = Values::from_file(&pack.values_path).into_diagnostic()?;

    // Apply schema defaults if available
    if let Some(schema) = pack.load_schema().into_diagnostic()? {
        let defaults = Values(schema.extract_defaults());
        values = Values::with_schema_defaults(defaults, values);
    }

    // Merge additional values files
    for vf in values_files {
        let overlay = Values::from_file(vf).into_diagnostic()?;
        values.merge(&overlay);
    }

    // Apply --set values
    if !set_values.is_empty() {
        let set_values_map = parse_set_values(set_values).into_diagnostic()?;
        values.merge(&set_values_map);
    }

    // Create storage driver (file-based for now, since we might not have a cluster)
    let storage_path = dirs::data_dir()
        .unwrap_or_else(|| std::path::PathBuf::from("."))
        .join("sherpack")
        .join("releases");

    let storage = FileDriver::new(storage_path, StorageConfig::default()).into_diagnostic()?;

    // Create client
    let client = KubeClient::new(storage).await.into_diagnostic()?;

    // Build install options
    let mut options = InstallOptions::new(name, namespace);
    options.wait = wait;
    options.atomic = atomic;
    options.create_namespace = create_namespace;
    options.dry_run = dry_run;
    options.show_diff = show_diff;

    if let Some(t) = timeout {
        options.timeout = Some(chrono::Duration::seconds(t as i64));
    }

    // Execute install
    let release = client
        .install(&pack, values, &options)
        .await
        .into_diagnostic()?;

    if dry_run {
        println!(
            "{} Dry run - would install {} in namespace {}",
            style("✓").green().bold(),
            style(name).cyan(),
            style(namespace).yellow()
        );
    } else {
        println!(
            "{} Successfully installed {} (revision {}) in namespace {}",
            style("✓").green().bold(),
            style(&release.name).cyan(),
            style(release.version).yellow(),
            style(&release.namespace).yellow()
        );
    }

    // Show notes if present
    if let Some(notes) = &release.notes {
        println!("\n{}", style("NOTES:").bold());
        println!("{}", notes);
    }

    Ok(())
}