Adjust to CR not setting TypeMeta anymore

Author: sbueringer

cmd/clusterctl/client/cluster/upgrader_info_test.go

@@ -491,10 +491,6 @@ func toSemanticVersions(versions []string) []version.Version {
 
 func fakeProvider(name string, providerType clusterctlv1.ProviderType, version, targetNamespace string) clusterctlv1.Provider {
 	return clusterctlv1.Provider{
-		TypeMeta: metav1.TypeMeta{
-			APIVersion: clusterctlv1.GroupVersion.String(),
-			Kind:       "Provider",
-		},
 		ObjectMeta: metav1.ObjectMeta{
 			ResourceVersion: "999",
 			Namespace:       targetNamespace,

cmd/clusterctl/client/tree/discovery.go

@@ -19,9 +19,11 @@ package tree
 import (
 	"context"
 
+	"github.com/pkg/errors"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	addonsv1 "sigs.k8s.io/cluster-api/api/addons/v1beta2"
@@ -110,7 +112,9 @@ func Discovery(ctx context.Context, c client.Client, namespace, name string, opt
 
 		addAnnotation(controlPlane, ObjectContractAnnotation, "ControlPlane")
 		addAnnotation(controlPlane, ObjectContractVersionAnnotation, contractVersion)
-		addControlPlane(cluster, controlPlane, tree, options)
+		if err := addControlPlane(ctx, c, cluster, controlPlane, tree, options); err != nil {
+			return nil, err
+		}
 	}
 
 	// Adds control plane machines.
@@ -120,7 +124,7 @@ func Discovery(ctx context.Context, c client.Client, namespace, name string, opt
 	}
 	machineMap := map[string]bool{}
 	addMachineFunc := func(parent client.Object, m *clusterv1.Machine) {
-		_, visible := tree.Add(parent, m)
+		_, visible := tree.Add(parent, m, GroupVersionKind(clusterv1.GroupVersion.WithKind("Machine")))
 		machineMap[m.Name] = true
 
 		if visible {
@@ -204,30 +208,51 @@ func addClusterResourceSetsToObjectTree(ctx context.Context, c client.Client, cl
 	}
 }
 
-func addControlPlane(cluster *clusterv1.Cluster, controlPlane *unstructured.Unstructured, tree *ObjectTree, options DiscoverOptions) {
+func addControlPlane(ctx context.Context, c client.Client, cluster *clusterv1.Cluster, controlPlane *unstructured.Unstructured, tree *ObjectTree, options DiscoverOptions) error {
 	tree.Add(cluster, controlPlane, ObjectMetaName("ControlPlane"), GroupingObject(true))
 
 	if options.ShowTemplates {
 		// Add control plane infrastructure ref using spec fields guaranteed in contract
-		infrastructureRef, found, err := unstructured.NestedMap(controlPlane.UnstructuredContent(), "spec", "machineTemplate", "infrastructureRef")
-		if err == nil && found {
-			infrastructureObjectRef := &corev1.ObjectReference{
-				Kind:       infrastructureRef["kind"].(string),
-				Namespace:  infrastructureRef["namespace"].(string),
-				Name:       infrastructureRef["name"].(string),
-				APIVersion: infrastructureRef["apiVersion"].(string),
-			}
+		contractVersion, err := contract.GetContractVersionForVersion(ctx, c, controlPlane.GroupVersionKind().GroupKind(), controlPlane.GroupVersionKind().Version)
+		if err != nil {
+			return errors.Wrapf(err, "failed to get contract version for the ControlPlane object")
+		}
 
-			machineTemplateRefObject := ObjectReferenceObject(infrastructureObjectRef)
-			var templateParent client.Object
-			if options.AddTemplateVirtualNode {
-				templateParent = addTemplateVirtualNode(tree, controlPlane, cluster.Namespace)
-			} else {
-				templateParent = controlPlane
+		var infrastructureObjectRef *corev1.ObjectReference
+		if contractVersion == "v1beta1" {
+			currentRef, err := contract.ControlPlane().MachineTemplate().InfrastructureV1Beta1Ref().Get(controlPlane)
+			if err != nil {
+				return nil //nolint:nilerr // intentionally ignoring the error here because infraRef in CP is optional
 			}
-			tree.Add(templateParent, machineTemplateRefObject, ObjectMetaName("MachineInfrastructureTemplate"))
+			infrastructureObjectRef = currentRef
+		} else {
+			currentRef, err := contract.ControlPlane().MachineTemplate().InfrastructureRef().Get(controlPlane)
+			if err != nil {
+				return nil //nolint:nilerr // intentionally ignoring the error here because infraRef in CP is optional
+			}
+			apiVersion, err := contract.GetAPIVersion(ctx, c, currentRef.GroupKind())
+			if err != nil {
+				return err
+			}
+			infrastructureObjectRef = &corev1.ObjectReference{
+				APIVersion: apiVersion,
+				Kind:       currentRef.Kind,
+				Namespace:  controlPlane.GetNamespace(),
+				Name:       currentRef.Name,
+			}
+		}
+
+		machineTemplateRefObject := ObjectReferenceObject(infrastructureObjectRef)
+		var templateParent client.Object
+		if options.AddTemplateVirtualNode {
+			templateParent = addTemplateVirtualNode(tree, controlPlane, cluster.Namespace)
+		} else {
+			templateParent = controlPlane
 		}
+		tree.Add(templateParent, machineTemplateRefObject, ObjectMetaName("MachineInfrastructureTemplate"))
 	}
+
+	return nil
 }
 
 func addMachineDeploymentToObjectTree(ctx context.Context, c client.Client, cluster *clusterv1.Cluster, workers *NodeObject, machinesList *clusterv1.MachineList, tree *ObjectTree, options DiscoverOptions, addMachineFunc func(parent client.Object, m *clusterv1.Machine)) error {
@@ -248,6 +273,7 @@ func addMachineDeploymentToObjectTree(ctx context.Context, c client.Client, clus
 		if !options.ShowMachineSets {
 			addOpts = append(addOpts, GroupingObject(true))
 		}
+		addOpts = append(addOpts, GroupVersionKind(clusterv1.GroupVersion.WithKind("MachineDeployment")))
 		tree.Add(workers, md, addOpts...)
 
 		if options.ShowTemplates {
@@ -286,17 +312,17 @@ func addMachineDeploymentToObjectTree(ctx context.Context, c client.Client, clus
 			tree.Add(templateParent, machineTemplateRefObject, ObjectMetaName("MachineInfrastructureTemplate"))
 		}
 
-		machineSets := selectMachinesSetsControlledBy(machineSetList, md)
+		machineSets := selectMachinesSetsControlledBy(machineSetList, md, clusterv1.GroupVersion.WithKind("MachineDeployment").GroupKind())
 		for i := range machineSets {
 			ms := machineSets[i]
 
 			var parent client.Object = md
 			if options.ShowMachineSets {
-				tree.Add(md, ms, GroupingObject(true))
+				tree.Add(md, ms, GroupingObject(true), GroupVersionKind(clusterv1.GroupVersion.WithKind("MachineSet")))
 				parent = ms
 			}
 
-			machines := selectMachinesControlledBy(machinesList, ms)
+			machines := selectMachinesControlledBy(machinesList, ms, clusterv1.GroupVersion.WithKind("MachineSet").GroupKind())
 			for _, w := range machines {
 				addMachineFunc(parent, w)
 			}
@@ -309,7 +335,7 @@ func addMachineDeploymentToObjectTree(ctx context.Context, c client.Client, clus
 func addMachinePoolsToObjectTree(ctx context.Context, c client.Client, workers *NodeObject, machinePoolList *clusterv1.MachinePoolList, machinesList *clusterv1.MachineList, tree *ObjectTree, addMachineFunc func(parent client.Object, m *clusterv1.Machine)) {
 	for i := range machinePoolList.Items {
 		mp := &machinePoolList.Items[i]
-		_, visible := tree.Add(workers, mp, GroupingObject(true))
+		_, visible := tree.Add(workers, mp, GroupingObject(true), GroupVersionKind(clusterv1.GroupVersion.WithKind("MachinePool")))
 
 		if visible {
 			if machinePoolBootstrap, err := external.GetObjectFromContractVersionedRef(ctx, c, mp.Spec.Template.Spec.Bootstrap.ConfigRef, mp.Namespace); err == nil {
@@ -321,7 +347,7 @@ func addMachinePoolsToObjectTree(ctx context.Context, c client.Client, workers *
 			}
 		}
 
-		machines := selectMachinesControlledBy(machinesList, mp)
+		machines := selectMachinesControlledBy(machinesList, mp, clusterv1.GroupVersion.WithKind("MachinePool").GroupKind())
 		for _, m := range machines {
 			addMachineFunc(mp, m)
 		}
@@ -417,22 +443,22 @@ func selectControlPlaneMachines(machineList *clusterv1.MachineList) []*clusterv1
 	return machines
 }
 
-func selectMachinesSetsControlledBy(machineSetList *clusterv1.MachineSetList, controller client.Object) []*clusterv1.MachineSet {
+func selectMachinesSetsControlledBy(machineSetList *clusterv1.MachineSetList, controller client.Object, controllerGK schema.GroupKind) []*clusterv1.MachineSet {
 	machineSets := []*clusterv1.MachineSet{}
 	for i := range machineSetList.Items {
 		m := &machineSetList.Items[i]
-		if util.IsControlledBy(m, controller) {
+		if util.IsControlledBy(m, controller, controllerGK) {
 			machineSets = append(machineSets, m)
 		}
 	}
 	return machineSets
 }
 
-func selectMachinesControlledBy(machineList *clusterv1.MachineList, controller client.Object) []*clusterv1.Machine {
+func selectMachinesControlledBy(machineList *clusterv1.MachineList, controller client.Object, controllerGK schema.GroupKind) []*clusterv1.Machine {
 	machines := []*clusterv1.Machine{}
 	for i := range machineList.Items {
 		m := &machineList.Items[i]
-		if util.IsControlledBy(m, controller) {
+		if util.IsControlledBy(m, controller, controllerGK) {
 			machines = append(machines, m)
 		}
 	}

cmd/clusterctl/client/tree/options.go

@@ -16,16 +16,22 @@ limitations under the License.
 
 package tree
 
+import (
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/utils/ptr"
+)
+
 // AddObjectOption define an option for the ObjectTree Add operation.
 type AddObjectOption interface {
 	ApplyToAdd(*addObjectOptions)
 }
 
 type addObjectOptions struct {
-	MetaName       string
-	GroupingObject bool
-	NoEcho         bool
-	ZOrder         int
+	GroupVersionKind *schema.GroupVersionKind
+	MetaName         string
+	GroupingObject   bool
+	NoEcho           bool
+	ZOrder           int
 }
 
 func (o *addObjectOptions) ApplyOptions(opts []AddObjectOption) *addObjectOptions {
@@ -35,6 +41,16 @@ func (o *addObjectOptions) ApplyOptions(opts []AddObjectOption) *addObjectOption
 	return o
 }
 
+// GroupVersionKind is the gvk to set on the passed in obj.
+// This option has to be used if obj is a typed object and
+// it cannot be guaranteed that gvk is set.
+type GroupVersionKind schema.GroupVersionKind
+
+// ApplyToAdd applies the given options.
+func (n GroupVersionKind) ApplyToAdd(options *addObjectOptions) {
+	options.GroupVersionKind = ptr.To(schema.GroupVersionKind(n))
+}
+
 // The ObjectMetaName option defines the meta name that should be used for the object in the presentation layer,
 // e.g. control plane for KCP.
 type ObjectMetaName string

cmd/clusterctl/client/tree/tree.go

@@ -97,6 +97,10 @@ func (od ObjectTree) Add(parent, obj client.Object, opts ...AddObjectOption) (ad
 	addOpts := &addObjectOptions{}
 	addOpts.ApplyOptions(opts)
 
+	if addOpts.GroupVersionKind != nil {
+		obj.GetObjectKind().SetGroupVersionKind(*addOpts.GroupVersionKind)
+	}
+
 	// Get a small set of conditions that will be used to determine e.g. when grouping or when an object is just an echo of
 	// its parent.
 	var objReadyV1Beta1, parentReadyV1Beta1 *clusterv1.Condition

cmd/clusterctl/client/upgrade_test.go

@@ -365,10 +365,6 @@ func fakeClientForUpgrade() *fakeClient {
 
 func fakeProvider(name string, providerType clusterctlv1.ProviderType, version, targetNamespace string) clusterctlv1.Provider {
 	return clusterctlv1.Provider{
-		TypeMeta: metav1.TypeMeta{
-			APIVersion: clusterctlv1.GroupVersion.String(),
-			Kind:       "Provider",
-		},
 		ObjectMeta: metav1.ObjectMeta{
 			Namespace: targetNamespace,
 			Name:      clusterctlv1.ManifestLabel(name, providerType),

cmd/clusterctl/internal/test/fake_objects.go

@@ -358,11 +358,12 @@ func (f *FakeControlPlane) Objs(cluster *clusterv1.Cluster) []client.Object {
 		},
 		Spec: fakecontrolplane.GenericControlPlaneSpec{
 			MachineTemplate: fakecontrolplane.GenericMachineTemplate{
-				InfrastructureRef: corev1.ObjectReference{
-					APIVersion: controlPlaneInfrastructure.APIVersion,
-					Kind:       controlPlaneInfrastructure.Kind,
-					Namespace:  controlPlaneInfrastructure.Namespace,
-					Name:       controlPlaneInfrastructure.Name,
+				Spec: fakecontrolplane.GenericMachineTemplateSpec{
+					InfrastructureRef: clusterv1.ContractVersionedObjectReference{
+						APIGroup: fakeinfrastructure.GroupVersion.Group,
+						Kind:     controlPlaneInfrastructure.Kind,
+						Name:     controlPlaneInfrastructure.Name,
+					},
 				},
 			},
 		},
@@ -1555,6 +1556,7 @@ func (f *FakeClusterClass) Objs() []client.Object {
 	}
 
 	clusterClass := clusterClassBuilder.Build()
+	clusterClass.SetGroupVersionKind(clusterv1.GroupVersion.WithKind("ClusterClass"))
 	objMap[clusterClass] = false
 
 	for o := range objMap {

cmd/clusterctl/internal/test/providers/controlplane/generic_types.go

@@ -17,13 +17,19 @@ limitations under the License.
 package controlplane
 
 import (
-	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2"
 )
 
 // GenericMachineTemplate contains a generic control plane spec.
 type GenericMachineTemplate struct {
-	InfrastructureRef corev1.ObjectReference `json:"infrastructureRef"`
+	Spec GenericMachineTemplateSpec `json:"spec"`
+}
+
+// GenericMachineTemplateSpec contains a generic control plane spec.
+type GenericMachineTemplateSpec struct {
+	InfrastructureRef clusterv1.ContractVersionedObjectReference `json:"infrastructureRef"`
 }
 
 // GenericControlPlaneSpec contains a generic control plane spec.

cmd/clusterctl/internal/test/providers/controlplane/zz_generated.deepcopy.go

@@ -1387,7 +1387,7 @@ func (r *KubeadmControlPlaneReconciler) adoptOwnedSecrets(ctx context.Context, k
 
 	for i := range secrets.Items {
 		s := secrets.Items[i]
-		if !util.IsOwnedByObject(&s, currentOwner) {
+		if !util.IsOwnedByObject(&s, currentOwner, bootstrapv1.GroupVersion.WithKind("KubeadmConfig").GroupKind()) {
 			continue
 		}
 		// avoid taking ownership of the bootstrap data secret

controlplane/kubeadm/internal/controllers/controller.go

@@ -94,7 +94,7 @@ func (r *KubeadmControlPlaneReconciler) reconcileKubeconfig(ctx context.Context,
 	}
 
 	// only do rotation on owned secrets
-	if !util.IsControlledBy(configSecret, controlPlane.KCP) {
+	if !util.IsControlledBy(configSecret, controlPlane.KCP, controlplanev1.GroupVersion.WithKind("KubeadmControlPlane").GroupKind()) {
 		return ctrl.Result{}, nil
 	}