OCPCLOUD-2992: machineset migration e2e

Makefile

@@ -44,7 +44,7 @@ unit:
 
 .PHONY: e2e
 e2e:
-	./hack/test.sh "./e2e/..." 30m
+	./hack/test.sh "./e2e/..." 60m
 
 # Run against the configured Kubernetes cluster in ~/.kube/config
 run:

e2e/framework/machine.go

@@ -1,6 +1,7 @@
 package framework
 
 import (
+	"context"
 	"fmt"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -54,3 +55,15 @@ func FilterRunningMachines(machines []*clusterv1.Machine) []*clusterv1.Machine {
 
 	return result
 }
+
+// GetMachine get a machine by its name from the cluster API namespace.
+func GetMachine(cl client.Client, name string) (*clusterv1.Machine, error) {
+	machine := &clusterv1.Machine{}
+	key := client.ObjectKey{Namespace: CAPINamespace, Name: name}
+
+	if err := cl.Get(context.Background(), key, machine); err != nil {
+		return nil, fmt.Errorf("error querying api for machine object: %w", err)
+	}
+
+	return machine, nil
+}

e2e/framework/machineset.go

@@ -1,16 +1,27 @@
 package framework
 
 import (
+	"context"
 	"fmt"
+	"time"
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/client-go/discovery"
+	"k8s.io/client-go/dynamic"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/scale"
+	"k8s.io/klog"
 	"k8s.io/utils/pointer"
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
 	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
+	"sigs.k8s.io/controller-runtime/pkg/client/config"
 )
 
 type machineSetParams struct {
@@ -171,7 +182,9 @@ func GetMachineSet(cl client.Client, name string) (*clusterv1.MachineSet, error)
 	machineSet := &clusterv1.MachineSet{}
 	key := client.ObjectKey{Namespace: CAPINamespace, Name: name}
 
-	Expect(cl.Get(ctx, key, machineSet)).To(Succeed())
+	if err := cl.Get(ctx, key, machineSet); err != nil {
+		return nil, fmt.Errorf("error querying api for machineSet object: %w", err)
+	}
 
 	return machineSet, nil
 }
@@ -190,3 +203,106 @@ func GetMachinesFromMachineSet(cl client.Client, machineSet *clusterv1.MachineSe
 	}
 	return machinesForSet, nil
 }
+
+// GetLatestMachineFromMachineSet returns the new created machine by a given machineSet.
+func GetLatestMachineFromMachineSet(cl client.Client, machineSet *clusterv1.MachineSet) (*clusterv1.Machine, error) {
+	machines, err := GetMachinesFromMachineSet(cl, machineSet)
+	if err != nil {
+		return nil, fmt.Errorf("error getting machines: %w", err)
+	}
+
+	var machine *clusterv1.Machine
+
+	newest := time.Date(2020, 0, 1, 12, 0, 0, 0, time.UTC)
+
+	for key := range machines {
+		time := machines[key].CreationTimestamp.Time
+		if time.After(newest) {
+			newest = time
+			machine = machines[key]
+		}
+	}
+
+	return machine, nil
+}
+
+// DeleteMachines deletes the specified machines and returns an error on failure.
+func DeleteMachines(cl client.Client, machines ...*clusterv1.Machine) error {
+	return wait.PollUntilContextTimeout(ctx, RetryShort, time.Minute, true, func(ctx context.Context) (bool, error) {
+		for _, machine := range machines {
+			if err := cl.Delete(ctx, machine); err != nil {
+				klog.Errorf("Error querying api for machine object %q: %v, retrying...", machine.Name, err)
+				return false, err
+			}
+		}
+
+		return true, nil
+	})
+}
+
+// WaitForMachinesDeleted polls until the given Machines are not found.
+func WaitForMachinesDeleted(cl client.Client, machines ...*clusterv1.Machine) {
+	Eventually(func() bool {
+		for _, m := range machines {
+			if err := cl.Get(context.Background(), client.ObjectKey{
+				Name:      m.GetName(),
+				Namespace: m.GetNamespace(),
+			}, &clusterv1.Machine{}); !apierrors.IsNotFound(err) {
+				return false // Not deleted, or other error.
+			}
+		}
+
+		return true // Everything was deleted.
+	}, WaitLong, RetryMedium).Should(BeTrue(), "error encountered while waiting for Machines to be deleted.")
+}
+
+// ScaleMachineSet scales a machineSet with a given name to the given number of replicas.
+func ScaleMachineSet(name string, replicas int) error {
+	scaleClient, err := getScaleClient()
+	if err != nil {
+		return fmt.Errorf("error calling getScaleClient %w", err)
+	}
+
+	scale, err := scaleClient.Scales(CAPINamespace).Get(ctx, schema.GroupResource{Group: "cluster.x-k8s.io", Resource: "MachineSet"}, name, metav1.GetOptions{})
+	if err != nil {
+		return fmt.Errorf("error calling scaleClient.Scales get: %w", err)
+	}
+
+	scaleUpdate := scale.DeepCopy()
+	scaleUpdate.Spec.Replicas = int32(replicas)
+
+	_, err = scaleClient.Scales(CAPINamespace).Update(ctx, schema.GroupResource{Group: "cluster.x-k8s.io", Resource: "MachineSet"}, scaleUpdate, metav1.UpdateOptions{})
+	if err != nil {
+		return fmt.Errorf("error calling scaleClient.Scales update: %w", err)
+	}
+
+	return nil
+}
+
+// getScaleClient returns a ScalesGetter object to manipulate scale subresources.
+func getScaleClient() (scale.ScalesGetter, error) {
+	cfg, err := config.GetConfig()
+	if err != nil {
+		return nil, fmt.Errorf("error getting config %w", err)
+	}
+
+	httpClient, err := rest.HTTPClientFor(cfg)
+	if err != nil {
+		return nil, fmt.Errorf("error calling rest.HTTPClientFor %w", err)
+	}
+
+	mapper, err := apiutil.NewDynamicRESTMapper(cfg, httpClient)
+	if err != nil {
+		return nil, fmt.Errorf("error calling NewDiscoveryRESTMapper %w", err)
+	}
+
+	discovery := discovery.NewDiscoveryClientForConfigOrDie(cfg)
+	scaleKindResolver := scale.NewDiscoveryScaleKindResolver(discovery)
+
+	scaleClient, err := scale.NewForConfig(cfg, mapper, dynamic.LegacyAPIPathResolverFunc, scaleKindResolver)
+	if err != nil {
+		return nil, fmt.Errorf("error calling building scale client %w", err)
+	}
+
+	return scaleClient, nil
+}

e2e/framework/machinetemplate.go

@@ -0,0 +1,104 @@
+package framework
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	awsv1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
+	azurev1 "sigs.k8s.io/cluster-api-provider-azure/api/v1beta1"
+	gcpv1 "sigs.k8s.io/cluster-api-provider-gcp/api/v1beta1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+// GetAWSMachineTemplateByName gets awsMachineTemplate by its name from the default cluster API namespace.
+func GetAWSMachineTemplateByName(cl client.Client, name string) (*awsv1.AWSMachineTemplate, error) {
+	var awsMachineTemplate = &awsv1.AWSMachineTemplate{}
+
+	key := client.ObjectKey{Namespace: CAPINamespace, Name: name}
+	if err := cl.Get(ctx, key, awsMachineTemplate); err != nil {
+		return nil, err
+	}
+	return awsMachineTemplate, nil
+}
+
+// GetAWSMachineTemplateByPrefix gets awsMachineTemplate by its prefix from the default cluster API namespace.
+func GetAWSMachineTemplateByPrefix(cl client.Client, prefix string) (*awsv1.AWSMachineTemplate, error) {
+    templateList := &awsv1.AWSMachineTemplateList{}
+    if err := cl.List(ctx, templateList, client.InNamespace(CAPINamespace)); err != nil {
+        return nil, fmt.Errorf("failed to list AWSMachineTemplates: %w", err)
+    }
+
+    var matches []*awsv1.AWSMachineTemplate
+    for i, t := range templateList.Items {
+        if strings.HasPrefix(t.Name, prefix) {
+            matches = append(matches, &templateList.Items[i])
+        }
+    }
+
+    switch len(matches) {
+    case 0:
+        return nil, fmt.Errorf("no AWSMachineTemplate found with prefix %q", prefix)
+    case 1:
+        return matches[0], nil
+    default:
+        return nil, fmt.Errorf("multiple AWSMachineTemplates found with prefix %q (%d matches)", prefix, len(matches))
+    }
+}
+
+// DeleteAWSMachineTemplateByPrefix deletes all AWSMachineTemplates with matching name prefix
+func DeleteAWSMachineTemplateByPrefix(cl client.Client, prefix string) error {
+    templateList := &awsv1.AWSMachineTemplateList{}
+    if err := cl.List(ctx, templateList, client.InNamespace(CAPINamespace)); err != nil {
+        return fmt.Errorf("failed to list AWSMachineTemplates: %w", err)
+    }
+
+    var deleteErrors []error
+    var deletedCount int
+
+    for i := range templateList.Items {
+        if strings.HasPrefix(templateList.Items[i].Name, prefix) {
+            if err := cl.Delete(ctx, &templateList.Items[i]); err != nil {
+                if !apierrors.IsNotFound(err) {
+                    deleteErrors = append(deleteErrors, fmt.Errorf("failed to delete %s: %w", templateList.Items[i].Name, err))
+                }
+                continue
+            }
+            deletedCount++
+        }
+    }
+
+    if len(deleteErrors) > 0 {
+        return fmt.Errorf("deleted %d templates, but encountered %d errors: %v", 
+            deletedCount, len(deleteErrors), errors.Join(deleteErrors...))
+    }
+
+    if deletedCount == 0 {
+        return fmt.Errorf("no templates found with prefix %q", prefix)
+    }
+
+    return nil
+}
+
+// GetAzureMachineTemplate gets azureMachineTemplate by its name from the default cluster API namespace.
+func GetAzureMachineTemplate(cl client.Client, name string) (*azurev1.AzureMachineTemplate, error) {
+	var azureMachineTemplate = &azurev1.AzureMachineTemplate{}
+
+	key := client.ObjectKey{Namespace: CAPINamespace, Name: name}
+	if err := cl.Get(ctx, key, azureMachineTemplate); err != nil {
+		return nil, err
+	}
+	return azureMachineTemplate, nil
+}
+
+// GetGCPMachineTemplate gets gcpMachineTemplate by its name from the default cluster API namespace.
+func GetGCPMachineTemplate(cl client.Client, name string) (*gcpv1.GCPMachineTemplate, error) {
+	var gcpMachineTemplate = &gcpv1.GCPMachineTemplate{}
+
+	key := client.ObjectKey{Namespace: CAPINamespace, Name: name}
+	if err := cl.Get(ctx, key, gcpMachineTemplate); err != nil {
+		return nil, err
+	}
+	return gcpMachineTemplate, nil
+}

e2e/framework/util.go

@@ -1,11 +1,13 @@
 package framework
 
 import (
+	"context"
 	"fmt"
 	"net/url"
 	"strconv"
 
 	configv1 "github.com/openshift/api/config/v1"
+	"k8s.io/apimachinery/pkg/types"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
@@ -32,3 +34,21 @@ func GetControlPlaneHostAndPort(cl client.Client) (string, int32, error) {
 
 	return apiUrl.Hostname(), int32(port), nil
 }
+
+// IsMachineAPIMigrationEnabled checks if the "MachineAPIMigration" feature is enabled via FeatureGate status
+func IsMachineAPIMigrationEnabled(ctx context.Context, cl client.Client) bool {
+    featureGate := &configv1.FeatureGate{}
+    if err := cl.Get(ctx, types.NamespacedName{Name: "cluster"}, featureGate); err != nil {
+        return false
+    }
+
+    for _, fg := range featureGate.Status.FeatureGates {
+		for _, enabled := range fg.Enabled {
+			if enabled.Name == "MachineAPIMigration" {
+				return true
+			}
+		}
+    }
+
+    return false
+}