Merge f2ea7a4cdd into 4f0749ccbe

chaoscenter/subscriber/pkg/k8s/client.go

@@ -1,6 +1,8 @@
 package k8s
 
 import (
+	"fmt"
+
 	wfclientset "github.com/argoproj/argo-workflows/v3/pkg/client/clientset/versioned"
 	v1alpha12 "github.com/argoproj/argo-workflows/v3/pkg/client/clientset/versioned/typed/workflow/v1alpha1"
 	"k8s.io/client-go/discovery"
@@ -15,10 +17,15 @@ var KubeConfig *string
 // getKubeConfig setup the config for access cluster resource
 func (k8s *k8sSubscriber) GetKubeConfig() (*rest.Config, error) {
 	// Use in-cluster config if kubeconfig path is not specified
-	if *KubeConfig == "" {
+	if *KubeConfig == "" || KubeConfig == nil {
 		return rest.InClusterConfig()
 	}
-	return clientcmd.BuildConfigFromFlags("", *KubeConfig)
+
+	config, err := clientcmd.BuildConfigFromFlags("", *KubeConfig)
+	if err != nil {
+		return nil, fmt.Errorf("failed to build config from kubeconfig: %v", err)
+	}
+	return config, nil
 }
 
 func (k8s *k8sSubscriber) GetGenericK8sClient() (*kubernetes.Clientset, error) {

chaoscenter/subscriber/pkg/k8s/fuzz/client_fuzz_test.go

@@ -0,0 +1,38 @@
+package fuzz
+
+import (
+	"subscriber/pkg/graphql"
+	"subscriber/pkg/k8s"
+	"testing"
+
+	fuzz "github.com/AdaLogics/go-fuzz-headers"
+)
+
+func FuzzGenerateArgoClient(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &struct {
+			namespace string
+		}{}
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			return
+		}
+
+		if targetStruct.namespace == "" {
+			targetStruct.namespace = "default-namespace"
+		}
+		subscriberGraphql := graphql.NewSubscriberGql()
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+
+		wfClient, err := subscriberK8s.GenerateArgoClient(targetStruct.namespace)
+		if err != nil {
+			t.Logf("Unexpected error: %v", err)
+			return
+		}
+
+		if wfClient == nil {
+			t.Errorf("Returned payload is nil")
+		}
+	})
+}

chaoscenter/subscriber/pkg/k8s/fuzz/log_fuzz_test.go

@@ -0,0 +1,108 @@
+package fuzz
+
+import (
+	"subscriber/pkg/graphql"
+	"subscriber/pkg/k8s"
+	"subscriber/pkg/types"
+	"testing"
+
+	fuzz "github.com/AdaLogics/go-fuzz-headers"
+)
+
+func FuzzGetLogs(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &struct {
+			PodName   string
+			Namespace string
+			Container string
+		}{}
+
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			t.Skip("Failed to generate struct:", err)
+			return
+		}
+
+		subscriberGraphql := graphql.NewSubscriberGql()
+		if subscriberGraphql == nil {
+			t.Fatalf("Failed to create a GraphQL subscriber")
+		}
+
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+		if subscriberK8s == nil {
+			t.Fatalf("Failed to create a Kubernetes subscriber")
+		}
+
+		response, err := subscriberK8s.GetLogs(targetStruct.PodName, targetStruct.Namespace, targetStruct.Container)
+		if err != nil {
+			t.Logf("Unexpected error: %v", err)
+			return
+		}
+		if response == "" {
+			t.Errorf("Returned payload is nil")
+		}
+	})
+}
+
+func FuzzCreatePodLogs(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &struct {
+			podLog types.PodLogRequest
+		}{}
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			return
+		}
+		subscriberGraphql := graphql.NewSubscriberGql()
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+		_, err = subscriberK8s.CreatePodLog(targetStruct.podLog)
+		if err != nil {
+			t.Errorf("Unexpected error: %v", err)
+		}
+	})
+}
+
+func FuzzSendPodLogs(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &struct {
+			infraData map[string]string
+			podLog    types.PodLogRequest
+		}{}
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			return
+		}
+		subscriberGraphql := graphql.NewSubscriberGql()
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+		subscriberK8s.SendPodLogs(targetStruct.infraData, targetStruct.podLog)
+	})
+}
+
+func FuzzGenerateLogPayload(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &struct {
+			cid       string
+			accessKey string
+			version   string
+			podLog    types.PodLogRequest
+		}{}
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			return
+		}
+		subscriberGraphql := graphql.NewSubscriberGql()
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+		response, err := subscriberK8s.GenerateLogPayload(targetStruct.cid, targetStruct.accessKey, targetStruct.version, targetStruct.podLog)
+		if err != nil {
+			t.Errorf("Unexpected error: %v", err)
+		}
+		if response == nil {
+			t.Errorf("Returned payload is nil")
+		}
+
+	})
+}

chaoscenter/subscriber/pkg/k8s/fuzz/objects_fuzz_test.go

@@ -0,0 +1,269 @@
+package fuzz
+
+import (
+	"subscriber/pkg/graphql"
+	"subscriber/pkg/k8s"
+	"subscriber/pkg/types"
+	"testing"
+
+	fuzz "github.com/AdaLogics/go-fuzz-headers"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/dynamic"
+)
+
+func FuzzGetKubernetesNamespaces(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &types.KubeNamespaceRequest{}
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			t.Skip("Failed to generate struct:", err)
+			return
+		}
+		subscriberGraphql := graphql.NewSubscriberGql()
+		if subscriberGraphql == nil {
+			t.Fatalf("Failed to create a GraphQL subscriber")
+		}
+
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+		if subscriberK8s == nil {
+			t.Fatalf("Failed to create a Kubernetes subscriber")
+		}
+
+		response, err := subscriberK8s.GetKubernetesNamespaces(*targetStruct)
+		if err != nil {
+			t.Logf("Unexpected error: %v", err)
+			return
+		}
+		if response == nil {
+			t.Errorf("Returned response is nil")
+		} else if len(response) == 0 {
+			t.Errorf("Returned response is an empty slice")
+		} else {
+			for _, ns := range response {
+				if ns.Name == "" {
+					t.Errorf("Namespace name is empty in response")
+				}
+			}
+		}
+	})
+}
+
+func FuzzGetKubernetesObjects(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &types.KubeObjRequest{}
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			t.Skip("Failed to generate struct:", err)
+			return
+		}
+		subscriberGraphql := graphql.NewSubscriberGql()
+		if subscriberGraphql == nil {
+			t.Fatalf("Failed to create a GraphQL subscriber")
+		}
+
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+		if subscriberK8s == nil {
+			t.Fatalf("Failed to create a Kubernetes subscriber")
+		}
+
+		response, err := subscriberK8s.GetKubernetesObjects(*targetStruct)
+		if err != nil {
+			t.Logf("Unexpected error: %v", err)
+			return
+		}
+		if response == nil {
+			t.Errorf("Returned response is nil")
+			return
+		}
+
+		if response.Namespace == "" {
+			t.Errorf("Namespace in response is empty")
+		}
+
+		if response.Data == nil {
+			t.Errorf("Data in response is nil")
+		} else {
+			if len(response.Data) == 0 {
+				t.Errorf("Data in response is an empty slice")
+			}
+		}
+	})
+}
+func FuzzGetObjectDataByNamespace(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &struct {
+			namespace     string
+			dynamicClient dynamic.Interface
+			resourceType  schema.GroupVersionResource
+		}{}
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			t.Skip("Failed to generate struct:", err)
+			return
+		}
+
+		if targetStruct.dynamicClient == nil {
+			t.Logf("dynamicClient is nil")
+			return
+		}
+		if targetStruct.resourceType == (schema.GroupVersionResource{}) {
+			t.Logf("resourceType is uninitialized")
+			return
+		}
+		if targetStruct.namespace == "" {
+			t.Logf("namespace is empty")
+			return
+		}
+
+		subscriberGraphql := graphql.NewSubscriberGql()
+		if subscriberGraphql == nil {
+			t.Fatalf("Failed to create a GraphQL subscriber")
+		}
+
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+		if subscriberK8s == nil {
+			t.Fatalf("Failed to create a Kubernetes subscriber")
+		}
+
+		response, err := subscriberK8s.GetObjectDataByNamespace(targetStruct.namespace, targetStruct.dynamicClient, targetStruct.resourceType)
+		if err != nil {
+			t.Logf("Unexpected error: %v", err)
+			return
+		}
+		if response == nil {
+			t.Errorf("Returned response is nil")
+			return
+		}
+	})
+}
+
+func FuzzGenerateKubeNamespace(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &struct {
+			cid                  string
+			accessKey            string
+			version              string
+			kubenamespacerequest types.KubeNamespaceRequest
+		}{}
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			t.Skip("Failed to generate struct:", err)
+			return
+		}
+		subscriberGraphql := graphql.NewSubscriberGql()
+		if subscriberGraphql == nil {
+			t.Fatalf("Failed to create a GraphQL subscriber")
+		}
+
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+		if subscriberK8s == nil {
+			t.Fatalf("Failed to create a Kubernetes subscriber")
+		}
+		response, err := subscriberK8s.GenerateKubeNamespace(targetStruct.cid, targetStruct.accessKey, targetStruct.version, targetStruct.kubenamespacerequest)
+		if err != nil {
+			t.Logf("Unexpected error: %v", err)
+			return
+		}
+		if response == nil {
+			t.Errorf("Returned response is nil")
+			return
+		}
+	})
+}
+
+func FuzzGenerateKubeObject(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &struct {
+			cid                  string
+			accessKey            string
+			version              string
+			kubenamespacerequest types.KubeObjRequest
+		}{}
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			t.Skip("Failed to generate struct:", err)
+			return
+		}
+		subscriberGraphql := graphql.NewSubscriberGql()
+		if subscriberGraphql == nil {
+			t.Fatalf("Failed to create a GraphQL subscriber")
+		}
+
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+		if subscriberK8s == nil {
+			t.Fatalf("Failed to create a Kubernetes subscriber")
+		}
+		response, err := subscriberK8s.GenerateKubeObject(targetStruct.cid, targetStruct.accessKey, targetStruct.version, targetStruct.kubenamespacerequest)
+		if err != nil {
+			t.Logf("Unexpected error: %v", err)
+			return
+		}
+		if response == nil {
+			t.Errorf("Returned response is nil")
+			return
+		}
+	})
+}
+
+func FuzzSendKubeNamespaces(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &struct {
+			infraData            map[string]string
+			kubenamespacerequest types.KubeNamespaceRequest
+		}{}
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			t.Skip("Failed to generate struct:", err)
+			return
+		}
+		subscriberGraphql := graphql.NewSubscriberGql()
+		if subscriberGraphql == nil {
+			t.Fatalf("Failed to create a GraphQL subscriber")
+		}
+
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+		if subscriberK8s == nil {
+			t.Fatalf("Failed to create a Kubernetes subscriber")
+		}
+		err = subscriberK8s.SendKubeNamespaces(targetStruct.infraData, targetStruct.kubenamespacerequest)
+		if err != nil {
+			t.Logf("Unexpected error: %v", err)
+			return
+		}
+	})
+}
+
+func FuzzSendKubeObjects(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &struct {
+			infraData         map[string]string
+			kubeobjectrequest types.KubeObjRequest
+		}{}
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			t.Skip("Failed to generate struct:", err)
+			return
+		}
+		subscriberGraphql := graphql.NewSubscriberGql()
+		if subscriberGraphql == nil {
+			t.Fatalf("Failed to create a GraphQL subscriber")
+		}
+
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+		if subscriberK8s == nil {
+			t.Fatalf("Failed to create a Kubernetes subscriber")
+		}
+		err = subscriberK8s.SendKubeObjects(targetStruct.infraData, targetStruct.kubeobjectrequest)
+		if err != nil {
+			t.Logf("Unexpected error: %v", err)
+			return
+		}
+	})
+}

chaoscenter/subscriber/pkg/k8s/fuzz/operations_fuzz_test.go

@@ -0,0 +1,130 @@
+package fuzz
+
+import (
+	"subscriber/pkg/graphql"
+	"subscriber/pkg/k8s"
+	pkgTypes "subscriber/pkg/types"
+	"testing"
+
+	fuzz "github.com/AdaLogics/go-fuzz-headers"
+)
+
+func FuzzCheckComponentStatus(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &struct {
+			componentEnv string
+		}{}
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			t.Skip("Failed to generate struct:", err)
+			return
+		}
+		subscriberGraphql := graphql.NewSubscriberGql()
+		if subscriberGraphql == nil {
+			t.Fatalf("Failed to create a GraphQL subscriber")
+		}
+
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+		if subscriberK8s == nil {
+			t.Fatalf("Failed to create a Kubernetes subscriber")
+		}
+		err = subscriberK8s.CheckComponentStatus(targetStruct.componentEnv)
+		if err != nil {
+			t.Logf("Unexpected error: %v", err)
+			return
+		}
+	})
+}
+
+func FuzzAgentRegister(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &struct {
+			accessKey string
+		}{}
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			t.Skip("Failed to generate struct:", err)
+			return
+		}
+		subscriberGraphql := graphql.NewSubscriberGql()
+		if subscriberGraphql == nil {
+			t.Fatalf("Failed to create a GraphQL subscriber")
+		}
+
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+		if subscriberK8s == nil {
+			t.Fatalf("Failed to create a Kubernetes subscriber")
+		}
+		_, err = subscriberK8s.AgentRegister(targetStruct.accessKey)
+		if err != nil {
+			t.Logf("Unexpected error: %v", err)
+			return
+		}
+	})
+}
+
+func FuzzAgentOperations(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &struct {
+			infraAction pkgTypes.Action
+		}{}
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			t.Skip("Failed to generate struct:", err)
+			return
+		}
+		subscriberGraphql := graphql.NewSubscriberGql()
+		if subscriberGraphql == nil {
+			t.Fatalf("Failed to create a GraphQL subscriber")
+		}
+
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+		if subscriberK8s == nil {
+			t.Fatalf("Failed to create a Kubernetes subscriber")
+		}
+		response, err := subscriberK8s.AgentOperations(targetStruct.infraAction)
+		if err != nil {
+			t.Logf("Unexpected error: %v", err)
+			return
+		}
+		if response == nil {
+			t.Errorf("Returned response is nil")
+			return
+		}
+	})
+}
+
+func FuzzAgentConfirm(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		fuzzConsumer := fuzz.NewConsumer(data)
+		targetStruct := &struct {
+			infraData map[string]string
+		}{}
+		err := fuzzConsumer.GenerateStruct(targetStruct)
+		if err != nil {
+			t.Skip("Failed to generate struct:", err)
+			return
+		}
+		subscriberGraphql := graphql.NewSubscriberGql()
+		if subscriberGraphql == nil {
+			t.Fatalf("Failed to create a GraphQL subscriber")
+		}
+
+		subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql)
+		if subscriberK8s == nil {
+			t.Fatalf("Failed to create a Kubernetes subscriber")
+		}
+		response, err := subscriberK8s.AgentConfirm(targetStruct.infraData)
+		if err != nil {
+			t.Logf("Unexpected error: %v", err)
+			return
+		}
+		if response == nil {
+			t.Errorf("Returned response is nil")
+			return
+		}
+	})
+}

chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzAgentConfirm/582528ddfad69eb5

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0")

chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGenerateArgoClient/582528ddfad69eb5

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0")

chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGetLogs/0c6be63e12aa5eb7

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x000")

chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGetLogs/582528ddfad69eb5

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0")

chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGetObjectDataByNamespace/582528ddfad69eb5

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0")