Add logic to OpenStackMachineTemplate controller

Add logic to OpenStackMachineTemplate controller to populate
status with:
- capacity related information taken from the flavor and rootVolume
  of the osmt
- operatingSystem info taken from the image of the osmt

Author: nikParasyr

api/v1beta1/openstackmachinetemplate_types.go

@@ -50,6 +50,7 @@ type NodeInfo struct {
 // +kubebuilder:object:root=true
 // +kubebuilder:storageversion
 // +kubebuilder:resource:path=openstackmachinetemplates,scope=Namespaced,categories=cluster-api,shortName=osmt
+// +kubebuilder:subresource:status
 
 // OpenStackMachineTemplate is the Schema for the openstackmachinetemplates API.
 type OpenStackMachineTemplate struct {
@@ -72,3 +73,11 @@ type OpenStackMachineTemplateList struct {
 func init() {
 	objectTypes = append(objectTypes, &OpenStackMachineTemplate{}, &OpenStackMachineTemplateList{})
 }
+
+// GetIdentifyRef returns the object's namespace and IdentityRef if it has an IdentityRef, or nulls if it does not.
+func (r *OpenStackMachineTemplate) GetIdentityRef() (*string, *OpenStackIdentityReference) {
+	if r.Spec.Template.Spec.IdentityRef != nil {
+		return &r.Namespace, r.Spec.Template.Spec.IdentityRef
+	}
+	return nil, nil
+}

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

@@ -24,7 +24,7 @@ spec:
         - "--v=2"
         - "--diagnostics-address=127.0.0.1:8080"
         - "--insecure-diagnostics=true"
-        - "--feature-gates=PriorityQueue=${EXP_CAPO_PRIORITY_QUEUE:=false}"
+        - "--feature-gates=PriorityQueue=${EXP_CAPO_PRIORITY_QUEUE:=false},AutoScaleFromZero=${EXP_CAPO_AUTOSCALE_FROM_ZERO:=false}"
         image: controller:latest
         imagePullPolicy: Always
         name: manager

config/manager/manager.yaml

@@ -51,6 +51,7 @@ import (
 	"sigs.k8s.io/cluster-api-provider-openstack/pkg/cloud/services/loadbalancer"
 	"sigs.k8s.io/cluster-api-provider-openstack/pkg/cloud/services/networking"
 	"sigs.k8s.io/cluster-api-provider-openstack/pkg/scope"
+	controllers "sigs.k8s.io/cluster-api-provider-openstack/pkg/utils/controllers"
 	capoerrors "sigs.k8s.io/cluster-api-provider-openstack/pkg/utils/errors"
 )
 
@@ -122,7 +123,7 @@ func (r *OpenStackMachineReconciler) Reconcile(ctx context.Context, req ctrl.Req
 		return ctrl.Result{}, nil
 	}
 
-	infraCluster, err := r.getInfraCluster(ctx, cluster, openStackMachine)
+	infraCluster, err := controllers.GetInfraCluster(ctx, r.Client, cluster, openStackMachine.Namespace)
 	if err != nil {
 		return ctrl.Result{}, errors.New("error getting infra provider cluster")
 	}
@@ -804,15 +805,3 @@ func (r *OpenStackMachineReconciler) requestsForCluster(ctx context.Context, log
 	}
 	return result
 }
-
-func (r *OpenStackMachineReconciler) getInfraCluster(ctx context.Context, cluster *clusterv1.Cluster, openStackMachine *infrav1.OpenStackMachine) (*infrav1.OpenStackCluster, error) {
-	openStackCluster := &infrav1.OpenStackCluster{}
-	openStackClusterName := client.ObjectKey{
-		Namespace: openStackMachine.Namespace,
-		Name:      cluster.Spec.InfrastructureRef.Name,
-	}
-	if err := r.Client.Get(ctx, openStackClusterName, openStackCluster); err != nil {
-		return nil, err
-	}
-	return openStackCluster, nil
-}

controllers/openstackmachine_controller.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2023 The Kubernetes Authors.
+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.
@@ -17,21 +17,34 @@ package controllers
 
 import (
 	"context"
+	"errors"
 
+	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/resource"
+	kerrors "k8s.io/apimachinery/pkg/util/errors"
 	"k8s.io/client-go/tools/record"
+	"sigs.k8s.io/cluster-api/util"
+	"sigs.k8s.io/cluster-api/util/annotations"
+	"sigs.k8s.io/cluster-api/util/patch"
+	"sigs.k8s.io/cluster-api/util/predicates"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 
-	"sigs.k8s.io/cluster-api/util/predicates"
-
 	infrav1 "sigs.k8s.io/cluster-api-provider-openstack/api/v1beta1"
+	"sigs.k8s.io/cluster-api-provider-openstack/pkg/cloud/services/compute"
 	"sigs.k8s.io/cluster-api-provider-openstack/pkg/scope"
+	controllers "sigs.k8s.io/cluster-api-provider-openstack/pkg/utils/controllers"
 )
 
+const imagePropertyForOS = "os_type"
+
+// Set here so we can easily mock it in tests.
+var newComputeService = compute.NewService
+
 // OpenStackMachineTemplateReconciler reconciles a OpenStackMachineTemplate object.
-// it only updates the .status field to allow auto-scaling
+// it only updates the .status field to allow auto-scaling.
 type OpenStackMachineTemplateReconciler struct {
 	Client           client.Client
 	Recorder         record.EventRecorder
@@ -40,14 +53,14 @@ type OpenStackMachineTemplateReconciler struct {
 	CaCertificates   []byte // PEM encoded ca certificates.
 }
 
-// +kubebuilder:rbac:groups=infrastructure.cluster.x-k8s.io,resources=openstackmachinetemplatess,verbs=get;list;watch;create;
-// +kubebuilder:rbac:groups=infrastructure.cluster.x-k8s.io,resources=openstackmachinetemplatess/status,verbs=get;update;patch
+// +kubebuilder:rbac:groups=infrastructure.cluster.x-k8s.io,resources=openstackmachinetemplates,verbs=get;list;watch
+// +kubebuilder:rbac:groups=infrastructure.cluster.x-k8s.io,resources=openstackmachinetemplates/status,verbs=get;update;patch
 
 func (r *OpenStackMachineTemplateReconciler) Reconcile(ctx context.Context, req ctrl.Request) (result ctrl.Result, reterr error) {
 	log := ctrl.LoggerFrom(ctx)
 
 	// Fetch the OpenStackMachine instance.
-	openStackMachineTemplate := &infrav1.OpenStackMachine{}
+	openStackMachineTemplate := &infrav1.OpenStackMachineTemplate{}
 	err := r.Client.Get(ctx, req.NamespacedName, openStackMachineTemplate)
 	if err != nil {
 		if apierrors.IsNotFound(err) {
@@ -59,9 +72,141 @@ func (r *OpenStackMachineTemplateReconciler) Reconcile(ctx context.Context, req
 	log = log.WithValues("openStackMachineTemplate", openStackMachineTemplate.Name)
 	log.V(4).Info("Reconciling openStackMachineTemplate")
 
+	// If OSMT is set for deletion, do nothing
+	if !openStackMachineTemplate.DeletionTimestamp.IsZero() {
+		log.Info("OpenStackMachineTemplate marked for deletion, skipping reconciliation")
+		return ctrl.Result{}, nil
+	}
+
+	// Fetch the Cluster.
+	cluster, err := util.GetClusterFromMetadata(ctx, r.Client, openStackMachineTemplate.ObjectMeta)
+	if err != nil {
+		log.Info("openStackMachineTemplate is missing cluster label or cluster does not exist")
+		return ctrl.Result{}, nil
+	}
+
+	log = log.WithValues("cluster", cluster.Name)
+
+	if annotations.IsPaused(cluster, openStackMachineTemplate) {
+		log.Info("OpenStackMachineTemplate or linked Cluster is marked as paused. Won't reconcile")
+		return ctrl.Result{}, nil
+	}
+
+	infraCluster, err := controllers.GetInfraCluster(ctx, r.Client, cluster, openStackMachineTemplate.Namespace)
+	if err != nil {
+		return ctrl.Result{}, errors.New("error getting infra provider cluster")
+	}
+	if infraCluster == nil {
+		log.Info("OpenStackCluster not ready", "name", cluster.Spec.InfrastructureRef.Name)
+		return ctrl.Result{}, nil
+	}
+
+	log = log.WithValues("openStackCluster", infraCluster.Name)
+
+	clientScope, err := r.ScopeFactory.NewClientScopeFromObject(ctx, r.Client, r.CaCertificates, log, openStackMachineTemplate, infraCluster)
+	if err != nil {
+		return ctrl.Result{}, err
+	}
+	scope := scope.NewWithLogger(clientScope, log)
+
+	// Initialize the patch helper
+	patchHelper, err := patch.NewHelper(openStackMachineTemplate, r.Client)
+	if err != nil {
+		return ctrl.Result{}, err
+	}
+
+	// Always patch the openStackMachine when exiting this function so we can persist any OpenStackMachine changes.
+	defer func() {
+		if err := patchHelper.Patch(ctx, openStackMachineTemplate); err != nil {
+			log.Error(err, "Failed to patch OpenStackMachineTemplate after reconciliation")
+			result = ctrl.Result{}
+			reterr = kerrors.NewAggregate([]error{reterr, err})
+		}
+	}()
+
+	// Handle non-deleted OpenStackMachineTemplates
+	if err := r.reconcileNormal(ctx, scope, openStackMachineTemplate); err != nil {
+		return ctrl.Result{}, err
+	}
+	log.V(4).Info("Successfully reconciled OpenStackMachineTemplate")
 	return ctrl.Result{}, nil
 }
 
+func (r *OpenStackMachineTemplateReconciler) reconcileNormal(ctx context.Context, scope *scope.WithLogger, openStackMachineTemplate *infrav1.OpenStackMachineTemplate) (reterr error) {
+	log := scope.Logger()
+
+	computeService, err := newComputeService(scope)
+	if err != nil {
+		return err
+	}
+
+	flavorID, err := computeService.GetFlavorID(openStackMachineTemplate.Spec.Template.Spec.FlavorID, openStackMachineTemplate.Spec.Template.Spec.Flavor)
+	if err != nil {
+		return err
+	}
+
+	flavor, err := computeService.GetFlavor(flavorID)
+	if err != nil {
+		return err
+	}
+
+	log.V(4).Info("Retrieved flavor details", "flavorID", flavorID)
+
+	if openStackMachineTemplate.Status.Capacity == nil {
+		log.V(4).Info("Initializing status capacity map")
+		openStackMachineTemplate.Status.Capacity = corev1.ResourceList{}
+	}
+
+	if flavor.VCPUs > 0 {
+		openStackMachineTemplate.Status.Capacity[corev1.ResourceCPU] = *resource.NewQuantity(int64(flavor.VCPUs), resource.DecimalSI)
+	}
+
+	if flavor.RAM > 0 {
+		// flavor.RAM is in MiB -> convert to bytes
+		ramBytes := int64(flavor.RAM) * 1024 * 1024
+		openStackMachineTemplate.Status.Capacity[corev1.ResourceMemory] = *resource.NewQuantity(ramBytes, resource.BinarySI)
+	}
+
+	if flavor.Ephemeral > 0 {
+		// flavor.Ephemeral is in GiB -> convert to bytes
+		ephemeralBytes := int64(flavor.Ephemeral) * 1024 * 1024 * 1024
+		openStackMachineTemplate.Status.Capacity[corev1.ResourceEphemeralStorage] = *resource.NewQuantity(ephemeralBytes, resource.BinarySI)
+	}
+
+	// storage depends on whether user boots-from-volume or not
+	if openStackMachineTemplate.Spec.Template.Spec.RootVolume != nil && openStackMachineTemplate.Spec.Template.Spec.RootVolume.SizeGiB > 0 {
+		// RootVolume.SizeGib is in GiB -> convert to bytes
+		storageBytes := int64(openStackMachineTemplate.Spec.Template.Spec.RootVolume.SizeGiB) * 1024 * 1024 * 1024
+		openStackMachineTemplate.Status.Capacity[corev1.ResourceStorage] = *resource.NewQuantity(storageBytes, resource.BinarySI)
+	} else if flavor.Disk > 0 {
+		// flavor.Disk is in GiB -> convert to bytes
+		storageBytes := int64(flavor.Disk) * 1024 * 1024 * 1024
+		openStackMachineTemplate.Status.Capacity[corev1.ResourceStorage] = *resource.NewQuantity(storageBytes, resource.BinarySI)
+	}
+
+	imageID, err := computeService.GetImageID(ctx, r.Client, openStackMachineTemplate.Namespace, openStackMachineTemplate.Spec.Template.Spec.Image)
+	if err != nil {
+		return err
+	}
+
+	image, err := computeService.GetImageDetails(*imageID)
+	if err != nil {
+		return err
+	}
+
+	log.V(4).Info("Retrieved image details", "imageID", imageID)
+
+	if image.Properties != nil {
+		if v, ok := image.Properties[imagePropertyForOS]; ok {
+			if osType, ok := v.(string); ok {
+				openStackMachineTemplate.Status.NodeInfo.OperatingSystem = osType
+			}
+		}
+	}
+
+	return nil
+}
+
 func (r *OpenStackMachineTemplateReconciler) SetupWithManager(ctx context.Context, mgr ctrl.Manager, options controller.Options) error {
 	log := ctrl.LoggerFrom(ctx)