Add OpenStackMachineTemplate controller

Add OSMT controller behind a feature flag with basic
skeleton

Author: nikParasyr

controllers/openstackmachinetemplate_controller.go

@@ -0,0 +1,76 @@
+/*
+Copyright 2023 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 controllers
+
+import (
+	"context"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/client-go/tools/record"
+	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/scope"
+)
+
+// OpenStackMachineTemplateReconciler reconciles a OpenStackMachineTemplate object.
+// it only updates the .status field to allow auto-scaling
+type OpenStackMachineTemplateReconciler struct {
+	Client           client.Client
+	Recorder         record.EventRecorder
+	WatchFilterValue string
+	ScopeFactory     scope.Factory
+	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
+
+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{}
+	err := r.Client.Get(ctx, req.NamespacedName, openStackMachineTemplate)
+	if err != nil {
+		if apierrors.IsNotFound(err) {
+			return ctrl.Result{}, nil
+		}
+		return ctrl.Result{}, err
+	}
+
+	log = log.WithValues("openStackMachineTemplate", openStackMachineTemplate.Name)
+	log.V(4).Info("Reconciling openStackMachineTemplate")
+
+	return ctrl.Result{}, nil
+}
+
+func (r *OpenStackMachineTemplateReconciler) SetupWithManager(ctx context.Context, mgr ctrl.Manager, options controller.Options) error {
+	log := ctrl.LoggerFrom(ctx)
+
+	return ctrl.NewControllerManagedBy(mgr).
+		WithOptions(options).
+		For(&infrav1.OpenStackMachineTemplate{}).
+		WithEventFilter(predicates.ResourceNotPausedAndHasFilterLabel(mgr.GetScheme(), log, r.WatchFilterValue)).
+		// The filter below is required as we only want to reconcile objects created by cluster-api
+		// and not users'
+		WithEventFilter(predicates.ResourceIsTopologyOwned(mgr.GetScheme(), log)).
+		Complete(r)
+}

feature/feature.go

@@ -34,6 +34,13 @@ const (
 	//
 	// alpha: v0.14
 	PriorityQueue featuregate.Feature = "PriorityQueue"
+
+	// AutoScaleFromZero is a feature gate that enables the OpenStackMachineTemplate controller that adds
+	// information in OpenStackMachineTemplate.status required by the cluster-autoscaler to scale from zero
+	// without the addition of labels
+	//
+	// alpha: v0.14
+	AutoScaleFromZero featuregate.Feature = "AutoScaleFromZero"
 )
 
 func init() {
@@ -44,5 +51,6 @@ func init() {
 // To add a new feature, define a key for it above and add it here.
 var defaultCAPOFeatureGates = map[featuregate.Feature]featuregate.FeatureSpec{
 	// Every feature should be initiated here:
-	PriorityQueue: {Default: false, PreRelease: featuregate.Alpha},
+	PriorityQueue:     {Default: false, PreRelease: featuregate.Alpha},
+	AutoScaleFromZero: {Default: false, PreRelease: featuregate.Alpha},
 }

main.go

@@ -77,28 +77,29 @@ var (
 	setupLog = ctrl.Log.WithName("setup")
 
 	// flags.
-	managerOptions              = flags.ManagerOptions{}
-	enableLeaderElection        bool
-	leaderElectionLeaseDuration time.Duration
-	leaderElectionRenewDeadline time.Duration
-	leaderElectionRetryPeriod   time.Duration
-	watchNamespace              string
-	watchFilterValue            string
-	profilerAddress             string
-	openStackClusterConcurrency int
-	openStackMachineConcurrency int
-	syncPeriod                  time.Duration
-	restConfigQPS               float32
-	restConfigBurst             int
-	webhookPort                 int
-	webhookCertDir              string
-	healthAddr                  string
-	lbProvider                  string
-	caCertsPath                 string
-	showVersion                 bool
-	scopeCacheMaxSize           int
-	skipCRDMigrationPhases      []string
-	logOptions                  = logs.NewOptions()
+	managerOptions                      = flags.ManagerOptions{}
+	enableLeaderElection                bool
+	leaderElectionLeaseDuration         time.Duration
+	leaderElectionRenewDeadline         time.Duration
+	leaderElectionRetryPeriod           time.Duration
+	watchNamespace                      string
+	watchFilterValue                    string
+	profilerAddress                     string
+	openStackClusterConcurrency         int
+	openStackMachineConcurrency         int
+	openStackMachineTemplateConcurrency int
+	syncPeriod                          time.Duration
+	restConfigQPS                       float32
+	restConfigBurst                     int
+	webhookPort                         int
+	webhookCertDir                      string
+	healthAddr                          string
+	lbProvider                          string
+	caCertsPath                         string
+	showVersion                         bool
+	scopeCacheMaxSize                   int
+	skipCRDMigrationPhases              []string
+	logOptions                          = logs.NewOptions()
 )
 
 func init() {
@@ -148,6 +149,9 @@ func InitFlags(fs *pflag.FlagSet) {
 	fs.IntVar(&openStackMachineConcurrency, "openstackmachine-concurrency", 10,
 		"Number of OpenStackMachines to process simultaneously")
 
+	fs.IntVar(&openStackMachineTemplateConcurrency, "openstackmachinetemplate-concurrency", 10,
+		"Number of OpenStackMachineTemplates to process simultaneously")
+
 	fs.DurationVar(&syncPeriod, "sync-period", 10*time.Minute,
 		"The minimum interval at which watched resources are reconciled (e.g. 15m)")
 
@@ -395,6 +399,20 @@ func setupReconcilers(ctx context.Context, mgr ctrl.Manager, caCerts []byte) {
 		setupLog.Error(err, "unable to create controller", "controller", "OpenStackServer")
 		os.Exit(1)
 	}
+
+	if feature.Gates.Enabled(feature.AutoScaleFromZero) {
+		if err := (&controllers.OpenStackMachineTemplateReconciler{
+			Client:           mgr.GetClient(),
+			Recorder:         mgr.GetEventRecorderFor("openstackmachinetemplate-controller"),
+			WatchFilterValue: watchFilterValue,
+			ScopeFactory:     scopeFactory,
+			CaCertificates:   caCerts,
+		}).SetupWithManager(ctx, mgr, concurrency(openStackMachineTemplateConcurrency)); err != nil {
+			setupLog.Error(err, "unable to create controller", "controller", "OpenStackMachineTemplate")
+			os.Exit(1)
+		}
+	}
+
 }
 
 func setupWebhooks(mgr ctrl.Manager) {