Initial impl for VSphereMachine AAF changes

- Updates VMOP API dependency

Misc VMG fixes
- Use namingStrategy to calculate VM names
- Use MachineDeployment names for VMG placement label
- Includes all machinedeployments to generate node-pool -> zone
  mapping

Fixes VMG webhook validation error
- Adds cluster-name label to Af/AAF spec
- re-adds zone topology key back to anti-aff spec

Signed-off-by: Sagar Muchhal <[email protected]>

Author: srm09

controllers/vmware/virtualmachinegroup_reconciler.go

@@ -37,6 +37,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
 	vmwarev1 "sigs.k8s.io/cluster-api-provider-vsphere/apis/vmware/v1beta1"
+	infrautilv1 "sigs.k8s.io/cluster-api-provider-vsphere/pkg/util"
 	clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2"
 )
 
@@ -191,16 +192,24 @@ func (r *VirtualMachineGroupReconciler) createOrUpdateVMG(ctx context.Context, c
 		return reconcile.Result{RequeueAfter: reconciliationDelay}, nil
 	}
 
-	// Generate all the members of the VirtualMachineGroup.
-	members := make([]vmoprv1.GroupMember, 0, len(currentVSphereMachines))
-	// Sort the VSphereMachines by name for consistent ordering
-	sort.Slice(currentVSphereMachines, func(i, j int) bool {
-		return currentVSphereMachines[i].Name < currentVSphereMachines[j].Name
+	// Generate VM names according to the naming strategy set on the VSphereMachine.
+	vmNames := make([]string, 0, len(currentVSphereMachines))
+	for _, machine := range currentVSphereMachines {
+		name, err := GenerateVirtualMachineName(machine.Name, machine.Spec.NamingStrategy)
+		if err != nil {
+			return reconcile.Result{}, err
+		}
+		vmNames = append(vmNames, name)
+	}
+	// Sort the VM names alphabetically for consistent ordering
+	sort.Slice(vmNames, func(i, j int) bool {
+		return vmNames[i] < vmNames[j]
 	})
 
-	for _, vm := range currentVSphereMachines {
+	members := make([]vmoprv1.GroupMember, 0, len(currentVSphereMachines))
+	for _, name := range vmNames {
 		members = append(members, vmoprv1.GroupMember{
-			Name: vm.Name,
+			Name: name,
 			Kind: "VirtualMachine",
 		})
 	}
@@ -210,9 +219,14 @@ func (r *VirtualMachineGroupReconciler) createOrUpdateVMG(ctx context.Context, c
 		return reconcile.Result{}, errors.Errorf("Cluster Topology is not defined %s/%s",
 			cluster.Namespace, cluster.Name)
 	}
-	mds := cluster.Spec.Topology.Workers.MachineDeployments
-	mdNames := make([]string, 0, len(mds))
-	for _, md := range mds {
+	machineDeployments := &clusterv1.MachineDeploymentList{}
+	if err := r.Client.List(ctx, machineDeployments,
+		client.InNamespace(cluster.Namespace),
+		client.MatchingLabels{clusterv1.ClusterNameLabel: cluster.Name}); err != nil {
+		return reconcile.Result{}, err
+	}
+	mdNames := []string{}
+	for _, md := range machineDeployments.Items {
 		mdNames = append(mdNames, md.Name)
 	}
 
@@ -401,7 +415,7 @@ func getCurrentVSphereMachines(ctx context.Context, kubeClient client.Client, cl
 	return result, nil
 }
 
-// GenerateVMGPlacementLabels returns labels per MachineDeployment which contain zone info for placed VMs for day-2 operationss
+// GenerateVMGPlacementLabels returns labels per MachineDeployment which contain zone info for placed VMs for day-2 operations.
 func GenerateVMGPlacementLabels(ctx context.Context, vmg *vmoprv1.VirtualMachineGroup, machineDeployments []string) (map[string]string, error) {
 	log := ctrl.LoggerFrom(ctx)
 	labels := make(map[string]string)
@@ -428,6 +442,7 @@ func GenerateVMGPlacementLabels(ctx context.Context, vmg *vmoprv1.VirtualMachine
 			}
 
 			// Check if VM belongs to a Machine Deployment by name (e.g. cluster-1-np-1-vm-xxx contains np-1)
+			// TODO: Establish membership via the machine deployment name label
 			if strings.Contains(member.Name, md) {
 				// Get the VM placement information by member status.
 				if member.Placement == nil {
@@ -448,3 +463,20 @@ func GenerateVMGPlacementLabels(ctx context.Context, vmg *vmoprv1.VirtualMachine
 
 	return labels, nil
 }
+
+// TODO: de-dup this logic with vmopmachine.go
+// GenerateVirtualMachineName generates the name of a VirtualMachine based on the naming strategy.
+func GenerateVirtualMachineName(machineName string, namingStrategy *vmwarev1.VirtualMachineNamingStrategy) (string, error) {
+	// Per default the name of the VirtualMachine should be equal to the Machine name (this is the same as "{{ .machine.name }}")
+	if namingStrategy == nil || namingStrategy.Template == nil {
+		// Note: No need to trim to max length in this case as valid Machine names will also be valid VirtualMachine names.
+		return machineName, nil
+	}
+
+	name, err := infrautilv1.GenerateMachineNameFromTemplate(machineName, namingStrategy.Template)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to generate name for VirtualMachine")
+	}
+
+	return name, nil
+}

go.mod

@@ -10,7 +10,7 @@ require (
 	github.com/vmware-tanzu/net-operator-api v0.0.0-20240326163340-1f32d6bf7f9d
 	github.com/vmware-tanzu/nsx-operator/pkg/apis v0.0.0-20241112044858-9da8637c1b0d
 	// The version of vm-operator should be kept in sync with the manifests at: config/deployments/integration-tests
-	github.com/vmware-tanzu/vm-operator/api v1.9.1-0.20250908141901-a9e1dfbc0045
+	github.com/vmware-tanzu/vm-operator/api v1.9.1-0.20251007154704-e2d6e85d9ec7
 	github.com/vmware-tanzu/vm-operator/external/ncp v0.0.0-20240404200847-de75746a9505
 	github.com/vmware/govmomi v0.51.0
 )

go.sum

@@ -221,8 +221,8 @@ github.com/vmware-tanzu/net-operator-api v0.0.0-20240326163340-1f32d6bf7f9d h1:c
 github.com/vmware-tanzu/net-operator-api v0.0.0-20240326163340-1f32d6bf7f9d/go.mod h1:JbFOh22iDsT5BowJe0GgpMI5e2/S7cWaJlv9LdURVQM=
 github.com/vmware-tanzu/nsx-operator/pkg/apis v0.0.0-20241112044858-9da8637c1b0d h1:z9lrzKVtNlujduv9BilzPxuge/LE2F0N1ms3TP4JZvw=
 github.com/vmware-tanzu/nsx-operator/pkg/apis v0.0.0-20241112044858-9da8637c1b0d/go.mod h1:Q4JzNkNMvjo7pXtlB5/R3oME4Nhah7fAObWgghVmtxk=
-github.com/vmware-tanzu/vm-operator/api v1.9.1-0.20250908141901-a9e1dfbc0045 h1:zME8crazIAWVJGboJpSLl+qcRYQ8yA6hPQojz28gY5M=
-github.com/vmware-tanzu/vm-operator/api v1.9.1-0.20250908141901-a9e1dfbc0045/go.mod h1:hkc/QZCSHcosWWMPS6VWWR12WenZcNE3BaTJ/8A8sNE=
+github.com/vmware-tanzu/vm-operator/api v1.9.1-0.20251007154704-e2d6e85d9ec7 h1:VlnaiDKI1H1buwBOgL8R3HRB3EQNN96xMdz25vE5FUo=
+github.com/vmware-tanzu/vm-operator/api v1.9.1-0.20251007154704-e2d6e85d9ec7/go.mod h1:nWTPpxfe4gHuuYuFcrs86+NMxfkqPk3a3IlvI8TCWak=
 github.com/vmware-tanzu/vm-operator/external/ncp v0.0.0-20240404200847-de75746a9505 h1:y4wXx1FUFqqSgJ/xUOEM1DLS2Uu0KaeLADWpzpioGTU=
 github.com/vmware-tanzu/vm-operator/external/ncp v0.0.0-20240404200847-de75746a9505/go.mod h1:5rqRJ9zGR+KnKbkGx373WgN8xJpvAj99kHnfoDYRO5I=
 github.com/vmware/govmomi v0.51.0 h1:n3RLS9aw/irTOKbiIyJzAb6rOat4YOVv/uDoRsNTSQI=

pkg/services/vmoperator/constants.go

@@ -18,8 +18,6 @@ limitations under the License.
 package vmoperator
 
 const (
-	kubeTopologyZoneLabelKey = "topology.kubernetes.io/zone"
-
 	// ControlPlaneVMClusterModuleGroupName is the name used for the control plane Cluster Module.
 	ControlPlaneVMClusterModuleGroupName = "control-plane-group"
 	// ClusterModuleNameAnnotationKey is key for the Cluster Module annotation.

pkg/services/vmoperator/vmopmachine.go

@@ -41,6 +41,7 @@ import (
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-vsphere/apis/v1beta1"
 	vmwarev1 "sigs.k8s.io/cluster-api-provider-vsphere/apis/vmware/v1beta1"
+	"sigs.k8s.io/cluster-api-provider-vsphere/feature"
 	capvcontext "sigs.k8s.io/cluster-api-provider-vsphere/pkg/context"
 	"sigs.k8s.io/cluster-api-provider-vsphere/pkg/context/vmware"
 	infrautilv1 "sigs.k8s.io/cluster-api-provider-vsphere/pkg/util"
@@ -163,6 +164,15 @@ func (v *VmopMachineService) SyncFailureReason(_ context.Context, machineCtx cap
 	return supervisorMachineCtx.VSphereMachine.Status.FailureReason != nil || supervisorMachineCtx.VSphereMachine.Status.FailureMessage != nil, nil
 }
 
+type affinityInfo struct {
+	affinitySpec  *vmoprv1.AffinitySpec
+	vmGroupName   string
+	failureDomain *string
+
+	// TODO: is this needed for the single zone case?
+	// zones []topologyv1.Zone
+}
+
 // ReconcileNormal reconciles create and update events for VM Operator VMs.
 func (v *VmopMachineService) ReconcileNormal(ctx context.Context, machineCtx capvcontext.MachineContext) (bool, error) {
 	log := ctrl.LoggerFrom(ctx)
@@ -171,10 +181,6 @@ func (v *VmopMachineService) ReconcileNormal(ctx context.Context, machineCtx cap
 		return false, errors.New("received unexpected SupervisorMachineContext type")
 	}
 
-	if supervisorMachineCtx.Machine.Spec.FailureDomain != "" {
-		supervisorMachineCtx.VSphereMachine.Spec.FailureDomain = ptr.To(supervisorMachineCtx.Machine.Spec.FailureDomain)
-	}
-
 	// If debug logging is enabled, report the number of vms in the cluster before and after the reconcile
 	if log.V(5).Enabled() {
 		vms, err := v.getVirtualMachinesInCluster(ctx, supervisorMachineCtx)
@@ -188,6 +194,112 @@ func (v *VmopMachineService) ReconcileNormal(ctx context.Context, machineCtx cap
 	// Set the VM state. Will get reset throughout the reconcile
 	supervisorMachineCtx.VSphereMachine.Status.VMStatus = vmwarev1.VirtualMachineStatePending
 
+	var affInfo affinityInfo
+	if feature.Gates.Enabled(feature.NodeAutoPlacement) &&
+		!infrautilv1.IsControlPlaneMachine(machineCtx.GetVSphereMachine()) {
+		// Check for the presence of a VirtualMachineGroup with the name and namespace same as the name of the Cluster
+		vmOperatorVMGroup := &vmoprv1.VirtualMachineGroup{}
+		key := client.ObjectKey{
+			Namespace: supervisorMachineCtx.Cluster.Namespace,
+			Name:      supervisorMachineCtx.Cluster.Name,
+		}
+		err := v.Client.Get(ctx, key, vmOperatorVMGroup)
+		if err != nil {
+			if !apierrors.IsNotFound(err) {
+				return false, err
+			}
+			if apierrors.IsNotFound(err) {
+				log.V(4).Info("VirtualMachineGroup not found, requeueing")
+				return true, nil
+			}
+		}
+
+		// Check if the current machine is a member of the boot order
+		// in the VirtualMachineGroup.
+		if !v.checkVirtualMachineGroupMembership(vmOperatorVMGroup, supervisorMachineCtx) {
+			log.V(4).Info("Waiting for VirtualMachineGroup membership, requeueing")
+			return true, nil
+		}
+
+		// Initialize the affinityInfo for the VM
+		affInfo = affinityInfo{
+			vmGroupName: vmOperatorVMGroup.Name,
+		}
+
+		// Check the presence of the node-pool label on the VirtualMachineGroup object
+		nodePool := supervisorMachineCtx.Machine.Labels[clusterv1.MachineDeploymentNameLabel]
+		if zone, ok := vmOperatorVMGroup.Labels[fmt.Sprintf("zone.cluster.x-k8s.io/%s", nodePool)]; ok && zone != "" {
+			affInfo.failureDomain = ptr.To(zone)
+		}
+
+		// Fetch machine deployments without explicit failureDomain specified
+		// to use when setting the anti-affinity rules
+		machineDeployments := &clusterv1.MachineDeploymentList{}
+		if err := v.Client.List(ctx, machineDeployments,
+			client.InNamespace(supervisorMachineCtx.Cluster.Namespace),
+			client.MatchingLabels{clusterv1.ClusterNameLabel: supervisorMachineCtx.Cluster.Name}); err != nil {
+			return false, err
+		}
+		mdNames := []string{}
+		for _, machineDeployment := range machineDeployments.Items {
+			// Not adding node pool with explicit failureDomain specified to propose anti-affinity behavior
+			// among node pools with automatic placement only.
+			if machineDeployment.Spec.Template.Spec.FailureDomain == "" && machineDeployment.Name != nodePool {
+				mdNames = append(mdNames, machineDeployment.Name)
+			}
+		}
+		// turn to v4 log
+		log.V(2).Info("Gathered anti-affine MDs", "mdNames", mdNames)
+
+		affInfo.affinitySpec = &vmoprv1.AffinitySpec{
+			VMAffinity: &vmoprv1.VMAffinitySpec{
+				RequiredDuringSchedulingPreferredDuringExecution: []vmoprv1.VMAffinityTerm{
+					{
+						LabelSelector: &metav1.LabelSelector{
+							MatchLabels: map[string]string{
+								clusterv1.MachineDeploymentNameLabel: nodePool,
+								clusterv1.ClusterNameLabel:           supervisorMachineCtx.Cluster.Name,
+							},
+						},
+						TopologyKey: corev1.LabelTopologyZone,
+					},
+				},
+			},
+			VMAntiAffinity: &vmoprv1.VMAntiAffinitySpec{
+				PreferredDuringSchedulingPreferredDuringExecution: []vmoprv1.VMAffinityTerm{
+					{
+						LabelSelector: &metav1.LabelSelector{
+							MatchLabels: map[string]string{
+								clusterv1.MachineDeploymentNameLabel: nodePool,
+								clusterv1.ClusterNameLabel:           supervisorMachineCtx.Cluster.Name,
+							},
+						},
+						TopologyKey: corev1.LabelHostname,
+					},
+					{
+						LabelSelector: &metav1.LabelSelector{
+							MatchLabels: map[string]string{
+								clusterv1.ClusterNameLabel: supervisorMachineCtx.Cluster.Name,
+							},
+							MatchExpressions: []metav1.LabelSelectorRequirement{
+								{
+									Key:      clusterv1.MachineDeploymentNameLabel,
+									Operator: metav1.LabelSelectorOpIn,
+									Values:   mdNames,
+								},
+							},
+						},
+						TopologyKey: corev1.LabelTopologyZone,
+					},
+				},
+			},
+		}
+	}
+
+	if supervisorMachineCtx.Machine.Spec.FailureDomain != "" {
+		supervisorMachineCtx.VSphereMachine.Spec.FailureDomain = ptr.To(supervisorMachineCtx.Machine.Spec.FailureDomain)
+	}
+
 	// Check for the presence of an existing object
 	vmOperatorVM := &vmoprv1.VirtualMachine{}
 	key, err := virtualMachineObjectKey(supervisorMachineCtx.Machine.Name, supervisorMachineCtx.Machine.Namespace, supervisorMachineCtx.VSphereMachine.Spec.NamingStrategy)
@@ -208,7 +320,7 @@ func (v *VmopMachineService) ReconcileNormal(ctx context.Context, machineCtx cap
 	}
 
 	// Reconcile the VM Operator VirtualMachine.
-	if err := v.reconcileVMOperatorVM(ctx, supervisorMachineCtx, vmOperatorVM); err != nil {
+	if err := v.reconcileVMOperatorVM(ctx, supervisorMachineCtx, vmOperatorVM, &affInfo); err != nil {
 		v1beta1conditions.MarkFalse(supervisorMachineCtx.VSphereMachine, infrav1.VMProvisionedCondition, vmwarev1.VMCreationFailedReason, clusterv1beta1.ConditionSeverityWarning,
 			"failed to create or update VirtualMachine: %v", err)
 		v1beta2conditions.Set(supervisorMachineCtx.VSphereMachine, metav1.Condition{
@@ -378,7 +490,7 @@ func (v *VmopMachineService) GetHostInfo(ctx context.Context, machineCtx capvcon
 	return vmOperatorVM.Status.Host, nil
 }
 
-func (v *VmopMachineService) reconcileVMOperatorVM(ctx context.Context, supervisorMachineCtx *vmware.SupervisorMachineContext, vmOperatorVM *vmoprv1.VirtualMachine) error {
+func (v *VmopMachineService) reconcileVMOperatorVM(ctx context.Context, supervisorMachineCtx *vmware.SupervisorMachineContext, vmOperatorVM *vmoprv1.VirtualMachine, affinityInfo *affinityInfo) error {
 	// All Machine resources should define the version of Kubernetes to use.
 	if supervisorMachineCtx.Machine.Spec.Version == "" {
 		return errors.Errorf(
@@ -472,7 +584,7 @@ func (v *VmopMachineService) reconcileVMOperatorVM(ctx context.Context, supervis
 		}
 
 		// Assign the VM's labels.
-		vmOperatorVM.Labels = getVMLabels(supervisorMachineCtx, vmOperatorVM.Labels)
+		vmOperatorVM.Labels = getVMLabels(supervisorMachineCtx, vmOperatorVM.Labels, affinityInfo)
 
 		addResourcePolicyAnnotations(supervisorMachineCtx, vmOperatorVM)
 
@@ -494,6 +606,15 @@ func (v *VmopMachineService) reconcileVMOperatorVM(ctx context.Context, supervis
 			vmOperatorVM = typedModified
 		}
 
+		if affinityInfo != nil && affinityInfo.affinitySpec != nil {
+			if vmOperatorVM.Spec.Affinity == nil {
+				vmOperatorVM.Spec.Affinity = affinityInfo.affinitySpec
+			}
+			if vmOperatorVM.Spec.GroupName == "" {
+				vmOperatorVM.Spec.GroupName = affinityInfo.vmGroupName
+			}
+		}
+
 		// Make sure the VSphereMachine owns the VM Operator VirtualMachine.
 		if err := ctrlutil.SetControllerReference(supervisorMachineCtx.VSphereMachine, vmOperatorVM, v.Client.Scheme()); err != nil {
 			return errors.Wrapf(err, "failed to mark %s %s/%s as owner of %s %s/%s",
@@ -735,7 +856,7 @@ func (v *VmopMachineService) addVolumes(ctx context.Context, supervisorMachineCt
 
 		if zone := supervisorMachineCtx.VSphereMachine.Spec.FailureDomain; zonal && zone != nil {
 			topology := []map[string]string{
-				{kubeTopologyZoneLabelKey: *zone},
+				{corev1.LabelTopologyZone: *zone},
 			}
 			b, err := json.Marshal(topology)
 			if err != nil {
@@ -777,7 +898,7 @@ func (v *VmopMachineService) addVolumes(ctx context.Context, supervisorMachineCt
 }
 
 // getVMLabels returns the labels applied to a VirtualMachine.
-func getVMLabels(supervisorMachineCtx *vmware.SupervisorMachineContext, vmLabels map[string]string) map[string]string {
+func getVMLabels(supervisorMachineCtx *vmware.SupervisorMachineContext, vmLabels map[string]string, affinityInfo *affinityInfo) map[string]string {
 	if vmLabels == nil {
 		vmLabels = map[string]string{}
 	}
@@ -791,7 +912,11 @@ func getVMLabels(supervisorMachineCtx *vmware.SupervisorMachineContext, vmLabels
 
 	// Get the labels that determine the VM's placement inside of a stretched
 	// cluster.
-	topologyLabels := getTopologyLabels(supervisorMachineCtx)
+	var failureDomain *string
+	if affinityInfo != nil && affinityInfo.failureDomain != nil {
+		failureDomain = affinityInfo.failureDomain
+	}
+	topologyLabels := getTopologyLabels(supervisorMachineCtx, failureDomain)
 	for k, v := range topologyLabels {
 		vmLabels[k] = v
 	}
@@ -800,6 +925,9 @@ func getVMLabels(supervisorMachineCtx *vmware.SupervisorMachineContext, vmLabels
 	// resources associated with the target cluster.
 	vmLabels[clusterv1.ClusterNameLabel] = supervisorMachineCtx.GetClusterContext().Cluster.Name
 
+	// Ensure the VM has the machine deployment name label
+	vmLabels[clusterv1.MachineDeploymentNameLabel] = supervisorMachineCtx.Machine.Labels[clusterv1.MachineDeploymentNameLabel]
+
 	return vmLabels
 }
 
@@ -809,10 +937,16 @@ func getVMLabels(supervisorMachineCtx *vmware.SupervisorMachineContext, vmLabels
 //
 //	and thus the code is optimized as such. However, in the future
 //	this function may return a more diverse topology.
-func getTopologyLabels(supervisorMachineCtx *vmware.SupervisorMachineContext) map[string]string {
+func getTopologyLabels(supervisorMachineCtx *vmware.SupervisorMachineContext, failureDomain *string) map[string]string {
+	// TODO: Make it so that we always set the zone label, might require enquiring the zones present (when unset)
 	if fd := supervisorMachineCtx.VSphereMachine.Spec.FailureDomain; fd != nil && *fd != "" {
 		return map[string]string{
-			kubeTopologyZoneLabelKey: *fd,
+			corev1.LabelTopologyZone: *fd,
+		}
+	}
+	if failureDomain != nil && *failureDomain != "" {
+		return map[string]string{
+			corev1.LabelTopologyZone: *failureDomain,
 		}
 	}
 	return nil
@@ -823,3 +957,16 @@ func getTopologyLabels(supervisorMachineCtx *vmware.SupervisorMachineContext) ma
 func getMachineDeploymentNameForCluster(cluster *clusterv1.Cluster) string {
 	return fmt.Sprintf("%s-workers-0", cluster.Name)
 }
+
+// checkVirtualMachineGroupMembership checks if the machine is in the first boot order group
+// and performs logic if a match is found.
+func (v *VmopMachineService) checkVirtualMachineGroupMembership(vmOperatorVMGroup *vmoprv1.VirtualMachineGroup, supervisorMachineCtx *vmware.SupervisorMachineContext) bool {
+	if len(vmOperatorVMGroup.Spec.BootOrder) > 0 {
+		for _, member := range vmOperatorVMGroup.Spec.BootOrder[0].Members {
+			if member.Name == supervisorMachineCtx.Machine.Name {
+				return true
+			}
+		}
+	}
+	return false
+}