Use GetClusterFromMetadata from CAPI

Signed-off-by: Chuck Ha <[email protected]>

Author: chuckha

controllers/control_plane_init_locker_test.go

@@ -32,6 +32,42 @@ import (
 )
 
 func TestControlPlaneInitLockerAcquire(t *testing.T) {
+	tests := []struct {
+		name     string
+		getError error
+	}{
+		{
+			name:     "create succeeds",
+			getError: apierrors.NewNotFound(schema.GroupResource{Group: "", Resource: "configmaps"}, "uid1-configmap"),
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			l := &controlPlaneInitLocker{
+				log: log.ZapLogger(true),
+				configMapClient: &configMapsGetter{
+					getError: tc.getError,
+				},
+			}
+
+			cluster := &clusterv2.Cluster{
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "ns1",
+					Name:      "name1",
+					UID:       types.UID("uid1"),
+				},
+			}
+
+			acquired := l.Acquire(cluster)
+			if !acquired {
+				t.Fatal("acquired was false but it should have been true")
+			}
+		})
+	}
+}
+
+func TestControlPlaneInitLockerAcquireErrors(t *testing.T) {
 	tests := []struct {
 		name          string
 		configMap     *v1.ConfigMap
@@ -49,11 +85,6 @@ func TestControlPlaneInitLockerAcquire(t *testing.T) {
 			getError:      errors.New("get error"),
 			expectAcquire: false,
 		},
-		{
-			name:          "create succeeds",
-			getError:      apierrors.NewNotFound(schema.GroupResource{Group: "", Resource: "configmaps"}, "uid1-configmap"),
-			expectAcquire: true,
-		},
 		{
 			name:          "create fails",
 			getError:      apierrors.NewNotFound(schema.GroupResource{Group: "", Resource: "configmaps"}, "uid1-configmap"),
@@ -82,8 +113,8 @@ func TestControlPlaneInitLockerAcquire(t *testing.T) {
 			}
 
 			acquired := l.Acquire(cluster)
-			if tc.expectAcquire != acquired {
-				t.Errorf("expected %t, got %t", tc.expectAcquire, acquired)
+			if acquired {
+				t.Fatal("expected acquried to be false but it is true")
 			}
 		})
 	}

controllers/kubeadmconfig_controller.go

@@ -76,49 +76,24 @@ func (r *KubeadmConfigReconciler) Reconcile(req ctrl.Request) (ctrl.Result, erro
 		return ctrl.Result{}, nil
 	}
 
-	// Find the owner reference
-	// The cluster-api machine controller set this value.
-	var machineRef *v1.OwnerReference
-	for _, ref := range config.OwnerReferences {
-		if ref.Kind == machineKind.Kind && ref.APIVersion == machineKind.GroupVersion().String() {
-			machineRef = &ref
-			break
-		}
-	}
-	if machineRef == nil {
-		log.Info("did not find matching machine reference")
-		return ctrl.Result{}, nil
-	}
-
-	// Get the machine
-	machine := &capiv1alpha2.Machine{}
-	machineKey := client.ObjectKey{
-		Namespace: req.Namespace,
-		Name:      machineRef.Name,
-	}
-
-	if err := r.Get(ctx, machineKey, machine); err != nil {
-		log.Error(err, "failed to get machine")
+	machine, err := util.GetOwnerMachine(ctx, r.Client, config.ObjectMeta)
+	if err != nil {
+		log.Error(err, "could not get owner machine")
 		return ctrl.Result{}, err
 	}
+	if machine == nil {
+		log.Info("Waiting for Machine Controller to set OwnerRef on the KubeadmConfig")
+		return ctrl.Result{RequeueAfter: 10 * time.Second}, nil
+	}
 
 	// Ignore machines that already have bootstrap data
 	if machine.Spec.Bootstrap.Data != nil {
 		return ctrl.Result{}, nil
 	}
 
-	if machine.Labels[capiv1alpha2.MachineClusterLabelName] == "" {
-		return ctrl.Result{}, errors.New("machine has no associated cluster")
-	}
-
-	// Get the cluster
-	cluster := &capiv1alpha2.Cluster{}
-	clusterKey := client.ObjectKey{
-		Namespace: req.Namespace,
-		Name:      machine.Labels[capiv1alpha2.MachineClusterLabelName],
-	}
-	if err := r.Get(ctx, clusterKey, cluster); err != nil {
-		log.Error(err, "failed to get cluster")
+	cluster, err := util.GetClusterFromMetadata(ctx, r.Client, machine.ObjectMeta)
+	if err != nil {
+		log.Error(err, "could not get cluster by machine metadata")
 		return ctrl.Result{}, err
 	}
 

controllers/kubeadmconfig_controller_test.go

@@ -74,7 +74,7 @@ func TestBailIfKubeadmConfigStatusReady(t *testing.T) {
 	}
 }
 
-func TestBailIfNoMachineRefIsSet(t *testing.T) {
+func TestRequeueIfNoMachineRefIsSet(t *testing.T) {
 	config := newKubeadmConfig(nil, "cfg") // intentionally omitting machine
 	objects := []runtime.Object{
 		config,
@@ -99,8 +99,8 @@ func TestBailIfNoMachineRefIsSet(t *testing.T) {
 	if result.Requeue == true {
 		t.Fatal("did not expected to requeue")
 	}
-	if result.RequeueAfter != time.Duration(0) {
-		t.Fatal("did not expected to requeue after")
+	if result.RequeueAfter == time.Duration(0) {
+		t.Fatal("Expected a requeue but did not get one")
 	}
 }