update remaining controllers to perform the new routine to determine local/remote GVKs

On-behalf-of: @SAP [email protected]

Author: xrstf

internal/controller/sync/controller.go

@@ -78,22 +78,30 @@ func Create(
 ) (controller.Controller, error) {
 	log = log.Named(ControllerName)
 
+	// find the local CRD so we know the actual local object scope
+	localCRD, err := discoveryClient.RetrieveCRD(ctx, projection.PublishedResourceSourceGK(pubRes))
+	if err != nil {
+		return nil, fmt.Errorf("failed to find local CRD: %w", err)
+	}
+
 	// create a dummy that represents the type used on the local service cluster
-	localGVK := projection.PublishedResourceSourceGVK(pubRes)
+	localGVK, err := projection.PublishedResourceSourceGVK(localCRD, pubRes)
+	if err != nil {
+		return nil, err
+	}
+
 	localDummy := &unstructured.Unstructured{}
 	localDummy.SetGroupVersionKind(localGVK)
 
 	// create a dummy unstructured object with the projected GVK inside the workspace
-	remoteGVK := projection.PublishedResourceProjectedGVK(pubRes)
-	remoteDummy := &unstructured.Unstructured{}
-	remoteDummy.SetGroupVersionKind(remoteGVK)
-
-	// find the local CRD so we know the actual local object scope
-	localCRD, err := discoveryClient.RetrieveCRD(ctx, localGVK)
+	remoteGVK, err := projection.PublishedResourceProjectedGVK(localCRD, pubRes)
 	if err != nil {
-		return nil, fmt.Errorf("failed to find local CRD: %w", err)
+		return nil, err
 	}
 
+	remoteDummy := &unstructured.Unstructured{}
+	remoteDummy.SetGroupVersionKind(remoteGVK)
+
 	// create the syncer that holds the meat&potatoes of the synchronization logic
 	mutator := mutation.NewMutator(pubRes.Spec.Mutation)
 	syncer, err := sync.NewResourceSyncer(log, localManager.GetClient(), virtualWorkspaceCluster.GetClient(), pubRes, localCRD, mutator, stateNamespace, agentName)

internal/projection/projection.go

@@ -39,32 +39,49 @@ func PublishedResourceSourceGK(pubRes *syncagentv1alpha1.PublishedResource) sche
 	}
 }
 
-// PublishedResourceProjectedGVK returns the effective GVK after the projection
-// rules have been applied according to the PublishedResource.
-func PublishedResourceProjectedGVK(pubRes *syncagentv1alpha1.PublishedResource) schema.GroupVersionKind {
-	apiGroup := pubRes.Spec.Resource.APIGroup
-	apiVersion := pubRes.Spec.Resource.Version
-	kind := pubRes.Spec.Resource.Kind
-
-	if projection := pubRes.Spec.Projection; projection != nil {
-		if v := projection.Group; v != "" {
-			apiGroup = v
-		}
+func PublishedResourceSourceGVK(crd *apiextensionsv1.CustomResourceDefinition, pubRes *syncagentv1alpha1.PublishedResource) (schema.GroupVersionKind, error) {
+	storageVersion := getStorageVersion(crd)
+	if storageVersion == "" {
+		return schema.GroupVersionKind{}, errors.New("CRD does not contain a storage version")
+	}
 
-		if v := projection.Version; v != "" {
-			apiVersion = v
-		}
+	sourceGV := PublishedResourceSourceGK(pubRes)
 
-		if k := projection.Kind; k != "" {
-			kind = k
+	return schema.GroupVersionKind{
+		Group:   sourceGV.Group,
+		Version: storageVersion,
+		Kind:    sourceGV.Kind,
+	}, nil
+}
+
+func getStorageVersion(crd *apiextensionsv1.CustomResourceDefinition) string {
+	for _, version := range crd.Spec.Versions {
+		if version.Storage {
+			return version.Name
 		}
 	}
 
-	return schema.GroupVersionKind{
-		Group:   apiGroup,
-		Version: apiVersion,
-		Kind:    kind,
+	return ""
+}
+
+// PublishedResourceProjectedGVK returns the effective GVK after the projection
+// rules have been applied according to the PublishedResource.
+func PublishedResourceProjectedGVK(originalCRD *apiextensionsv1.CustomResourceDefinition, pubRes *syncagentv1alpha1.PublishedResource) (schema.GroupVersionKind, error) {
+	projectedCRD, err := ApplyProjection(originalCRD, pubRes)
+	if err != nil {
+		return schema.GroupVersionKind{}, fmt.Errorf("failed to project CRD: %w", err)
 	}
+
+	storageVersion := getStorageVersion(projectedCRD)
+	if storageVersion == "" {
+		return schema.GroupVersionKind{}, errors.New("projected CRD does not contain a storage version")
+	}
+
+	return schema.GroupVersionKind{
+		Group:   projectedCRD.Spec.Group,
+		Version: storageVersion,
+		Kind:    projectedCRD.Spec.Names.Kind,
+	}, nil
 }
 
 func ApplyProjection(crd *apiextensionsv1.CustomResourceDefinition, pubRes *syncagentv1alpha1.PublishedResource) (*apiextensionsv1.CustomResourceDefinition, error) {

internal/projection/projection_test.go

@@ -20,6 +20,7 @@ import (
 	"testing"
 
 	syncagentv1alpha1 "github.com/kcp-dev/api-syncagent/sdk/apis/syncagent/v1alpha1"
+	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 
 	"k8s.io/apimachinery/pkg/runtime/schema"
 )
@@ -69,6 +70,22 @@ func TestPublishedResourceProjectedGVK(t *testing.T) {
 		},
 	}
 
+	crd := &apiextensionsv1.CustomResourceDefinition{
+		Spec: apiextensionsv1.CustomResourceDefinitionSpec{
+			Group: apiGroup,
+			Names: apiextensionsv1.CustomResourceDefinitionNames{
+				Kind: kind,
+			},
+			Versions: []apiextensionsv1.CustomResourceDefinitionVersion{
+				{
+					Name:    version,
+					Served:  true,
+					Storage: true,
+				},
+			},
+		},
+	}
+
 	testcases := []struct {
 		name       string
 		projection *syncagentv1alpha1.ResourceProjection
@@ -106,7 +123,10 @@ func TestPublishedResourceProjectedGVK(t *testing.T) {
 			pr := pubRes.DeepCopy()
 			pr.Spec.Projection = testcase.projection
 
-			gvk := PublishedResourceProjectedGVK(pr)
+			gvk, err := PublishedResourceProjectedGVK(crd, pr)
+			if err != nil {
+				t.Fatalf("Unexpected error: %v", err)
+			}
 
 			if gvk.Group != testcase.expected.Group {
 				t.Errorf("Expected API group to be %q, but got %q.", testcase.expected.Group, gvk.Group)

internal/sync/syncer.go

@@ -63,21 +63,25 @@ func NewResourceSyncer(
 	agentName string,
 ) (*ResourceSyncer, error) {
 	// create a dummy that represents the type used on the local service cluster
-	localGVK := projection.PublishedResourceSourceGVK(pubRes)
+	localGVK, err := projection.PublishedResourceSourceGVK(localCRD, pubRes)
+	if err != nil {
+		return nil, err
+	}
+
+	// create a dummy that represents the type used on the local service cluster
 	localDummy := &unstructured.Unstructured{}
 	localDummy.SetGroupVersionKind(localGVK)
 
 	// create a dummy unstructured object with the projected GVK inside the workspace
-	remoteGVK := projection.PublishedResourceProjectedGVK(pubRes)
+	remoteGVK, err := projection.PublishedResourceProjectedGVK(localCRD, pubRes)
+	if err != nil {
+		return nil, err
+	}
 
 	// determine whether the CRD has a status subresource in the relevant version
 	subresources := []string{}
-	versionFound := false
-
 	for _, version := range localCRD.Spec.Versions {
-		if version.Name == pubRes.Spec.Resource.Version {
-			versionFound = true
-
+		if version.Name == localGVK.Version {
 			if sr := version.Subresources; sr != nil {
 				if sr.Scale != nil {
 					subresources = append(subresources, "scale")
@@ -89,10 +93,6 @@ func NewResourceSyncer(
 		}
 	}
 
-	if !versionFound {
-		return nil, fmt.Errorf("CRD %s does not define version %s requested by PublishedResource", pubRes.Spec.Resource.APIGroup, pubRes.Spec.Resource.Version)
-	}
-
 	return &ResourceSyncer{
 		log:                 log.With("local-gvk", localGVK, "remote-gvk", remoteGVK),
 		localClient:         localClient,