KCP: Implement CanUpdateMachine

Author: sbueringer

controlplane/kubeadm/controllers/alias.go

@@ -27,12 +27,14 @@ import (
 
 	"sigs.k8s.io/cluster-api/controllers/clustercache"
 	kubeadmcontrolplanecontrollers "sigs.k8s.io/cluster-api/controlplane/kubeadm/internal/controllers"
+	runtimeclient "sigs.k8s.io/cluster-api/exp/runtime/client"
 )
 
 // KubeadmControlPlaneReconciler reconciles a KubeadmControlPlane object.
 type KubeadmControlPlaneReconciler struct {
 	Client              client.Client
 	SecretCachingClient client.Client
+	RuntimeClient       runtimeclient.Client
 	ClusterCache        clustercache.ClusterCache
 
 	EtcdDialTimeout time.Duration
@@ -50,6 +52,7 @@ func (r *KubeadmControlPlaneReconciler) SetupWithManager(ctx context.Context, mg
 	return (&kubeadmcontrolplanecontrollers.KubeadmControlPlaneReconciler{
 		Client:                      r.Client,
 		SecretCachingClient:         r.SecretCachingClient,
+		RuntimeClient:               r.RuntimeClient,
 		ClusterCache:                r.ClusterCache,
 		EtcdDialTimeout:             r.EtcdDialTimeout,
 		EtcdCallTimeout:             r.EtcdCallTimeout,

controlplane/kubeadm/internal/controllers/controller.go

@@ -46,6 +46,7 @@ import (
 	clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2"
 	"sigs.k8s.io/cluster-api/controllers/clustercache"
 	"sigs.k8s.io/cluster-api/controlplane/kubeadm/internal"
+	runtimeclient "sigs.k8s.io/cluster-api/exp/runtime/client"
 	"sigs.k8s.io/cluster-api/feature"
 	"sigs.k8s.io/cluster-api/internal/contract"
 	"sigs.k8s.io/cluster-api/internal/util/ssa"
@@ -80,6 +81,7 @@ const (
 type KubeadmControlPlaneReconciler struct {
 	Client              client.Client
 	SecretCachingClient client.Client
+	RuntimeClient       runtimeclient.Client
 	controller          controller.Controller
 	recorder            record.EventRecorder
 	ClusterCache        clustercache.ClusterCache
@@ -115,6 +117,9 @@ func (r *KubeadmControlPlaneReconciler) SetupWithManager(ctx context.Context, mg
 			"EtcdDialTimeout and EtcdCallTimeout must not be 0 and " +
 			"RemoteConditionsGracePeriod must not be < 2m")
 	}
+	if feature.Gates.Enabled(feature.InPlaceUpdates) && r.RuntimeClient == nil {
+		return errors.New("RuntimeClient must not be nil when InPlaceUpdates feature gate is enabled")
+	}
 
 	predicateLog := ctrl.LoggerFrom(ctx).WithValues("controller", "kubeadmcontrolplane")
 	c, err := ctrl.NewControllerManagedBy(mgr).
@@ -814,7 +819,8 @@ func (r *KubeadmControlPlaneReconciler) syncMachines(ctx context.Context, contro
 		if err != nil {
 			return errors.Wrapf(err, "failed to update Machine: %s", klog.KObj(m))
 		}
-		// Note: Ensure ControlPlane has the latest version of the Machine.
+		// Note: Ensure ControlPlane has the latest version of the Machine. This is required because
+		//       e.g. the in-place update code that is called later has to use the latest version of the Machine.
 		controlPlane.Machines[machineName] = updatedMachine
 		if _, ok := controlPlane.MachinesNotUpToDate[machineName]; ok {
 			controlPlane.MachinesNotUpToDate[machineName] = updatedMachine

controlplane/kubeadm/internal/controllers/inplace.go

@@ -19,6 +19,7 @@ package controllers
 import (
 	"context"
 
+	"github.com/pkg/errors"
 	ctrl "sigs.k8s.io/controller-runtime"
 
 	clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2"
@@ -35,6 +36,26 @@ func (r *KubeadmControlPlaneReconciler) tryInPlaceUpdate(
 		return r.overrideTryInPlaceUpdateFunc(ctx, controlPlane, machineToInPlaceUpdate, machineUpToDateResult)
 	}
 
-	// Always fallback to scale down until in-place is implemented.
+	// Run preflight checks to ensure that the control plane is stable before proceeding with in-place update operation.
+	if resultForAllMachines := r.preflightChecks(ctx, controlPlane); !resultForAllMachines.IsZero() {
+		// We should not block a scale down of an unhealthy Machine that would work.
+		if result := r.preflightChecks(ctx, controlPlane, machineToInPlaceUpdate); result.IsZero() {
+			// Fallback to scale down.
+			return true, ctrl.Result{}, nil
+		}
+
+		return false, resultForAllMachines, nil
+	}
+
+	canUpdate, err := r.canUpdateMachine(ctx, machineToInPlaceUpdate, machineUpToDateResult)
+	if err != nil {
+		return false, ctrl.Result{}, errors.Wrapf(err, "failed to determine if Machine %s can be updated in-place", machineToInPlaceUpdate.Name)
+	}
+
+	if !canUpdate {
+		return true, ctrl.Result{}, nil
+	}
+
+	// Always fallback to scale down until triggering in-place updates is implemented.
 	return true, ctrl.Result{}, nil
 }