141 lines
3.6 KiB
Go
141 lines
3.6 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"iter"
|
|
"k8s.io/api/core/v1"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"k8s.io/client-go/kubernetes"
|
|
"log"
|
|
"maps"
|
|
"os"
|
|
"strconv"
|
|
)
|
|
|
|
type ValidationLevel int
|
|
|
|
const (
|
|
Info ValidationLevel = iota
|
|
Warning
|
|
Error
|
|
)
|
|
|
|
func LogValidationMsg(level ValidationLevel, msg string, v ...any) {
|
|
fmt.Fprintf(os.Stderr, msg+"\n", v...)
|
|
}
|
|
|
|
func IterToSlice[K any](i iter.Seq[K]) []K {
|
|
res := make([]K, 0)
|
|
for v := range i {
|
|
res = append(res, v)
|
|
}
|
|
return res
|
|
}
|
|
|
|
func MapKeys[K comparable, V any](m map[K]V) []K {
|
|
return IterToSlice(maps.Keys(m))
|
|
}
|
|
|
|
func validate(files []string, options *Options) error {
|
|
config, err := readConfig(files)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
clientset, _ := GetKubernetesConnection()
|
|
for _, ns := range config.Namespaces {
|
|
namespace := ns.Name
|
|
_, err = clientset.CoreV1().Namespaces().Get(context.Background(), namespace, metav1.GetOptions{})
|
|
if err != nil {
|
|
LogValidationMsg(Error, "ERROR: namespace not found: %s", namespace)
|
|
continue
|
|
}
|
|
for _, application := range ns.Applications {
|
|
pods := FindPods(application, clientset)
|
|
log.Printf(namespace + "/" + application.Name)
|
|
if len(pods) == 0 {
|
|
LogValidationMsg(Error, "application %s: no running pods found", application.Name)
|
|
}
|
|
ownerReferences := make(map[string]bool)
|
|
for _, pod := range pods {
|
|
log.Printf(" %s %v", pod.Name, pod.OwnerReferences)
|
|
for _, ownerReference := range pod.OwnerReferences {
|
|
ownerReferences[ownerReference.Kind+"/"+ownerReference.Name] = true
|
|
}
|
|
}
|
|
if len(ownerReferences) > 1 {
|
|
LogValidationMsg(Error, "Application %s: multiple owners found: %v", application.Name, MapKeys(ownerReferences))
|
|
}
|
|
// check ports
|
|
for _, port := range application.Ports {
|
|
for _, pod := range pods {
|
|
if !HasPort(pod, port) {
|
|
LogValidationMsg(Error, "application %s: port %v not found in pod %s/%s",
|
|
application.Name, port, pod.Namespace, pod.Name)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for _, communication := range config.Communications {
|
|
if len(communication.Ports) == 0 {
|
|
continue
|
|
}
|
|
for _, applicationName := range communication.To {
|
|
application, _, _ := config.GetApplication(applicationName)
|
|
if application == nil {
|
|
continue
|
|
}
|
|
for _, port := range communication.Ports {
|
|
pods := FindPods(application, clientset)
|
|
for _, pod := range pods {
|
|
if !HasPort(pod, port) {
|
|
LogValidationMsg(Error, "communication %v -> %v: port %v is not configured in pod %s/%s",
|
|
communication.From, communication.To, port, pod.Namespace, pod.Name)
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func FindPods(application *Application, clientset *kubernetes.Clientset) []v1.Pod {
|
|
labelSelector := &metav1.LabelSelector{
|
|
MatchLabels: application.MatchLabels,
|
|
MatchExpressions: application.MatchExpressions,
|
|
}
|
|
selector, err := metav1.LabelSelectorAsSelector(labelSelector)
|
|
if err != nil {
|
|
log.Fatalf("Error creating selector: %v", err)
|
|
}
|
|
pods, err := clientset.CoreV1().Pods(application.Namespace.Name).List(context.TODO(), metav1.ListOptions{
|
|
LabelSelector: selector.String(),
|
|
})
|
|
if err != nil {
|
|
log.Fatalf("Error listing pods: %v", err)
|
|
}
|
|
return pods.Items
|
|
}
|
|
|
|
func HasPort(pod v1.Pod, port Port) bool {
|
|
if port.Protocol == "" {
|
|
port.Protocol = "TCP"
|
|
}
|
|
for _, container := range pod.Spec.Containers {
|
|
for _, kport := range container.Ports {
|
|
if kport.Protocol == "" {
|
|
kport.Protocol = "TCP"
|
|
}
|
|
if port.Protocol == string(kport.Protocol) && (port.Port == kport.Name || port.Port == strconv.Itoa(int(kport.ContainerPort))) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|