cks_cluster_controller.go

/*
Copyright 2022 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"
	"fmt"
	"strings"

	ctrl "sigs.k8s.io/controller-runtime"
	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"

	infrav1 "sigs.k8s.io/cluster-api-provider-cloudstack/api/v1beta3"
	csCtrlrUtils "sigs.k8s.io/cluster-api-provider-cloudstack/controllers/utils"
)

const CksClusterFinalizer = "ckscluster.infrastructure.cluster.x-k8s.io"

// RBAC permissions for CloudStackCluster.
// +kubebuilder:rbac:groups=infrastructure.cluster.x-k8s.io,resources=cloudstackclusters,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=infrastructure.cluster.x-k8s.io,resources=cloudstackclusters/status,verbs=create;get;update;patch
// +kubebuilder:rbac:groups=infrastructure.cluster.x-k8s.io,resources=cloudstackclusters/finalizers,verbs=update

// CksClusterReconciliationRunner is a ReconciliationRunner with extensions specific to CloudStackClusters.
// The runner does the actual reconciliation.
type CksClusterReconciliationRunner struct {
	*csCtrlrUtils.ReconciliationRunner
	FailureDomains        *infrav1.CloudStackFailureDomainList
	ReconciliationSubject *infrav1.CloudStackCluster
}

// CksClusterReconciler is the k8s controller manager's interface to reconcile a CloudStackCluster.
// This is primarily to adapt to k8s.
type CksClusterReconciler struct {
	csCtrlrUtils.ReconcilerBase
}

// Initialize a new CloudStackCluster reconciliation runner with concrete types and initialized member fields.
func NewCksClusterReconciliationRunner() *CksClusterReconciliationRunner {
	// Set concrete type and init pointers.
	runner := &CksClusterReconciliationRunner{ReconciliationSubject: &infrav1.CloudStackCluster{}}
	runner.FailureDomains = &infrav1.CloudStackFailureDomainList{}
	// Setup the base runner. Initializes pointers and links reconciliation methods.
	runner.ReconciliationRunner = csCtrlrUtils.NewRunner(runner, runner.ReconciliationSubject, "CKSClusterController")
	runner.CSCluster = runner.ReconciliationSubject
	return runner
}

// Reconcile is the method k8s will call upon a reconciliation request.
func (reconciler *CksClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request) (retRes ctrl.Result, retErr error) {
	r := NewCksClusterReconciliationRunner()
	r.UsingBaseReconciler(reconciler.ReconcilerBase).ForRequest(req).WithRequestCtx(ctx)
	r.WithAdditionalCommonStages(r.GetFailureDomains(r.FailureDomains))
	return r.RunBaseReconciliationStages()
}

// Reconcile actually reconciles the CloudStackCluster.
func (r *CksClusterReconciliationRunner) Reconcile() (res ctrl.Result, reterr error) {
	if r.CSCluster.Spec.SyncWithACS {
		// Prevent premature deletion.
		controllerutil.AddFinalizer(r.ReconciliationSubject, CksClusterFinalizer)

		if len(r.FailureDomains.Items) == 0 {
			return r.RequeueWithMessage("No failure domains found")
		}

		res, err := r.AsFailureDomainUser(&r.FailureDomains.Items[0].Spec)()
		if r.ShouldReturn(res, err) {
			return res, err
		}

		r.Log.Info("Creating entry with CKS")
		err = r.CSUser.GetOrCreateUnmanagedCluster(r.CAPICluster, r.ReconciliationSubject, &r.FailureDomains.Items[0].Spec)
		if err != nil {
			if strings.Contains(err.Error(), "Kubernetes Service plugin is disabled") {
				r.Log.Info("Kubernetes Service plugin is disabled on CloudStack. Skipping ExternalManaged kubernetes cluster creation")
				return ctrl.Result{}, nil
			}
			r.Log.Info(fmt.Sprintf("Failed creating ExternalManaged kubernetes cluster on CloudStack. Error: %s", err.Error()))
			return r.RequeueWithMessage(fmt.Sprintf("Syncing VMs with CloudStack failed. error: %s", err.Error()))
		}
	}
	return ctrl.Result{}, nil
}

// ReconcileDelete cleans up resources used by the cluster and finally removes the CloudStackCluster's finalizers.
func (r *CksClusterReconciliationRunner) ReconcileDelete() (ctrl.Result, error) {
	if r.ReconciliationSubject.Status.CloudStackClusterID != "" {
		if len(r.FailureDomains.Items) == 0 {
			return ctrl.Result{}, fmt.Errorf("no failure domains found")
		}
		res, err := r.AsFailureDomainUser(&r.FailureDomains.Items[0].Spec)()
		if r.ShouldReturn(res, err) {
			return res, err
		}
		err = r.CSUser.DeleteUnmanagedCluster(r.ReconciliationSubject)
		if err != nil && !strings.Contains(err.Error(), " not found") {
			return r.RequeueWithMessage(fmt.Sprintf("Deleting unmanaged kubernetes cluster on CloudStack failed. error: %s", err.Error()))
		}
	}
	controllerutil.RemoveFinalizer(r.ReconciliationSubject, CksClusterFinalizer)
	return ctrl.Result{}, nil
}

// SetupWithManager sets up the controller with the Manager.
func (reconciler *CksClusterReconciler) SetupWithManager(mgr ctrl.Manager) error {
	return ctrl.NewControllerManagedBy(mgr).
		For(&infrav1.CloudStackCluster{}).
		Complete(reconciler)
}