Merge pull request #1506 from justinsb/machinepool

Minimal MachinePool support

Author: k8s-ci-robot

api/v1beta1/conditions_consts.go

@@ -0,0 +1,24 @@
+/*
+Copyright 2025 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1beta1
+
+const (
+	// WaitingForClusterInfrastructureReason used when machine is waiting for cluster infrastructure to be ready before proceeding.
+	WaitingForClusterInfrastructureReason = "WaitingForClusterInfrastructure"
+	// WaitingForBootstrapDataReason used when machine is waiting for bootstrap data to be ready before proceeding.
+	WaitingForBootstrapDataReason = "WaitingForBootstrapData"
+)

api/v1beta1/labels.go

@@ -114,6 +114,11 @@ const (
 
 	// InternalRoleTagValue describes the value for the internal role.
 	InternalRoleTagValue = "api-internal"
+
+	// ConfigHashKey holds the full hash of the desired state of a resource.
+	// Note that label values are limited to 63 characters in GCP, so we can use
+	// base32 encoding if we want to store a full sha256 hash.
+	ConfigHashKey = NameGCPProviderPrefix + "config-hash"
 )
 
 // ClusterTagKey generates the key for resources associated with a cluster.

cloud/interfaces.go

@@ -90,7 +90,7 @@ type MachineGetter interface {
 	ControlPlaneGroupName() string
 	GetInstanceID() *string
 	GetProviderID() string
-	GetBootstrapData() (string, error)
+	GetBootstrapData(ctx context.Context) (string, error)
 	GetInstanceStatus() *infrav1.InstanceStatus
 }
 

cloud/scope/machine.go

@@ -25,7 +25,6 @@ import (
 	"strings"
 
 	"github.com/go-logr/logr"
-
 	"github.com/pkg/errors"
 	"golang.org/x/mod/semver"
 	"google.golang.org/api/compute/v1"
@@ -41,6 +40,13 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
+// Constants for GCP OnHostMaintenance values.
+// These are not exported, because they are not _our_ API, but they are used in multiple places.
+const (
+	onHostMaintenanceTerminate = "TERMINATE"
+	onHostMaintenanceMigrate   = "MIGRATE"
+)
+
 // MachineScopeParams defines the input parameters used to create a new MachineScope.
 type MachineScopeParams struct {
 	Client        client.Client
@@ -320,12 +326,12 @@ func instanceAdditionalDiskSpec(ctx context.Context, spec []infrav1.AttachedDisk
 }
 
 // InstanceNetworkInterfaceSpec returns compute network interface spec.
-func (m *MachineScope) InstanceNetworkInterfaceSpec() *compute.NetworkInterface {
+func InstanceNetworkInterfaceSpec(cluster cloud.ClusterGetter, publicIP *bool, subnet *string, aliasIPRanges []infrav1.AliasIPRange) *compute.NetworkInterface {
 	networkInterface := &compute.NetworkInterface{
-		Network: path.Join("projects", m.ClusterGetter.NetworkProject(), "global", "networks", m.ClusterGetter.NetworkName()),
+		Network: path.Join("projects", cluster.NetworkProject(), "global", "networks", cluster.NetworkName()),
 	}
 
-	if m.GCPMachine.Spec.PublicIP != nil && *m.GCPMachine.Spec.PublicIP {
+	if publicIP != nil && *publicIP {
 		networkInterface.AccessConfigs = []*compute.AccessConfig{
 			{
 				Type: "ONE_TO_ONE_NAT",
@@ -334,22 +340,22 @@ func (m *MachineScope) InstanceNetworkInterfaceSpec() *compute.NetworkInterface
 		}
 	}
 
-	if m.GCPMachine.Spec.Subnet != nil {
-		networkInterface.Subnetwork = path.Join("projects", m.ClusterGetter.NetworkProject(), "regions", m.ClusterGetter.Region(), "subnetworks", *m.GCPMachine.Spec.Subnet)
+	if subnet != nil {
+		networkInterface.Subnetwork = path.Join("projects", cluster.NetworkProject(), "regions", cluster.Region(), "subnetworks", *subnet)
 	}
 
-	networkInterface.AliasIpRanges = m.InstanceNetworkInterfaceAliasIPRangesSpec()
+	networkInterface.AliasIpRanges = InstanceNetworkInterfaceAliasIPRangesSpec(aliasIPRanges)
 
 	return networkInterface
 }
 
 // InstanceNetworkInterfaceAliasIPRangesSpec returns a slice of Alias IP Range specs.
-func (m *MachineScope) InstanceNetworkInterfaceAliasIPRangesSpec() []*compute.AliasIpRange {
-	if len(m.GCPMachine.Spec.AliasIPRanges) == 0 {
+func InstanceNetworkInterfaceAliasIPRangesSpec(spec []infrav1.AliasIPRange) []*compute.AliasIpRange {
+	if len(spec) == 0 {
 		return nil
 	}
-	aliasIPRanges := make([]*compute.AliasIpRange, 0, len(m.GCPMachine.Spec.AliasIPRanges))
-	for _, alias := range m.GCPMachine.Spec.AliasIPRanges {
+	aliasIPRanges := make([]*compute.AliasIpRange, 0, len(spec))
+	for _, alias := range spec {
 		aliasIPRange := &compute.AliasIpRange{
 			IpCidrRange:         alias.IPCidrRange,
 			SubnetworkRangeName: alias.SubnetworkRangeName,
@@ -377,9 +383,9 @@ func instanceServiceAccountsSpec(serviceAccount *infrav1.ServiceAccount) *comput
 }
 
 // InstanceAdditionalMetadataSpec returns additional metadata spec.
-func (m *MachineScope) InstanceAdditionalMetadataSpec() *compute.Metadata {
+func InstanceAdditionalMetadataSpec(spec []infrav1.MetadataItem) *compute.Metadata {
 	metadata := new(compute.Metadata)
-	for _, additionalMetadata := range m.GCPMachine.Spec.AdditionalMetadata {
+	for _, additionalMetadata := range spec {
 		metadata.Items = append(metadata.Items, &compute.MetadataItems{
 			Key:   additionalMetadata.Key,
 			Value: additionalMetadata.Value,
@@ -469,9 +475,9 @@ func (m *MachineScope) InstanceSpec(log logr.Logger) *compute.Instance {
 	if m.GCPMachine.Spec.OnHostMaintenance != nil {
 		switch *m.GCPMachine.Spec.OnHostMaintenance {
 		case infrav1.HostMaintenancePolicyMigrate:
-			instance.Scheduling.OnHostMaintenance = "MIGRATE"
+			instance.Scheduling.OnHostMaintenance = onHostMaintenanceMigrate
 		case infrav1.HostMaintenancePolicyTerminate:
-			instance.Scheduling.OnHostMaintenance = "TERMINATE"
+			instance.Scheduling.OnHostMaintenance = onHostMaintenanceTerminate
 		default:
 			log.Error(errors.New("Invalid value"), "Unknown OnHostMaintenance value", "Spec.OnHostMaintenance", *m.GCPMachine.Spec.OnHostMaintenance)
 		}
@@ -496,12 +502,13 @@ func (m *MachineScope) InstanceSpec(log logr.Logger) *compute.Instance {
 
 	instance.Disks = append(instance.Disks, m.InstanceImageSpec())
 	instance.Disks = append(instance.Disks, instanceAdditionalDiskSpec(ctx, m.GCPMachine.Spec.AdditionalDisks, m.GCPMachine.Spec.RootDiskEncryptionKey, m.Zone(), m.ResourceManagerTags())...)
-	instance.Metadata = m.InstanceAdditionalMetadataSpec()
+
+	instance.Metadata = InstanceAdditionalMetadataSpec(m.GCPMachine.Spec.AdditionalMetadata)
 	instance.ServiceAccounts = append(instance.ServiceAccounts, instanceServiceAccountsSpec(m.GCPMachine.Spec.ServiceAccount))
-	instance.NetworkInterfaces = append(instance.NetworkInterfaces, m.InstanceNetworkInterfaceSpec())
+	instance.NetworkInterfaces = append(instance.NetworkInterfaces, InstanceNetworkInterfaceSpec(m.ClusterGetter, m.GCPMachine.Spec.PublicIP, m.GCPMachine.Spec.Subnet, m.GCPMachine.Spec.AliasIPRanges))
 	instance.GuestAccelerators = instanceGuestAcceleratorsSpec(m.GCPMachine.Spec.GuestAccelerators)
 	if len(instance.GuestAccelerators) > 0 {
-		instance.Scheduling.OnHostMaintenance = "TERMINATE"
+		instance.Scheduling.OnHostMaintenance = onHostMaintenanceTerminate
 	}
 
 	return instance
@@ -510,15 +517,20 @@ func (m *MachineScope) InstanceSpec(log logr.Logger) *compute.Instance {
 // ANCHOR_END: MachineInstanceSpec
 
 // GetBootstrapData returns the bootstrap data from the secret in the Machine's bootstrap.dataSecretName.
-func (m *MachineScope) GetBootstrapData() (string, error) {
-	if m.Machine.Spec.Bootstrap.DataSecretName == nil {
+func (m *MachineScope) GetBootstrapData(ctx context.Context) (string, error) {
+	return GetBootstrapData(ctx, m.client, m.Machine, m.Machine.Spec.Bootstrap)
+}
+
+// GetBootstrapData returns the bootstrap data from the secret in the Machine's bootstrap.dataSecretName.
+func GetBootstrapData(ctx context.Context, client client.Client, parent client.Object, bootstrap clusterv1.Bootstrap) (string, error) {
+	if bootstrap.DataSecretName == nil {
 		return "", errors.New("error retrieving bootstrap data: linked Machine's bootstrap.dataSecretName is nil")
 	}
 
 	secret := &corev1.Secret{}
-	key := types.NamespacedName{Namespace: m.Namespace(), Name: *m.Machine.Spec.Bootstrap.DataSecretName}
-	if err := m.client.Get(context.TODO(), key, secret); err != nil {
-		return "", errors.Wrapf(err, "failed to retrieve bootstrap data secret for GCPMachine %s/%s", m.Namespace(), m.Name())
+	key := types.NamespacedName{Namespace: parent.GetNamespace(), Name: *bootstrap.DataSecretName}
+	if err := client.Get(ctx, key, secret); err != nil {
+		return "", errors.Wrapf(err, "failed to retrieve bootstrap data secret %s/%s", key.Namespace, key.Name)
 	}
 
 	value, ok := secret.Data["value"]

cloud/scope/machine_test.go

@@ -78,39 +78,14 @@ func TestMachineLocalSSDDiskType(t *testing.T) {
 
 // TestInstanceNetworkInterfaceAliasIPRangesSpec tests the InstanceNetworkInterfaceAliasIPRangesSpec function
 func TestInstanceNetworkInterfaceAliasIPRangesSpec(t *testing.T) {
-	// Register the GCPMachine and GCPMachineList in a schema.
-	schema, err := infrav1.SchemeBuilder.Register(&infrav1.GCPMachine{}, &infrav1.GCPMachineList{}).Build()
-	assert.Nil(t, err)
-
-	// Create a controller fake client.
-	testClient := fake.NewClientBuilder().WithScheme(schema).Build()
-
-	// Test machine parameter
-	failureDomain := "us-central1-a"
-	testMachine := clusterv1.Machine{
-		Spec: clusterv1.MachineSpec{
-			FailureDomain: failureDomain,
-		},
-	}
-
 	t.Run("should return nil for empty alias IP ranges", func(t *testing.T) {
 		testGCPMachine := infrav1.GCPMachine{
 			Spec: infrav1.GCPMachineSpec{
 				AliasIPRanges: []infrav1.AliasIPRange{},
 			},
 		}
 
-		testScopeParams := MachineScopeParams{
-			Client:     testClient,
-			Machine:    &testMachine,
-			GCPMachine: &testGCPMachine,
-		}
-
-		testMachineScope, err := NewMachineScope(testScopeParams)
-		assert.Nil(t, err)
-		assert.NotNil(t, testMachineScope)
-
-		result := testMachineScope.InstanceNetworkInterfaceAliasIPRangesSpec()
+		result := InstanceNetworkInterfaceAliasIPRangesSpec(testGCPMachine.Spec.AliasIPRanges)
 		assert.Nil(t, result)
 	})
 
@@ -126,17 +101,7 @@ func TestInstanceNetworkInterfaceAliasIPRangesSpec(t *testing.T) {
 			},
 		}
 
-		testScopeParams := MachineScopeParams{
-			Client:     testClient,
-			Machine:    &testMachine,
-			GCPMachine: &testGCPMachine,
-		}
-
-		testMachineScope, err := NewMachineScope(testScopeParams)
-		assert.Nil(t, err)
-		assert.NotNil(t, testMachineScope)
-
-		result := testMachineScope.InstanceNetworkInterfaceAliasIPRangesSpec()
+		result := InstanceNetworkInterfaceAliasIPRangesSpec(testGCPMachine.Spec.AliasIPRanges)
 		assert.NotNil(t, result)
 		assert.Len(t, result, 1)
 		assert.Equal(t, "10.0.0.0/24", result[0].IpCidrRange)
@@ -159,17 +124,7 @@ func TestInstanceNetworkInterfaceAliasIPRangesSpec(t *testing.T) {
 			},
 		}
 
-		testScopeParams := MachineScopeParams{
-			Client:     testClient,
-			Machine:    &testMachine,
-			GCPMachine: &testGCPMachine,
-		}
-
-		testMachineScope, err := NewMachineScope(testScopeParams)
-		assert.Nil(t, err)
-		assert.NotNil(t, testMachineScope)
-
-		result := testMachineScope.InstanceNetworkInterfaceAliasIPRangesSpec()
+		result := InstanceNetworkInterfaceAliasIPRangesSpec(testGCPMachine.Spec.AliasIPRanges)
 		assert.NotNil(t, result)
 		assert.Len(t, result, 2)
 		assert.Equal(t, "10.0.0.0/24", result[0].IpCidrRange)
@@ -190,17 +145,7 @@ func TestInstanceNetworkInterfaceAliasIPRangesSpec(t *testing.T) {
 			},
 		}
 
-		testScopeParams := MachineScopeParams{
-			Client:     testClient,
-			Machine:    &testMachine,
-			GCPMachine: &testGCPMachine,
-		}
-
-		testMachineScope, err := NewMachineScope(testScopeParams)
-		assert.Nil(t, err)
-		assert.NotNil(t, testMachineScope)
-
-		result := testMachineScope.InstanceNetworkInterfaceAliasIPRangesSpec()
+		result := InstanceNetworkInterfaceAliasIPRangesSpec(testGCPMachine.Spec.AliasIPRanges)
 		assert.NotNil(t, result)
 		assert.Len(t, result, 1)
 		assert.Equal(t, "10.100.0.0/24", result[0].IpCidrRange)