Works on single host. Should work on two. We'll see...

Author: Joshua Reed

controllers/cloudstackfailuredomain_controller.go

@@ -106,7 +106,7 @@ func (r *CloudStackFailureDomainReconciliationRunner) Reconcile() (retRes ctrl.R
 
 // ReconcileDelete on the ReconciliationRunner actually attempts to delete the reconciliation subject.
 func (r *CloudStackFailureDomainReconciliationRunner) ReconcileDelete() (retRes ctrl.Result, retErr error) {
-	r.Log.Info("Deleting CloudStackZone")
+	r.Log.Info("Deleting CloudStackFailureDomain")
 	// Address Isolated Networks.
 	if r.ReconciliationSubject.Spec.Zone.Network.Type == infrav1.NetworkTypeIsolated {
 		netName := r.ReconciliationSubject.Spec.Zone.Network.Name

controllers/cloudstackisolatednetwork_controller.go

@@ -22,6 +22,7 @@ import (
 
 	"sigs.k8s.io/cluster-api/util/patch"
 	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 
 	"github.com/pkg/errors"
@@ -57,27 +58,17 @@ func NewCSIsoNetReconciliationRunner() *CloudStackIsoNetReconciliationRunner {
 }
 
 func (reconciler *CloudStackIsoNetReconciler) Reconcile(ctx context.Context, req ctrl.Request) (res ctrl.Result, retErr error) {
-	return NewCSIsoNetReconciliationRunner().
-		UsingBaseReconciler(reconciler.ReconcilerBase).
-		ForRequest(req).
-		WithRequestCtx(ctx).
-		RunBaseReconciliationStages()
+	r := NewCSIsoNetReconciliationRunner()
+	r.UsingBaseReconciler(reconciler.ReconcilerBase).ForRequest(req).WithRequestCtx(ctx)
+	r.WithAdditionalCommonStages(
+		r.GetParent(r.ReconciliationSubject, r.FailureDomain),
+		r.CheckPresent(map[string]client.Object{"CloudStackFailureDomain": r.FailureDomain}),
+		r.AsFailureDomainUser(&r.FailureDomain.Spec),
+	)
+	return r.RunBaseReconciliationStages()
 }
 
 func (r *CloudStackIsoNetReconciliationRunner) Reconcile() (retRes ctrl.Result, retErr error) {
-	if res, err := r.GetParent(r.ReconciliationSubject, r.FailureDomain)(); r.ShouldReturn(res, err) {
-		return res, err
-	}
-	if r.FailureDomain.Spec.Name == "" {
-		return ctrl.Result{}, errors.New("couldn't get parent Failure Domain for placement")
-	}
-	res, err := r.AsFailureDomainUser(&r.FailureDomain.Spec)()
-	if r.ShouldReturn(res, err) {
-		return res, err
-	}
-	if res, err := r.RequeueIfMissingBaseCRs(); r.ShouldReturn(res, err) {
-		return res, err
-	}
 	controllerutil.AddFinalizer(r.ReconciliationSubject, infrav1.IsolatedNetworkFinalizer)
 
 	// Setup isolated network, endpoint, egress, and load balancing.

controllers/cloudstackmachine_controller.go

@@ -82,22 +82,21 @@ func NewCSMachineReconciliationRunner() *CloudStackMachineReconciliationRunner {
 // Reconcile is part of the main kubernetes reconciliation loop which aims to
 // move the current state of the cluster closer to the desired state.
 func (reconciler *CloudStackMachineReconciler) Reconcile(ctx context.Context, req ctrl.Request) (res ctrl.Result, retErr error) {
-	return NewCSMachineReconciliationRunner().
-		UsingBaseReconciler(reconciler.ReconcilerBase).
-		ForRequest(req).
-		WithRequestCtx(ctx).
-		RunBaseReconciliationStages()
-}
-
-func (r *CloudStackMachineReconciliationRunner) Reconcile() (retRes ctrl.Result, reterr error) {
-	return r.RunReconciliationStages(
+	r := NewCSMachineReconciliationRunner()
+	r.UsingBaseReconciler(reconciler.ReconcilerBase).ForRequest(req).WithRequestCtx(ctx)
+	r.WithAdditionalCommonStages(
 		r.GetParent(r.ReconciliationSubject, r.CAPIMachine),
 		r.RequeueIfCloudStackClusterNotReady,
 		r.SetFailureDomainOnCSMachine,
 		r.GetObjectByName("placeholder", r.FailureDomain,
 			func() string { return r.ReconciliationSubject.Spec.FailureDomain.Name }),
 		r.CheckPresent(map[string]client.Object{"CloudStackFailureDomain": r.FailureDomain}),
-		r.AsFailureDomainUser(&r.FailureDomain.Spec),
+		r.AsFailureDomainUser(&r.FailureDomain.Spec))
+	return r.RunBaseReconciliationStages()
+}
+
+func (r *CloudStackMachineReconciliationRunner) Reconcile() (retRes ctrl.Result, reterr error) {
+	return r.RunReconciliationStages(
 		r.GetObjectByName("placeholder", r.IsoNet,
 			func() string { return r.IsoNetMetaName(r.FailureDomain.Spec.Zone.Network.Name) }),
 		r.RunIf(func() bool { return r.FailureDomain.Spec.Zone.Network.Type == cloud.NetworkTypeIsolated },
@@ -145,7 +144,7 @@ func (r *CloudStackMachineReconciliationRunner) SetFailureDomainOnCSMachine() (r
 	return ctrl.Result{}, nil
 }
 
-// GetOrCreateVMInstance creates or gets a VM instance.
+// GetOrCreateVMInstance gets or creates a VM instance.
 // Implicitly it also fetches its bootstrap secret in order to create said instance.
 func (r *CloudStackMachineReconciliationRunner) GetOrCreateVMInstance() (retRes ctrl.Result, reterr error) {
 	if r.CAPIMachine.Spec.Bootstrap.DataSecretName == nil {
@@ -224,9 +223,6 @@ func (r *CloudStackMachineReconciliationRunner) GetOrCreateMachineStateChecker()
 }
 
 func (r *CloudStackMachineReconciliationRunner) ReconcileDelete() (retRes ctrl.Result, reterr error) {
-	if res, err := r.AsFailureDomainUser(&r.ReconciliationSubject.Spec.FailureDomain)(); r.ShouldReturn(res, err) {
-		return res, err
-	}
 	if r.ReconciliationSubject.Spec.InstanceID != nil {
 		r.Log.Info("Deleting instance", "instance-id", r.ReconciliationSubject.Spec.InstanceID)
 		// Use CSClient instead of CSUser here to expunge as admin.
@@ -247,7 +243,6 @@ func (r *CloudStackMachineReconciliationRunner) ReconcileDelete() (retRes ctrl.R
 
 // SetupWithManager registers the machine reconciler to the CAPI controller manager.
 func (reconciler *CloudStackMachineReconciler) SetupWithManager(mgr ctrl.Manager) error {
-
 	controller, err := ctrl.NewControllerManagedBy(mgr).
 		For(&infrav1.CloudStackMachine{}).
 		WithEventFilter(

controllers/utils/base_reconciler.go

@@ -63,13 +63,14 @@ type CloudStackBaseContext struct {
 type ReconciliationRunner struct {
 	ReconcilerBase
 	CloudStackBaseContext
-	ReconciliationSubject client.Object // Underlying crd interface.
-	ConditionalResult     bool          // Stores a conidtinal result for stringing if else type methods.
-	returnEarly           bool          // A signal that the reconcile should return early.
-	ReconcileDelete       CloudStackReconcilerMethod
-	Reconcile             CloudStackReconcilerMethod
-	CSUser                cloud.Client
-	ControllerKind        string
+	ReconciliationSubject  client.Object // Underlying crd interface.
+	ConditionalResult      bool          // Stores a conidtinal result for stringing if else type methods.
+	returnEarly            bool          // A signal that the reconcile should return early.
+	additionalCommonStages []CloudStackReconcilerMethod
+	ReconcileDelete        CloudStackReconcilerMethod
+	Reconcile              CloudStackReconcilerMethod
+	CSUser                 cloud.Client
+	ControllerKind         string
 }
 
 type ConcreteRunner interface {
@@ -110,6 +111,12 @@ func (r *ReconciliationRunner) WithRequestCtx(ctx context.Context) *Reconciliati
 	return r
 }
 
+// WithRequestCtx sets the request context.
+func (r *ReconciliationRunner) WithAdditionalCommonStages(fns ...CloudStackReconcilerMethod) *ReconciliationRunner {
+	r.additionalCommonStages = fns
+	return r
+}
+
 // SetupLogger sets up the reconciler's logger to log with name and namespace values.
 func (r *ReconciliationRunner) SetupLogger() (res ctrl.Result, retErr error) {
 	r.Log = r.BaseLogger.WithName(r.ControllerKind).WithValues("name", r.Request.Name, "namespace", r.Request.Namespace)
@@ -237,30 +244,6 @@ func (r *ReconciliationRunner) CheckOwnedCRDsForReadiness(gvks ...schema.GroupVe
 	}
 }
 
-// SetCSUser sets the CSUser client to any user that can operate in specified domain and account if specified.
-func (r *ReconciliationRunner) SetCSUser() (ctrl.Result, error) {
-	// TODO: Remove no-op.
-	// r.CSUser = r.CSClient
-	// if r.CSCluster.Spec.Account != "" {
-	// 	user := &cloud.User{}
-	// 	user.Account.Domain.Path = r.CSCluster.Spec.Domain
-	// 	user.Account.Name = r.CSCluster.Spec.Account
-	// 	if found, err := r.CSClient.GetUserWithKeys(user); err != nil {
-	// 		return ctrl.Result{}, err
-	// 	} else if !found {
-	// 		return ctrl.Result{}, errors.Errorf("could not find sufficient user (with API keys) in domain/account %s/%s",
-	// 			r.CSCluster.Spec.Domain, r.CSCluster.Spec.Account)
-	// 	}
-	// 	cfg := cloud.Config{APIKey: user.APIKey, SecretKey: user.SecretKey}
-	// 	client, err := r.CSClient.NewClientFromSpec(cfg)
-	// 	if err != nil {
-	// 		return ctrl.Result{}, err
-	// 	}
-	// 	r.CSUser = client
-	// }
-	return ctrl.Result{}, nil
-}
-
 // RequeueIfCloudStackClusterNotReady requeues the reconciliation request if the CloudStackCluster is not ready.
 func (r *ReconciliationRunner) RequeueIfCloudStackClusterNotReady() (ctrl.Result, error) {
 	if !r.CSCluster.Status.Ready {
@@ -357,16 +340,21 @@ func (r *ReconciliationRunner) RunBaseReconciliationStages() (res ctrl.Result, r
 			}
 		}
 	}()
-	return r.RunReconciliationStages(
+
+	// Inject common stages prior to calling Reconcile or ReconcileDelete.
+	baseStages := []CloudStackReconcilerMethod{
 		r.SetupLogger,
 		r.GetReconciliationSubject,
 		r.SetupPatcher,
 		r.GetCAPICluster,
 		r.GetCSCluster,
-		r.RequeueIfMissingBaseCRs,
+		r.RequeueIfMissingBaseCRs}
+	baseStages = append(
+		append(baseStages, r.additionalCommonStages...),
 		r.IfDeletionTimestampIsZero(r.Reconcile),
-		r.Else(r.ReconcileDelete),
-	)
+		r.Else(r.ReconcileDelete))
+
+	return r.RunReconciliationStages(baseStages...)
 }
 
 // CheckIfPaused returns with requeue later set if paused.
@@ -378,13 +366,19 @@ func (r *ReconciliationRunner) CheckIfPaused() (ctrl.Result, error) {
 	return reconcile.Result{}, nil
 }
 
+// SetReturnEarly sets the runner to return early. This causes the runner to break from running further
+// reconciliation stages and return whatever result the current method returns.
+func (r *ReconciliationRunner) SetReturnEarly() {
+	r.returnEarly = true
+}
+
 // GetReconcilationSubject gets the reconciliation subject of type defined by the concrete reconciler. It also sets up
 // a patch helper at this point.
 func (r *ReconciliationRunner) GetReconciliationSubject() (res ctrl.Result, reterr error) {
 	r.Log.V(1).Info("Getting reconciliation subject.")
 	err := client.IgnoreNotFound(r.K8sClient.Get(r.RequestCtx, r.Request.NamespacedName, r.ReconciliationSubject))
-	if r.ReconciliationSubject.GetName() == "" {
-		return ctrl.Result{}, errors.Errorf("Could not fetch object by namespaced name: %s", r.Request.NamespacedName)
+	if r.ReconciliationSubject.GetName() == "" { // Resource does not exist. No need to reconcile.
+		r.SetReturnEarly()
 	}
 	if err != nil {
 		return ctrl.Result{}, errors.Wrap(err, "fetching reconciliation subject")
@@ -403,7 +397,7 @@ func (r *ReconciliationRunner) SetReconciliationSubjectToConcreteSubject(subject
 // InitFromMgr just initiates a ReconcilerBase using given manager's fields/methods.
 func (r *ReconcilerBase) InitFromMgr(mgr ctrl.Manager, client cloud.Client) {
 	r.K8sClient = mgr.GetClient()
-	r.BaseLogger = ctrl.Log.WithName("controllers").WithName("name")
+	r.BaseLogger = ctrl.Log.WithName("controllers")
 	r.Scheme = mgr.GetScheme()
 	r.CSClient = client
 }