Bugfix: Listener: Do not use storage version as preferred server version for CRDs (#101)

* use server preferred version instead of storage version for CRDs

* apply review suggestion: avoid string manipulations

* ci: change action trigger

* ci: trigger push event only on main branch

* fix missing labelSelector schema

---------

Co-authored-by: aaronschweig <aaron.schweig@gmail.com>

Author: fourthisle

.github/workflows/pipeline.yml

@@ -1,5 +1,12 @@
 name: ci
-on: [push]
+on: 
+  push:
+    branches:
+      - main
+  pull_request:
+    types:
+      - opened
+      - synchronize
 
 jobs:
   pipe:

listener/apischema/crd_resolver.go

@@ -12,6 +12,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/discovery"
 	"k8s.io/client-go/openapi"
 	"k8s.io/kube-openapi/pkg/validation/spec"
@@ -23,6 +24,11 @@ var (
 	ErrGVKNotPreferred = errors.New("failed to find CRD GVK in API preferred resources")
 )
 
+type GroupKindVersions struct {
+	*metav1.GroupKind
+	Versions []string
+}
+
 type CRDResolver struct {
 	*discovery.DiscoveryClient
 	meta.RESTMapper
@@ -33,44 +39,44 @@ func (cr *CRDResolver) Resolve() ([]byte, error) {
 }
 
 func (cr *CRDResolver) ResolveApiSchema(crd *apiextensionsv1.CustomResourceDefinition) ([]byte, error) {
-	gvk, err := getCRDGroupVersionKind(crd.Spec)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get CRD GVK: %w", err)
-	}
+	gkv := getCRDGroupKindVersions(crd.Spec)
 
 	apiResLists, err := cr.ServerPreferredResources()
 	if err != nil {
 		return nil, fmt.Errorf("failed to get server preferred resources: %w", err)
 	}
 
-	preferredApiGroups, err := errorIfCRDNotInPreferredApiGroups(gvk, apiResLists)
+	preferredApiGroups, err := errorIfCRDNotInPreferredApiGroups(gkv, apiResLists)
 	if err != nil {
 		return nil, fmt.Errorf("failed to filter server preferred resources: %w", err)
 	}
 
 	return resolveForPaths(cr.OpenAPIV3(), preferredApiGroups, cr.RESTMapper)
 }
 
-func errorIfCRDNotInPreferredApiGroups(gvk *metav1.GroupVersionKind, apiResLists []*metav1.APIResourceList) ([]string, error) {
-	targetGV := gvk.Group + "/" + gvk.Version
-	isGVFound := false
+func errorIfCRDNotInPreferredApiGroups(gkv *GroupKindVersions, apiResLists []*metav1.APIResourceList) ([]string, error) {
+	isKindFound := false
 	preferredApiGroups := make([]string, 0, len(apiResLists))
 	for _, apiResources := range apiResLists {
-		gv := apiResources.GroupVersion
-		isGVFound = gv == targetGV
-		if isGVFound && !isCRDKindIncluded(gvk, apiResources) {
-			return nil, ErrGVKNotPreferred
+		gv, err := schema.ParseGroupVersion(apiResources.GroupVersion)
+		if err != nil {
+			//TODO: debug log?
+			continue
+		}
+		isGroupFound := gkv.Group == gv.Group
+		isVersionFound := slices.Contains(gkv.Versions, gv.Version)
+		if isGroupFound && isVersionFound && !isKindFound {
+			isKindFound = isCRDKindIncluded(gkv, apiResources)
 		}
-		preferredApiGroups = append(preferredApiGroups, gv)
+		preferredApiGroups = append(preferredApiGroups, apiResources.GroupVersion)
 	}
-
-	if !isGVFound {
+	if !isKindFound {
 		return nil, ErrGVKNotPreferred
 	}
 	return preferredApiGroups, nil
 }
 
-func isCRDKindIncluded(gvk *metav1.GroupVersionKind, apiResources *metav1.APIResourceList) bool {
+func isCRDKindIncluded(gvk *GroupKindVersions, apiResources *metav1.APIResourceList) bool {
 	for _, res := range apiResources.APIResources {
 		if res.Kind == gvk.Kind {
 			return true
@@ -79,17 +85,18 @@ func isCRDKindIncluded(gvk *metav1.GroupVersionKind, apiResources *metav1.APIRes
 	return false
 }
 
-func getCRDGroupVersionKind(spec apiextensionsv1.CustomResourceDefinitionSpec) (*metav1.GroupVersionKind, error) {
+func getCRDGroupKindVersions(spec apiextensionsv1.CustomResourceDefinitionSpec) *GroupKindVersions {
+	versions := make([]string, 0, len(spec.Versions))
 	for _, v := range spec.Versions {
-		if v.Storage {
-			return &metav1.GroupVersionKind{
-				Group:   spec.Group,
-				Version: v.Name,
-				Kind:    spec.Names.Kind,
-			}, nil
-		}
+		versions = append(versions, v.Name)
+	}
+	return &GroupKindVersions{
+		GroupKind: &metav1.GroupKind{
+			Group: spec.Group,
+			Kind:  spec.Names.Kind,
+		},
+		Versions: versions,
 	}
-	return nil, errors.New("failed to find storage version")
 }
 
 func getSchemaForPath(preferredApiGroups []string, path string, gv openapi.GroupVersion) (map[string]*spec.Schema, error) {

listener/apischema/scope_resolver.go

@@ -22,12 +22,10 @@ type GroupVersionKind struct {
 }
 
 func addScopeInfo(schemas map[string]*spec.Schema, rm meta.RESTMapper) (map[string]*spec.Schema, error) {
-	scopedSchemas := make(map[string]*spec.Schema)
-	for name, schema := range schemas {
+	for _, schema := range schemas {
 		//skip resources that do not have the GVK extension:
 		//assumption: sub-resources do not have GVKs
 		if schema.VendorExtensible.Extensions == nil {
-			scopedSchemas[name] = schema
 			continue
 		}
 		var gvksVal any
@@ -70,7 +68,6 @@ func addScopeInfo(schemas map[string]*spec.Schema, rm meta.RESTMapper) (map[stri
 			schema.VendorExtensible.AddExtension(scopeExtensionKey, apiextensionsv1.ClusterScoped)
 		}
 
-		scopedSchemas[name] = schema
 	}
-	return scopedSchemas, nil
+	return schemas, nil
 }