Merge pull request #4 from nginxinc/helm-client

Feat: add Cobra parameters and create supportpkg tarball

Author: dareste

cmd/kic-supportpkg.go

@@ -0,0 +1,52 @@
+package cmd
+
+import (
+	"fmt"
+	"github.com/nginxinc/kubectl-kic-supportpkg/pkg/data_collector"
+	"github.com/nginxinc/kubectl-kic-supportpkg/pkg/jobs"
+	"github.com/spf13/cobra"
+	"os"
+)
+
+func Execute() {
+
+	var namespaces []string
+
+	var rootCmd = &cobra.Command{
+		Use:   "kic-supportpkg",
+		Short: "kic-supportpkg - a tool to create Ingress Controller diagnostics package",
+		Long:  `kic-supportpkg - a tool to create Ingress Controller diagnostics package`,
+		Run: func(cmd *cobra.Command, args []string) {
+
+			collector, err := data_collector.NewDataCollector(namespaces...)
+			if err != nil {
+				fmt.Println(fmt.Errorf("unable to start data collector: %s", err))
+				os.Exit(1)
+			}
+
+			for _, job := range jobs.JobList() {
+				fmt.Printf("Running job %s...", job.Name)
+				err = job.Collect(collector)
+				if err != nil {
+					fmt.Printf("Error: %s", err)
+				} else {
+					fmt.Print(" OK\n")
+				}
+			}
+
+			err = collector.WrapUp()
+			if err != nil {
+				fmt.Println(fmt.Errorf("error when wrapping up: %s", err))
+				os.Exit(1)
+			}
+		},
+	}
+
+	rootCmd.Flags().StringSliceVarP(&namespaces, "namespace", "n", []string{}, "comma-separated list of namespaces to collect information from")
+	rootCmd.SetUsageTemplate("Usage: \n kic-supportpkg -n namespace1 -n namespace2 ...")
+
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}

internal/data_collector/data_collector.go

@@ -1,33 +1,9 @@
 package main
 
 import (
-	"fmt"
-	"github.com/nginxinc/kubectl-kic-supportpkg/internal/data_collector"
-	"github.com/nginxinc/kubectl-kic-supportpkg/internal/jobs"
-	"k8s.io/client-go/tools/clientcmd"
-	"k8s.io/client-go/util/homedir"
-	"path/filepath"
+	"github.com/nginxinc/kubectl-kic-supportpkg/cmd"
 )
 
 func main() {
-
-	home := homedir.HomeDir()
-	kubeConfig := filepath.Join(home, ".kube", "config")
-	config, err := clientcmd.BuildConfigFromFlags("", kubeConfig)
-
-	namespaces := []string{"nginx-ingress-0", "observability"}
-
-	collector := data_collector.NewDataCollector(config, namespaces...)
-
-	if err != nil {
-		panic(err.Error())
-	}
-
-	for _, job := range jobs.JobList() {
-		fmt.Printf("Running %s and collecting the output in %s...\n", job.Name, collector.BaseDir)
-		job.Collect(collector)
-	}
-
-	//collector.WrapUp()
-
+	cmd.Execute()
 }

main.go

@@ -0,0 +1,123 @@
+package data_collector
+
+import (
+	"archive/tar"
+	"compress/gzip"
+	"fmt"
+	helmClient "github.com/mittwald/go-helm-client"
+	"io"
+	crdClient "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/tools/clientcmd"
+	"k8s.io/client-go/util/homedir"
+	metricsClient "k8s.io/metrics/pkg/client/clientset/versioned"
+	"os"
+	"path/filepath"
+	"strconv"
+	"time"
+)
+
+type DataCollector struct {
+	BaseDir             string
+	Namespaces          []string
+	K8sCoreClientSet    *kubernetes.Clientset
+	K8sCrdClientSet     *crdClient.Clientset
+	K8sMetricsClientSet *metricsClient.Clientset
+	K8sHelmClientSet    map[string]helmClient.Client
+}
+
+func NewDataCollector(namespaces ...string) (*DataCollector, error) {
+
+	tmpDir, err := os.MkdirTemp("", "kic-diag")
+
+	if err != nil {
+		return nil, fmt.Errorf("unable to create temp directory: %s", err)
+	}
+
+	// Find config
+	home := homedir.HomeDir()
+	kubeConfig := filepath.Join(home, ".kube", "config")
+	config, err := clientcmd.BuildConfigFromFlags("", kubeConfig)
+
+	if err != nil {
+		return nil, fmt.Errorf("unable to create k8s config: %s", err)
+	}
+
+	dc := DataCollector{
+		BaseDir:          tmpDir,
+		Namespaces:       namespaces,
+		K8sHelmClientSet: make(map[string]helmClient.Client),
+	}
+
+	//Initialize clients
+	dc.K8sCoreClientSet, _ = kubernetes.NewForConfig(config)
+	dc.K8sCrdClientSet, _ = crdClient.NewForConfig(config)
+	dc.K8sMetricsClientSet, _ = metricsClient.NewForConfig(config)
+	for _, namespace := range dc.Namespaces {
+		dc.K8sHelmClientSet[namespace], _ = helmClient.NewClientFromRestConf(&helmClient.RestConfClientOptions{
+			Options:    &helmClient.Options{Namespace: namespace},
+			RestConfig: config,
+		})
+	}
+
+	return &dc, nil
+}
+
+func (c *DataCollector) WrapUp() error {
+
+	// Create the tarball file
+	//wd, _ := os.Getwd()
+	unixTime := time.Now().Unix()
+	unixTimeString := strconv.FormatInt(unixTime, 10)
+	tarballName := fmt.Sprintf("kic-supportpkg-%s.tar.gz", unixTimeString)
+
+	file, err := os.Create(tarballName)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	gw := gzip.NewWriter(file)
+	defer gw.Close()
+
+	tw := tar.NewWriter(gw)
+	defer tw.Close()
+
+	filepath.Walk(c.BaseDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		header, err := tar.FileInfoHeader(info, "")
+		if err != nil {
+			return err
+		}
+		header.Name = path
+		//TODO: correct this to relative path
+
+		if err := tw.WriteHeader(header); err != nil {
+			return err
+		}
+
+		if !info.Mode().IsRegular() {
+			return nil
+		}
+
+		file, err := os.Open(path)
+		if err != nil {
+			return err
+		}
+		defer file.Close()
+
+		_, err = io.Copy(tw, file)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	fmt.Println("Tarball created successfully:", tarballName)
+	os.RemoveAll(c.BaseDir)
+	return nil
+}

pkg/data_collector/data_collector.go

@@ -2,7 +2,7 @@ package jobs
 
 import (
 	"context"
-	"github.com/nginxinc/kubectl-kic-supportpkg/internal/data_collector"
+	"github.com/nginxinc/kubectl-kic-supportpkg/pkg/data_collector"
 	"os"
 	"path"
 	"time"
@@ -12,18 +12,26 @@ type Job struct {
 	Name    string
 	Global  bool
 	Execute func(dc *data_collector.DataCollector, ctx context.Context) map[string][]byte
+	//TODO: execute function must return an error
 }
 
-func (j Job) Collect(dc *data_collector.DataCollector) {
+func (j Job) Collect(dc *data_collector.DataCollector) error {
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 
 	jobResults := j.Execute(dc, ctx)
 
 	for fileName, fileValue := range jobResults {
-		os.MkdirAll(path.Dir(fileName), os.ModePerm)
+		err := os.MkdirAll(path.Dir(fileName), os.ModePerm)
+		if err != nil {
+			return err
+		}
 		file, _ := os.Create(fileName)
-		_, _ = file.Write(fileValue)
-		file.Close()
+		_, err = file.Write(fileValue)
+		if err != nil {
+			return err
+		}
+		_ = file.Close()
 	}
+	return nil
 }

internal/jobs/job.go renamed to pkg/jobs/job.go

@@ -4,7 +4,8 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"github.com/nginxinc/kubectl-kic-supportpkg/internal/data_collector"
+	"fmt"
+	"github.com/nginxinc/kubectl-kic-supportpkg/pkg/data_collector"
 	"io"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -34,18 +35,20 @@ func JobList() []Job {
 			Execute: func(dc *data_collector.DataCollector, ctx context.Context) map[string][]byte {
 				results := make(map[string][]byte)
 				for _, namespace := range dc.Namespaces {
-					pods, _ := dc.K8sCoreClientSet.CoreV1().Pods(namespace).List(ctx, metav1.ListOptions{FieldSelector: "name"})
+					pods, _ := dc.K8sCoreClientSet.CoreV1().Pods(namespace).List(ctx, metav1.ListOptions{})
 					for _, pod := range pods.Items {
-						logFileName := path.Join(dc.BaseDir, namespace, "logs", pod.Name+".txt")
-						bufferedLogs := dc.K8sCoreClientSet.CoreV1().Pods(namespace).GetLogs(pod.Name, &corev1.PodLogOptions{})
-						podLogs, err := bufferedLogs.Stream(context.TODO())
-						if err != nil {
-							log.Fatal("error in opening stream")
+						for _, container := range pod.Spec.Containers {
+							logFileName := path.Join(dc.BaseDir, namespace, "logs", fmt.Sprintf("%s__%s.txt", pod.Name, container.Name))
+							bufferedLogs := dc.K8sCoreClientSet.CoreV1().Pods(namespace).GetLogs(pod.Name, &corev1.PodLogOptions{Container: container.Name})
+							podLogs, err := bufferedLogs.Stream(context.TODO())
+							if err != nil {
+								log.Fatal("error in opening stream")
+							}
+							buf := new(bytes.Buffer)
+							_, _ = io.Copy(buf, podLogs)
+							podLogs.Close()
+							results[logFileName] = buf.Bytes()
 						}
-						buf := new(bytes.Buffer)
-						_, _ = io.Copy(buf, podLogs)
-						podLogs.Close()
-						results[logFileName] = buf.Bytes()
 					}
 				}
 				return results
@@ -185,16 +188,29 @@ func JobList() []Job {
 			},
 		},
 		{
-			Name:   "helm-information",
+			Name:   "helm-info",
 			Global: true,
 			Execute: func(dc *data_collector.DataCollector, ctx context.Context) map[string][]byte {
 				jobResults := make(map[string][]byte)
-				settings := dc.K8sHelmClientSet.GetSettings()
+				settings := dc.K8sHelmClientSet[dc.Namespaces[0]].GetSettings()
 				jsonSettings, _ := json.MarshalIndent(settings, "", "  ")
 				jobResults[path.Join(dc.BaseDir, "helm", "settings.json")] = jsonSettings
-				releases, _ := dc.K8sHelmClientSet.ListDeployedReleases()
-				jsonReleases, _ := json.MarshalIndent(releases, "", "  ")
-				jobResults[path.Join(dc.BaseDir, "helm", "releases.json")] = jsonReleases
+				return jobResults
+			},
+		},
+		{
+			Name:   "helm-deployments",
+			Global: false,
+			Execute: func(dc *data_collector.DataCollector, ctx context.Context) map[string][]byte {
+				jobResults := make(map[string][]byte)
+				for _, namespace := range dc.Namespaces {
+					releases, _ := dc.K8sHelmClientSet[namespace].ListDeployedReleases()
+					for _, release := range releases {
+						jsonRelease, _ := json.MarshalIndent(release, "", "  ")
+						jobResults[path.Join(dc.BaseDir, "helm", namespace, release.Name+"_release.json")] = jsonRelease
+						jobResults[path.Join(dc.BaseDir, "helm", namespace, release.Name+"_manifest.txt")] = []byte(release.Manifest)
+					}
+				}
 				return jobResults
 			},
 		},