Remove NodeVersion field

cloud/scope/managedcontrolplane.go

@@ -30,6 +30,7 @@ import (
 	"github.com/pkg/errors"
 	infrav1exp "sigs.k8s.io/cluster-api-provider-gcp/exp/api/v1beta1"
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
+	clusterv1exp "sigs.k8s.io/cluster-api/exp/api/v1beta1"
 	"sigs.k8s.io/cluster-api/util/patch"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
@@ -125,7 +126,8 @@ type ManagedControlPlaneScope struct {
 	credentialsClient      *credentials.IamCredentialsClient
 	credential             *Credential
 
-	AllNodePools []infrav1exp.GCPManagedMachinePool
+	AllMachinePools 	   []clusterv1exp.MachinePool
+	AllManagedMachinePools []infrav1exp.GCPManagedMachinePool
 }
 
 // PatchObject persists the managed control plane configuration and status.
@@ -174,21 +176,29 @@ func (s *ManagedControlPlaneScope) GetCredential() *Credential {
 }
 
 // GetAllNodePools gets all node pools for the control plane.
-func (s *ManagedControlPlaneScope) GetAllNodePools(ctx context.Context) ([]infrav1exp.GCPManagedMachinePool, error) {
-	if s.AllNodePools == nil {
+func (s *ManagedControlPlaneScope) GetAllNodePools(ctx context.Context) ([]infrav1exp.GCPManagedMachinePool, []clusterv1exp.MachinePool, error) {
+	if s.AllManagedMachinePools == nil || len(s.AllManagedMachinePools) == 0 {
 		opt1 := client.InNamespace(s.GCPManagedControlPlane.Namespace)
 		opt2 := client.MatchingLabels(map[string]string{
 			clusterv1.ClusterLabelName: s.Cluster.Name,
 		})
 
-		machinePoolList := &infrav1exp.GCPManagedMachinePoolList{}
+		machinePoolList := &clusterv1exp.MachinePoolList{}
 		if err := s.client.List(ctx, machinePoolList, opt1, opt2); err != nil {
-			return nil, err
+			return nil, nil, err
 		}
-		s.AllNodePools = machinePoolList.Items
+		managedMachinePoolList := &infrav1exp.GCPManagedMachinePoolList{}
+		if err := s.client.List(ctx, managedMachinePoolList, opt1, opt2); err != nil {
+			return nil, nil, err
+		}
+		if len(machinePoolList.Items) != len(managedMachinePoolList.Items) {
+			return nil, nil, fmt.Errorf("machinePoolList length (%d) != managedMachinePoolList length (%d)", len(machinePoolList.Items), len(managedMachinePoolList.Items))
+		}
+		s.AllMachinePools = machinePoolList.Items
+		s.AllManagedMachinePools = managedMachinePoolList.Items
 	}
 
-	return s.AllNodePools, nil
+	return s.AllManagedMachinePools, s.AllMachinePools, nil
 }
 
 func parseLocation(location string) string {

cloud/scope/managedmachinepool.go

@@ -30,6 +30,7 @@ import (
 	"github.com/pkg/errors"
 	infrav1exp "sigs.k8s.io/cluster-api-provider-gcp/exp/api/v1beta1"
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
+	clusterv1exp "sigs.k8s.io/cluster-api/exp/api/v1beta1"
 	"sigs.k8s.io/cluster-api/util/patch"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
@@ -40,6 +41,7 @@ type ManagedMachinePoolScopeParams struct {
 	InstanceGroupManagersClient *compute.InstanceGroupManagersClient
 	Client                      client.Client
 	Cluster                     *clusterv1.Cluster
+	MachinePool                 *clusterv1exp.MachinePool
 	GCPManagedCluster           *infrav1exp.GCPManagedCluster
 	GCPManagedControlPlane      *infrav1exp.GCPManagedControlPlane
 	GCPManagedMachinePool       *infrav1exp.GCPManagedMachinePool
@@ -51,6 +53,9 @@ func NewManagedMachinePoolScope(ctx context.Context, params ManagedMachinePoolSc
 	if params.Cluster == nil {
 		return nil, errors.New("failed to generate new scope from nil Cluster")
 	}
+	if params.MachinePool == nil {
+		return nil, errors.New("failed to generate new scope from nil MachinePool")
+	}
 	if params.GCPManagedCluster == nil {
 		return nil, errors.New("failed to generate new scope from nil GCPManagedCluster")
 	}
@@ -111,6 +116,7 @@ type ManagedMachinePoolScope struct {
 	patchHelper *patch.Helper
 
 	Cluster                *clusterv1.Cluster
+	MachinePool            *clusterv1exp.MachinePool
 	GCPManagedCluster      *infrav1exp.GCPManagedCluster
 	GCPManagedControlPlane *infrav1exp.GCPManagedControlPlane
 	GCPManagedMachinePool  *infrav1exp.GCPManagedMachinePool
@@ -153,6 +159,11 @@ func (s *ManagedMachinePoolScope) InstanceGroupManagersClient() *compute.Instanc
 	return s.migClient
 }
 
+// NodePoolVersion returns the k8s version of the node pool.
+func (s *ManagedMachinePoolScope) NodePoolVersion() *string {
+	return s.MachinePool.Spec.Template.Spec.Version
+}
+
 // ParseInstanceGroupURL parses an instance group URL.
 func ParseInstanceGroupURL(url string) (project string, zone string, mig string) {
 	parts := strings.Split(url, "/")
@@ -163,7 +174,7 @@ func ParseInstanceGroupURL(url string) (project string, zone string, mig string)
 }
 
 // ConvertToSdkNodePool convertsSetReplicas a node pool to format that is used by GCP SDK.
-func ConvertToSdkNodePool(nodePool infrav1exp.GCPManagedMachinePool) *containerpb.NodePool {
+func ConvertToSdkNodePool(nodePool infrav1exp.GCPManagedMachinePool, machinePool clusterv1exp.MachinePool) *containerpb.NodePool {
 	nodePoolName := nodePool.Spec.NodePoolName
 	if len(nodePoolName) == 0 {
 		nodePoolName = nodePool.Name
@@ -177,17 +188,17 @@ func ConvertToSdkNodePool(nodePool infrav1exp.GCPManagedMachinePool) *containerp
 			Metadata: nodePool.Spec.AdditionalLabels,
 		},
 	}
-	if nodePool.Spec.NodeVersion != nil {
-		sdkNodePool.Version = *nodePool.Spec.NodeVersion
+	if machinePool.Spec.Template.Spec.Version != nil {
+		sdkNodePool.Version = *machinePool.Spec.Template.Spec.Version
 	}
 	return &sdkNodePool
 }
 
 // ConvertToSdkNodePools converts node pools to format that is used by GCP SDK.
-func ConvertToSdkNodePools(nodePools []infrav1exp.GCPManagedMachinePool) []*containerpb.NodePool {
+func ConvertToSdkNodePools(nodePools []infrav1exp.GCPManagedMachinePool, machinePools []clusterv1exp.MachinePool) []*containerpb.NodePool {
 	res := []*containerpb.NodePool{}
-	for _, nodePool := range nodePools {
-		res = append(res, ConvertToSdkNodePool(nodePool))
+	for i := range nodePools {
+		res = append(res, ConvertToSdkNodePool(nodePools[i], machinePools[i]))
 	}
 	return res
 }

cloud/services/container/clusters/reconcile.go

@@ -49,7 +49,7 @@ func (s *Service) Reconcile(ctx context.Context) (ctrl.Result, error) {
 		log.Info("Cluster not found, creating")
 		s.scope.GCPManagedControlPlane.Status.Ready = false
 
-		nodePools, err := s.scope.GetAllNodePools(ctx)
+		nodePools, _, err := s.scope.GetAllNodePools(ctx)
 		if err != nil {
 			conditions.MarkFalse(s.scope.ConditionSetter(), clusterv1.ReadyCondition, infrav1exp.GKEControlPlaneReconciliationFailedReason, clusterv1.ConditionSeverityError, err.Error())
 			conditions.MarkFalse(s.scope.ConditionSetter(), infrav1exp.GKEControlPlaneReadyCondition, infrav1exp.GKEControlPlaneReconciliationFailedReason, clusterv1.ConditionSeverityError, err.Error())
@@ -215,14 +215,14 @@ func (s *Service) describeCluster(ctx context.Context) (*containerpb.Cluster, er
 func (s *Service) createCluster(ctx context.Context) error {
 	log := log.FromContext(ctx)
 
-	nodePools, _ := s.scope.GetAllNodePools(ctx)
+	nodePools, machinePools, _ := s.scope.GetAllNodePools(ctx)
 	cluster := &containerpb.Cluster{
 		Name:    s.scope.GCPManagedControlPlane.Spec.ClusterName,
 		Network: *s.scope.GCPManagedCluster.Spec.Network.Name,
 		Autopilot: &containerpb.Autopilot{
 			Enabled: false,
 		},
-		NodePools: scope.ConvertToSdkNodePools(nodePools),
+		NodePools: scope.ConvertToSdkNodePools(nodePools, machinePools),
 		ReleaseChannel: &containerpb.ReleaseChannel{
 			Channel: convertToSdkReleaseChannel(s.scope.GCPManagedControlPlane.Spec.ReleaseChannel),
 		},

cloud/services/container/nodepools/reconcile.go

@@ -246,7 +246,7 @@ func (s *Service) getInstances(ctx context.Context, nodePool *containerpb.NodePo
 
 func (s *Service) createNodePool(ctx context.Context) error {
 	createNodePoolRequest := &containerpb.CreateNodePoolRequest{
-		NodePool: scope.ConvertToSdkNodePool(*s.scope.GCPManagedMachinePool),
+		NodePool: scope.ConvertToSdkNodePool(*s.scope.GCPManagedMachinePool, *s.scope.MachinePool),
 		Parent:   s.scope.NodePoolLocation(),
 	}
 	_, err := s.scope.ManagedMachinePoolClient().CreateNodePool(ctx, createNodePoolRequest)
@@ -293,9 +293,9 @@ func (s *Service) checkDiffAndPrepareUpdateVersionOrImage(existingNodePool *cont
 		Name: s.scope.NodePoolFullName(),
 	}
 	// Node version
-	if s.scope.GCPManagedMachinePool.Spec.NodeVersion != nil && *s.scope.GCPManagedMachinePool.Spec.NodeVersion != existingNodePool.Version {
+	if s.scope.NodePoolVersion() != nil && *s.scope.NodePoolVersion() != existingNodePool.Version {
 		needUpdate = true
-		updateNodePoolRequest.NodeVersion = *s.scope.GCPManagedMachinePool.Spec.NodeVersion
+		updateNodePoolRequest.NodeVersion = *s.scope.NodePoolVersion()
 	}
 	// Kubernetes labels
 	if !reflect.DeepEqual(map[string]string(s.scope.GCPManagedMachinePool.Spec.KubernetesLabels), existingNodePool.Config.Labels) {

config/crd/bases/infrastructure.cluster.x-k8s.io_gcpmanagedmachinepools.yaml

@@ -94,11 +94,6 @@ spec:
                   a default name will be created based on the namespace and name of
                   the managed machine pool.
                 type: string
-              nodeVersion:
-                description: NodeVersion represents the node version of the node pool.
-                  If not specified, the GKE cluster control plane version will be
-                  used.
-                type: string
               providerIDList:
                 description: ProviderIDList are the provider IDs of instances in the
                   managed instance group corresponding to the nodegroup represented

exp/api/v1beta1/gcpmanagedmachinepool_types.go

@@ -34,10 +34,6 @@ type GCPManagedMachinePoolSpec struct {
 	// then a default name will be created based on the namespace and name of the managed machine pool.
 	// +optional
 	NodePoolName string `json:"nodePoolName,omitempty"`
-	// NodeVersion represents the node version of the node pool.
-	// If not specified, the GKE cluster control plane version will be used.
-	// +optional
-	NodeVersion *string `json:"nodeVersion,omitempty"`
 	// NodeCount represents the initial number of nodes for the pool.
 	// In regional or multi-zonal clusters, this is the number of nodes per zone.
 	NodeCount int32 `json:"nodeCount"`

exp/controllers/gcpmanagedmachinepool_controller.go

@@ -289,6 +289,7 @@ func (r *GCPManagedMachinePoolReconciler) Reconcile(ctx context.Context, req ctr
 	managedMachinePoolScope, err := scope.NewManagedMachinePoolScope(ctx, scope.ManagedMachinePoolScopeParams{
 		Client:                 r.Client,
 		Cluster:                cluster,
+		MachinePool: 			machinePool,
 		GCPManagedCluster:      gcpManagedCluster,
 		GCPManagedControlPlane: gcpManagedControlPlane,
 		GCPManagedMachinePool:  gcpManagedMachinePool,