Updates InfraMachine watch_filters

Author: theobarberbany

pkg/controllers/machinesync/machine_sync_controller.go

@@ -81,6 +81,8 @@ const (
 	mapiNamespace                  string = "openshift-machine-api"
 	capiInfraCommonFinalizerSuffix string = ".cluster.x-k8s.io"
 
+	requeueInfraProgress = 1 * time.Second
+
 	messageSuccessfullySynchronizedCAPItoMAPI = "Successfully synchronized CAPI Machine to MAPI"
 	messageSuccessfullySynchronizedMAPItoCAPI = "Successfully synchronized MAPI Machine to CAPI"
 	progressingToSynchronizeMAPItoCAPI        = "Progressing to synchronize MAPI Machine to CAPI"
@@ -134,7 +136,7 @@ type MachineSyncReconciler struct {
 	MAPINamespace string
 }
 
-// SetupWithManager sets the CoreClusterReconciler controller up with the given manager.
+// SetupWithManager sets the MachineSyncReconciler controller up with the given manager.
 func (r *MachineSyncReconciler) SetupWithManager(mgr ctrl.Manager) error {
 	infraMachine, _, err := controllers.InitInfraMachineAndInfraClusterFromProvider(r.Platform)
 	if err != nil {
@@ -161,7 +163,7 @@ func (r *MachineSyncReconciler) SetupWithManager(mgr ctrl.Manager) error {
 		).
 		Watches(
 			infraMachine,
-			handler.EnqueueRequestsFromMapFunc(util.RewriteNamespace(r.MAPINamespace)),
+			handler.EnqueueRequestsFromMapFunc(util.ResolveCAPIMachineFromInfraMachine(r.MAPINamespace)),
 			builder.WithPredicates(util.FilterNamespace(r.CAPINamespace)),
 		).
 		Complete(r); err != nil {
@@ -182,8 +184,8 @@ func (r *MachineSyncReconciler) SetupWithManager(mgr ctrl.Manager) error {
 func (r *MachineSyncReconciler) Reconcile(ctx context.Context, req reconcile.Request) (ctrl.Result, error) {
 	logger := log.FromContext(ctx, "namespace", req.Namespace, "name", req.Name)
 
-	logger.V(1).Info("Reconciling machine")
-	defer logger.V(1).Info("Finished reconciling machine")
+	logger.Info("Reconciling machine")
+	defer logger.Info("Finished reconciling machine")
 
 	var mapiMachineNotFound, capiMachineNotFound bool
 
@@ -540,13 +542,13 @@ func (r *MachineSyncReconciler) reconcileMAPIMachinetoCAPIMachine(ctx context.Co
 		BlockOwnerDeletion: ptr.To(true),
 	}})
 
-	result, syncronizationIsProgressing, err := r.createOrUpdateCAPIInfraMachine(ctx, mapiMachine, infraMachine, newCAPIInfraMachine)
+	result, synchronizationIsProgressing, err := r.createOrUpdateCAPIInfraMachine(ctx, mapiMachine, infraMachine, newCAPIInfraMachine)
 	if err != nil {
 		return result, fmt.Errorf("unable to ensure Cluster API infra machine: %w", err)
 	}
 
-	if syncronizationIsProgressing {
-		return ctrl.Result{RequeueAfter: time.Second * 1}, r.applySynchronizedConditionWithPatch(ctx, mapiMachine, corev1.ConditionUnknown,
+	if synchronizationIsProgressing {
+		return ctrl.Result{RequeueAfter: requeueInfraProgress}, r.applySynchronizedConditionWithPatch(ctx, mapiMachine, corev1.ConditionUnknown,
 			reasonProgressingToCreateCAPIInfraMachine, progressingToSynchronizeMAPItoCAPI, nil)
 	}
 
@@ -1011,7 +1013,9 @@ func (r *MachineSyncReconciler) fetchCAPIInfraResources(ctx context.Context, cap
 }
 
 //nolint:funlen,gocognit,cyclop
-func (r *MachineSyncReconciler) reconcileMAPItoCAPIMachineDeletion(ctx context.Context, mapiMachine *machinev1beta1.Machine, capiMachine *clusterv1.Machine, infraMachine client.Object) (bool, error) {
+func (r *MachineSyncReconciler) reconcileMAPItoCAPIMachineDeletion(ctx context.Context, mapiMachine *machinev1beta1.Machine, capiMachine *clusterv1.Machine, infraMachine client.Object) (shouldReqeue bool, err error) {
+	logger := log.FromContext(ctx)
+
 	if mapiMachine.DeletionTimestamp.IsZero() {
 		if capiMachine == nil || capiMachine.DeletionTimestamp.IsZero() {
 			// Neither MAPI authoritative machine nor its CAPI non-authoritative machine mirror
@@ -1029,8 +1033,6 @@ func (r *MachineSyncReconciler) reconcileMAPItoCAPIMachineDeletion(ctx context.C
 		return true, nil
 	}
 
-	logger := log.FromContext(ctx)
-
 	if capiMachine == nil && util.IsNilObject(infraMachine) {
 		logger.Info("Cluster API machine and infra machine do not exist, removing corresponding Machine API machine sync finalizer")
 		// We don't have  a capi machine or infra resouorces to clean up we can
@@ -1228,9 +1230,7 @@ func (r *MachineSyncReconciler) reconcileCAPItoMAPIMachineDeletion(ctx context.C
 
 // ensureSyncFinalizer ensures the sync finalizer is present across the mapi
 // machine, capi machine and capi infra machine.
-func (r *MachineSyncReconciler) ensureSyncFinalizer(ctx context.Context, mapiMachine *machinev1beta1.Machine, capiMachine *clusterv1.Machine, infraMachine client.Object) (bool, error) {
-	var shouldRequeue bool
-
+func (r *MachineSyncReconciler) ensureSyncFinalizer(ctx context.Context, mapiMachine *machinev1beta1.Machine, capiMachine *clusterv1.Machine, infraMachine client.Object) (shouldRequeue bool, err error) {
 	var errors []error
 
 	if mapiMachine != nil {

pkg/controllers/machinesync/machine_sync_controller_test.go

@@ -191,6 +191,7 @@ var _ = Describe("With a running MachineSync Reconciler", func() {
 
 		mgr, err = ctrl.NewManager(controllerCfg, ctrl.Options{
 			Scheme: testScheme,
+			Logger: GinkgoLogr,
 			Controller: config.Controller{
 				SkipNameValidation: ptr.To(true),
 			},

pkg/controllers/machinesync/suite_test.go

@@ -33,7 +33,7 @@ import (
 	"k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/rest"
 	"k8s.io/klog/v2"
-	"k8s.io/klog/v2/textlogger"
+	ctrl "sigs.k8s.io/controller-runtime"
 
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
@@ -64,7 +64,8 @@ func TestAPIs(t *testing.T) {
 var _ = BeforeSuite(func() {
 	klog.SetOutput(GinkgoWriter)
 
-	logf.SetLogger(textlogger.NewLogger(textlogger.NewConfig()))
+	logf.SetLogger(GinkgoLogr)
+	ctrl.SetLogger(GinkgoLogr)
 
 	By("bootstrapping test environment")
 	var err error

pkg/util/watch_filters.go

@@ -21,7 +21,9 @@ import (
 	"fmt"
 
 	"github.com/openshift/cluster-capi-operator/pkg/controllers"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/klog/v2"
+	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
@@ -37,10 +39,10 @@ const machineSetKind = "MachineSet"
 func RewriteNamespace(namespace string) func(context.Context, client.Object) []reconcile.Request {
 	return func(ctx context.Context, obj client.Object) []reconcile.Request {
 		klog.V(4).Info(
-			"reconcile triggered by object",
-			"objectType", fmt.Sprintf("%T", obj),
-			"namespace", obj.GetNamespace(),
-			"name", obj.GetName(),
+			"reconcile triggered by ",
+			"objectType: ", fmt.Sprintf("%T", obj),
+			"namespace: ", obj.GetNamespace(),
+			"name: ", obj.GetName(),
 		)
 
 		return []reconcile.Request{{
@@ -56,10 +58,10 @@ func RewriteNamespace(namespace string) func(context.Context, client.Object) []r
 func ResolveCAPIMachineSetFromInfraMachineTemplate(namespace string) func(context.Context, client.Object) []reconcile.Request {
 	return func(ctx context.Context, obj client.Object) []reconcile.Request {
 		klog.V(4).Info(
-			"reconcile triggered by object",
-			"objectType", fmt.Sprintf("%T", obj),
-			"namespace", obj.GetNamespace(),
-			"name", obj.GetName(),
+			"reconcile triggered by ",
+			"objectType: ", fmt.Sprintf("%T", obj),
+			"namespace: ", obj.GetNamespace(),
+			"name: ", obj.GetName(),
 		)
 
 		objLabels := obj.GetLabels()
@@ -79,10 +81,47 @@ func ResolveCAPIMachineSetFromInfraMachineTemplate(namespace string) func(contex
 	}
 }
 
+// ResolveCAPIMachineFromInfraMachine resolves a CAPI Machine from an InfraMachine. It takes client.Object,
+// and uses owner references to determine the owning CAPI machine. If one is found, it returns a reconcile.Request
+// for the corresponding MAPI Machine in the MAPI namespace to trigger reconciliation of the mirror MAPI Machine.
+func ResolveCAPIMachineFromInfraMachine(namespace string) func(context.Context, client.Object) []reconcile.Request {
+	return func(ctx context.Context, obj client.Object) []reconcile.Request {
+		klog.V(4).Info(
+			"reconcile triggered by ",
+			"objectType: ", fmt.Sprintf("%T", obj),
+			"namespace: ", obj.GetNamespace(),
+			"name: ", obj.GetName(),
+		)
+
+		requests := []reconcile.Request{}
+
+		for _, ref := range obj.GetOwnerReferences() {
+			gv, err := schema.ParseGroupVersion(ref.APIVersion)
+			if err != nil {
+				klog.Info("Failed to parse GroupVersion", "name", obj.GetName(), "APIVersion", ref.APIVersion)
+			}
+
+			if ref.Kind == "Machine" && gv.Group == clusterv1.GroupVersion.Group {
+				requests = append(requests, reconcile.Request{
+					NamespacedName: client.ObjectKey{Namespace: namespace, Name: ref.Name},
+				})
+			}
+		}
+
+		return requests
+	}
+}
+
 // FilterNamespace filters a client.Object request, ensuring they are in the
 // namespace provided.
 func FilterNamespace(namespace string) predicate.Predicate {
 	return predicate.NewPredicateFuncs(func(obj client.Object) bool {
+		klog.V(4).Info(
+			"reconcile triggered by ",
+			"objectType: ", fmt.Sprintf("%T", obj),
+			"namespace: ", obj.GetNamespace(),
+			"name: ", obj.GetName(),
+		)
 		// Check namespace is as expected
 		return obj.GetNamespace() == namespace
 	})