k8s-netinspect 0.1.0

A minimal Kubernetes network inspection tool for diagnosing CNI and pod connectivity
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

use clap::{Parser, Subcommand};
use std::process;

mod commands;
mod errors;
mod validation;

use errors::NetInspectError;
use validation::Validator;

#[derive(Parser)]
#[command(name = "k8s-netinspect")]
#[command(about = "A minimal Kubernetes network inspection tool")]
#[command(version = "0.1.0")]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Diagnose CNI and basic network configuration
    Diagnose {
        /// Target namespace for pod diagnostics (default: cluster-wide)
        #[arg(short, long)]
        namespace: Option<String>,
    },
    /// Test pod connectivity
    TestPod {
        /// Pod name to test
        #[arg(short, long)]
        pod: String,
        /// Namespace (default: default)
        #[arg(short, long, default_value = "default")]
        namespace: String,
    },
    /// Show version information
    Version,
}

#[tokio::main]
async fn main() {
    let cli = Cli::parse();
    
    // Validate environment before executing commands
    if let Err(e) = Validator::validate_environment() {
        eprintln!("{}", e.detailed_message());
        process::exit(e.exit_code());
    }
    
    let result = match &cli.command {
        Commands::Diagnose { namespace } => {
            if let Err(e) = Validator::validate_kubernetes_access().await {
                Err(e)
            } else {
                // Validate namespace if provided
                if let Some(ns) = namespace {
                    if let Err(e) = Validator::validate_namespace(ns) {
                        Err(e)
                    } else if let Err(e) = Validator::validate_namespace_exists(ns).await {
                        Err(e)
                    } else {
                        commands::diagnose(namespace.as_deref()).await
                    }
                } else {
                    commands::diagnose(None).await
                }
            }
        },
        Commands::TestPod { pod, namespace } => {
            // Validate inputs
            if let Err(e) = Validator::validate_pod_name(pod) {
                Err(e)
            } else if let Err(e) = Validator::validate_namespace(namespace) {
                Err(e)
            } else if let Err(e) = Validator::validate_kubernetes_access().await {
                Err(e)
            } else {
                commands::test_pod(pod, namespace).await
            }
        },
        Commands::Version => {
            commands::version();
            Ok(())
        }
    };
    
    match result {
        Ok(()) => process::exit(0),
        Err(e) => {
            eprintln!("{}", e.detailed_message());
            process::exit(e.exit_code());
        }
    }
}