init

Author: ops

.gitignore

@@ -13,3 +13,5 @@
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
+
+*.idea

cmd/root.go

@@ -0,0 +1,88 @@
+/*
+Copyright © 2022 poorops poorops@163.com
+
+*/
+package cmd
+
+import (
+	"fmt"
+	"github.com/spf13/cobra"
+	"k8s.io/cli-runtime/pkg/genericclioptions"
+	"k8s.io/utils/strings/slices"
+	"kubectl-check/pkg/base"
+	"kubectl-check/pkg/check"
+	"kubectl-check/pkg/client"
+	"kubectl-check/pkg/table"
+	"os"
+	"strings"
+)
+
+var (
+	KubernetesConfigFlags *genericclioptions.ConfigFlags
+	field                 string
+	selector              string
+)
+
+// rootCmd represents the base command when called without any subcommands
+var rootCmd = &cobra.Command{
+	Use:   "kubectl-check",
+	Short: "check field from k8s resource definition",
+	Long: `kubectl-check is a plugin for kubectl command.
+the plugin is a tool to check definition for the  specified filed from k8s resource.
+For Example:
+	kubectl check -f nodeSelector`,
+	// Uncomment the following line if your bare application
+	// has an action associated with it:
+	Run: func(cmd *cobra.Command, args []string) {
+		namespace, _ := cmd.Flags().GetString("namespace")
+		if namespace == "" {
+			namespace = "default"
+		}
+
+		f, _ := cmd.Flags().GetString("field")
+		l, _ := cmd.Flags().GetString("selector")
+
+		if !slices.Contains(base.ValidFields, f) {
+			fmt.Printf("invalid filed, for now supported filed is: %s, current is %s\n", strings.Join(base.ValidFields, ", "), f)
+			return
+		}
+
+		client, err := client.NewClientSet(KubernetesConfigFlags)
+		if err != nil {
+			fmt.Printf("error to set client: %v", err)
+			return
+		}
+
+		plugin := check.NewPlugin(f, namespace, l, client)
+		result, e := plugin.Value()
+		if e != nil {
+			fmt.Printf("error to get result: %v", e)
+			return
+		}
+		table.GenTable(result)
+	},
+}
+
+// Execute adds all child commands to the root command and sets flags appropriately.
+// This is called by main.main(). It only needs to happen once to the rootCmd.
+func Execute() {
+	err := rootCmd.Execute()
+	if err != nil {
+		os.Exit(1)
+	}
+}
+
+func init() {
+	// Here you will define your flags and configuration settings.
+	// Cobra supports persistent flags, which, if defined here,
+	// will be global for your application.
+
+	// rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.kubectl-check.yaml)")
+
+	// Cobra also supports local flags, which will only run
+	// when this action is called directly.
+	KubernetesConfigFlags = genericclioptions.NewConfigFlags(true)
+	rootCmd.Flags().StringVarP(&field, "field", "f", "image", "The field to check")
+	rootCmd.Flags().StringVarP(&selector, "selector", "l", "", "Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2)")
+	KubernetesConfigFlags.AddFlags(rootCmd.Flags())
+}

go.mod

@@ -0,0 +1,14 @@
+module kubectl-check
+
+go 1.16
+
+require (
+	github.com/olekukonko/tablewriter v0.0.5
+	github.com/pkg/errors v0.9.1
+	github.com/spf13/cobra v1.4.0
+	k8s.io/api v0.24.0
+	k8s.io/apimachinery v0.24.0
+	k8s.io/cli-runtime v0.24.0
+	k8s.io/client-go v0.24.0
+	k8s.io/utils v0.0.0-20220210201930-3a6ce19ff2f9 // indirect
+)

go.sum

@@ -0,0 +1,11 @@
+/*
+Copyright © 2022 poorops poorops@163.com
+
+*/
+package main
+
+import "kubectl-check/cmd"
+
+func main() {
+	cmd.Execute()
+}

main.go

@@ -0,0 +1,92 @@
+package base
+
+import (
+	"context"
+	"github.com/pkg/errors"
+	v1 "k8s.io/api/apps/v1"
+	batchv1 "k8s.io/api/batch/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes"
+)
+
+type Field struct {
+	Name      string
+	Namespace string
+	Label     string
+	Client    *kubernetes.Clientset
+}
+
+type Resources struct {
+	Deployments  []v1.Deployment
+	StatefulSets []v1.StatefulSet
+	DaemonSets   []v1.DaemonSet
+	CronJobs     []batchv1.CronJob
+}
+
+var ValidFields = []string{"image", "resources"}
+
+func (f *Field) genListOptions() metav1.ListOptions {
+	return metav1.ListOptions{
+		LabelSelector: f.Label,
+	}
+}
+
+func (f *Field) GetDeployments() ([]v1.Deployment, error) {
+	list, e := f.Client.AppsV1().Deployments(f.Namespace).List(context.TODO(), f.genListOptions())
+	if e != nil {
+		return nil, errors.Wrap(e, "fail to list deployments")
+	}
+	return list.Items, nil
+}
+
+func (f *Field) GetStatefulSets() ([]v1.StatefulSet, error) {
+	list, e := f.Client.AppsV1().StatefulSets(f.Namespace).List(context.TODO(), f.genListOptions())
+	if e != nil {
+		return nil, errors.Wrap(e, "fail to list sts")
+	}
+	return list.Items, nil
+}
+
+func (f *Field) GetDaemonSets() ([]v1.DaemonSet, error) {
+	list, e := f.Client.AppsV1().DaemonSets(f.Namespace).List(context.TODO(), f.genListOptions())
+	if e != nil {
+		return nil, errors.Wrap(e, "fail to list ds")
+	}
+	return list.Items, nil
+}
+
+func (f *Field) GetCronJobs() ([]batchv1.CronJob, error) {
+	list, err := f.Client.BatchV1().CronJobs(f.Namespace).List(context.TODO(), f.genListOptions())
+	if err != nil {
+		return nil, errors.Wrap(err, "fail to list cronjob")
+	}
+	return list.Items, nil
+}
+
+func (f *Field) GetResources() (Resources, error) {
+	deployments, err := f.GetDeployments()
+	if err != nil {
+		return Resources{}, err
+	}
+
+	sts, err := f.GetStatefulSets()
+	if err != nil {
+		return Resources{}, err
+	}
+
+	daemonsets, err := f.GetDaemonSets()
+	if err != nil {
+		return Resources{}, err
+	}
+
+	cronjobs, err := f.GetCronJobs()
+	if err != nil {
+		return Resources{}, err
+	}
+	return Resources{
+		Deployments:  deployments,
+		StatefulSets: sts,
+		DaemonSets:   daemonsets,
+		CronJobs:     cronjobs,
+	}, nil
+}

pkg/base/base.go

@@ -0,0 +1,35 @@
+package check
+
+import (
+	"k8s.io/client-go/kubernetes"
+	"kubectl-check/pkg/base"
+	"kubectl-check/pkg/fileds"
+)
+
+type Plugin interface {
+	Value() ([][]string, error)
+}
+
+func NewPlugin(name, namespace, label string, client *kubernetes.Clientset) Plugin {
+	switch name {
+	case "image":
+		return &fileds.ImageField{
+			Field: base.Field{
+				Name:      name,
+				Namespace: namespace,
+				Label:     label,
+				Client:    client,
+			},
+		}
+	case "resources":
+		return &fileds.ResourcesField{
+			Field: base.Field{
+				Name:      name,
+				Namespace: namespace,
+				Label:     label,
+				Client:    client,
+			},
+		}
+	}
+	return nil
+}

pkg/check/check.go

@@ -0,0 +1,16 @@
+package client
+
+import (
+	"github.com/pkg/errors"
+	"k8s.io/cli-runtime/pkg/genericclioptions"
+	"k8s.io/client-go/kubernetes"
+)
+
+func NewClientSet(configFlags *genericclioptions.ConfigFlags) (*kubernetes.Clientset, error) {
+	config, err := configFlags.ToRESTConfig()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to read kubeconfig")
+	}
+
+	return kubernetes.NewForConfig(config)
+}

pkg/client/client.go

@@ -0,0 +1,65 @@
+package fileds
+
+import (
+	"fmt"
+	"kubectl-check/pkg/base"
+)
+
+type ImageField struct {
+	base.Field
+}
+
+func (i *ImageField) Value() ([][]string, error) {
+	result := make([][]string, 0)
+
+	resource, err := i.GetResources()
+	if err != nil {
+		return nil, err
+	}
+
+	if len(resource.Deployments) != 0 {
+		for _, deployment := range resource.Deployments {
+			containers := deployment.Spec.Template.Spec.Containers
+			var images string
+			for _, container := range containers {
+				images += fmt.Sprintf("{container: \"%v\", image: \"%v\"}\n", container.Name, container.Image)
+			}
+			result = append(result, []string{"Deployment", deployment.Name, "image", images})
+		}
+	}
+
+	if len(resource.StatefulSets) != 0 {
+		for _, s := range resource.StatefulSets {
+			containers := s.Spec.Template.Spec.Containers
+			var images string
+			for _, container := range containers {
+				images += fmt.Sprintf("{container: \"%v\", image: \"%v\"}\n", container.Name, container.Image)
+			}
+			result = append(result, []string{"StatefulSet", s.Name, "image", images})
+		}
+	}
+
+	if len(resource.DaemonSets) != 0 {
+		for _, s := range resource.DaemonSets {
+			containers := s.Spec.Template.Spec.Containers
+			var images string
+			for _, container := range containers {
+				images += fmt.Sprintf("{container: \"%v\", image: \"%v\"}\n", container.Name, container.Image)
+			}
+			result = append(result, []string{"DaemonSet", s.Name, "image", images})
+		}
+	}
+
+	if len(resource.CronJobs) != 0 {
+		for _, cronjob := range resource.CronJobs {
+			containers := cronjob.Spec.JobTemplate.Spec.Template.Spec.Containers
+			var images string
+			for _, container := range containers {
+				images += fmt.Sprintf("{container: \"%v\", image: \"%v\"}\n", container.Name, container.Image)
+			}
+			result = append(result, []string{"CronJob", cronjob.Name, "image", images})
+		}
+	}
+
+	return result, nil
+}