controllers: add a new controller to handle provider upgrades

Signed-off-by: Rewant Soni <[email protected]>

Author: rewantsoni

controllers/storageconsumer/storageconsumer_upgrade_controller.go

@@ -0,0 +1,214 @@
+/*
+Copyright 2021 Red Hat OpenShift Container Storage.
+
+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"
+	"crypto/md5"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	ocsv1alpha1 "github.com/red-hat-storage/ocs-operator/api/v4/v1alpha1"
+	"github.com/red-hat-storage/ocs-operator/v4/controllers/util"
+
+	"github.com/go-logr/logr"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/runtime"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/builder"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
+	"sigs.k8s.io/controller-runtime/pkg/event"
+	"sigs.k8s.io/controller-runtime/pkg/log"
+	"sigs.k8s.io/controller-runtime/pkg/predicate"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+)
+
+// StorageConsumerReconciler reconciles a StorageConsumer object
+type StorageConsumerUpgradeReconciler struct {
+	client.Client
+	Scheme *runtime.Scheme
+
+	log logr.Logger
+}
+
+// SetupWithManager sets up the controller with the Manager.
+func (r *StorageConsumerUpgradeReconciler) SetupWithManager(mgr ctrl.Manager) error {
+
+	operatorVersionPredicate := predicate.Funcs{
+		CreateFunc: func(e event.TypedCreateEvent[client.Object]) bool {
+			if e.Object == nil {
+				return false
+			}
+			obj := e.Object.(*ocsv1alpha1.StorageConsumer)
+			return strings.HasPrefix(obj.Status.Client.OperatorVersion, "4.18")
+		},
+		UpdateFunc: func(e event.UpdateEvent) bool {
+			if e.ObjectOld == nil || e.ObjectNew == nil {
+				return false
+			}
+			newObj := e.ObjectNew.(*ocsv1alpha1.StorageConsumer)
+			return strings.HasPrefix(newObj.Status.Client.OperatorVersion, "4.18")
+		},
+	}
+
+	return ctrl.NewControllerManagedBy(mgr).
+		For(&ocsv1alpha1.StorageConsumer{}, builder.WithPredicates(operatorVersionPredicate)).
+		Complete(r)
+}
+
+// +kubebuilder:rbac:groups=ocs.openshift.io,resources=storageconsumers,verbs=get;watch;create;update
+// +kubebuilder:rbac:groups=core,resources=configmaps,verbs=get;create;update
+
+func (r *StorageConsumerUpgradeReconciler) Reconcile(ctx context.Context, request reconcile.Request) (reconcile.Result, error) {
+
+	r.log = log.FromContext(ctx, "StorageConsumerUpgrade", request.NamespacedName)
+
+	storageConsumer := &ocsv1alpha1.StorageConsumer{}
+	storageConsumer.Name = request.Name
+	storageConsumer.Namespace = request.Namespace
+
+	if err := r.Client.Get(ctx, client.ObjectKeyFromObject(storageConsumer), storageConsumer); err != nil {
+		if errors.IsNotFound(err) {
+			r.log.Info("No StorageConsumer resource.")
+			// Request object not found, could have been deleted after reconcile request.
+			// Owned objects are automatically garbage collected. For additional cleanup logic use finalizers.
+			// Return and don't requeue
+			return reconcile.Result{}, nil
+		}
+		// Error reading the object - requeue the request.
+		r.log.Error(err, "Failed to retrieve StorageConsumer.")
+		return reconcile.Result{}, err
+	}
+
+	storageCluster, err := util.GetStorageClusterInNamespace(ctx, r.Client, storageConsumer.Namespace)
+	if err != nil {
+		return reconcile.Result{}, err
+	}
+
+	availableServices, err := util.GetAvailableServices(ctx, r.Client, storageCluster)
+	if err != nil {
+		return ctrl.Result{}, fmt.Errorf("failed to get available services configured in StorageCluster: %v", err)
+	}
+
+	consumerConfigMap := &corev1.ConfigMap{}
+	consumerConfigMap.Name = fmt.Sprintf("storageconsumer-%v", util.FnvHash(storageConsumer.Name))
+	consumerConfigMap.Namespace = storageConsumer.Namespace
+
+	if _, err := controllerutil.CreateOrUpdate(ctx, r.Client, consumerConfigMap, func() error {
+		data := util.GetStorageConsumerDefaultResourceNames(
+			storageConsumer.Name,
+			string(storageConsumer.UID),
+			availableServices,
+		)
+		resourceMap := util.WrapStorageConsumerResourceMap(data)
+
+		rbdClaimName := util.GenerateNameForCephBlockPoolSC(storageCluster)
+		cephFsClaimName := util.GenerateNameForCephFilesystemSC(storageCluster)
+
+		rbdStorageRequestHash := getStorageRequestName(string(storageConsumer.UID), rbdClaimName)
+		cephFsStorageRequestHash := getStorageRequestName(string(storageConsumer.UID), cephFsClaimName)
+
+		md5Sum := md5.Sum([]byte(rbdStorageRequestHash))
+		rnsName := fmt.Sprintf("cephradosnamespace-%s", hex.EncodeToString(md5Sum[:16]))
+
+		md5Sum = md5.Sum([]byte(cephFsStorageRequestHash))
+		svgName := fmt.Sprintf("cephfilesystemsubvolumegroup-%s", hex.EncodeToString(md5Sum[:16]))
+
+		rbdClientProfile := getMD5Hash(rbdClaimName)
+		cephFSClientProfile := getMD5Hash(cephFsClaimName)
+
+		rbdNodeSecretName := storageClaimCephCsiSecretName("node", rbdStorageRequestHash)
+		rbdProvisionerSecretName := storageClaimCephCsiSecretName("provisioner", rbdStorageRequestHash)
+
+		cephFsNodeSecretName := storageClaimCephCsiSecretName("node", cephFsStorageRequestHash)
+		cephFsProvisionerSecretName := storageClaimCephCsiSecretName("provisioner", cephFsStorageRequestHash)
+
+		resourceMap.ReplaceRbdRadosNamespaceName(rnsName)
+		resourceMap.ReplaceSubVolumeGroupName(svgName)
+		resourceMap.ReplaceSubVolumeGroupRadosNamespaceName("csi")
+		resourceMap.ReplaceRbdClientProfileName(rbdClientProfile)
+		resourceMap.ReplaceCephFsClientProfileName(cephFSClientProfile)
+		resourceMap.ReplaceCsiRbdNodeSecretName(rbdNodeSecretName)
+		resourceMap.ReplaceCsiRbdProvisionerSecretName(rbdProvisionerSecretName)
+		resourceMap.ReplaceCsiCephFsNodeSecretName(cephFsNodeSecretName)
+		resourceMap.ReplaceCsiCephFsProvisionerSecretName(cephFsProvisionerSecretName)
+		consumerConfigMap.Data = data
+		return nil
+	}); err != nil {
+		return reconcile.Result{}, err
+	}
+
+	if _, err := controllerutil.CreateOrUpdate(ctx, r.Client, storageConsumer, func() error {
+		spec := &storageConsumer.Spec
+		spec.ResourceNameMappingConfigMap.Name = consumerConfigMap.Name
+		spec.StorageClasses = []ocsv1alpha1.StorageClassSpec{
+			{Name: util.GenerateNameForCephBlockPoolSC(storageCluster)},
+			{Name: util.GenerateNameForCephFilesystemSC(storageCluster)},
+		}
+		spec.VolumeSnapshotClasses = []ocsv1alpha1.VolumeSnapshotClassSpec{
+			{Name: util.GenerateNameForSnapshotClass(storageCluster.Name, util.RbdSnapshotter)},
+			{Name: util.GenerateNameForSnapshotClass(storageCluster.Name, util.CephfsSnapshotter)},
+		}
+		spec.VolumeGroupSnapshotClasses = []ocsv1alpha1.VolumeGroupSnapshotClassSpec{
+			{Name: util.GenerateNameForGroupSnapshotClass(storageCluster, util.RbdGroupSnapshotter)},
+			{Name: util.GenerateNameForGroupSnapshotClass(storageCluster, util.CephfsGroupSnapshotter)},
+		}
+		util.AddAnnotation(storageConsumer, util.StorageConsumer418ProcessedAnnotationKey, util.StorageConsumer418ProcessedAnnotationProcessed)
+		return nil
+	}); err != nil {
+		return reconcile.Result{}, err
+	}
+
+	return reconcile.Result{}, nil
+}
+
+// getStorageRequestHash generates a hash for a StorageRequest based
+// on the MD5 hash of the StorageClaim name and storageConsumer UUID.
+func getStorageRequestHash(consumerUUID, storageClaimName string) string {
+	s := struct {
+		StorageConsumerUUID string `json:"storageConsumerUUID"`
+		StorageClaimName    string `json:"storageClaimName"`
+	}{
+		consumerUUID,
+		storageClaimName,
+	}
+
+	requestName, err := json.Marshal(s)
+	if err != nil {
+		panic("failed to marshal storage class request name")
+	}
+	md5Sum := md5.Sum(requestName)
+	return hex.EncodeToString(md5Sum[:16])
+}
+
+// getStorageRequestName generates a name for a StorageRequest resource.
+func getStorageRequestName(consumerUUID, storageClaimName string) string {
+	return fmt.Sprintf("storagerequest-%s", getStorageRequestHash(consumerUUID, storageClaimName))
+}
+
+func getMD5Hash(text string) string {
+	hash := md5.Sum([]byte(text))
+	return hex.EncodeToString(hash[:])
+}
+
+func storageClaimCephCsiSecretName(secretType, suffix string) string {
+	return fmt.Sprintf("ceph-client-%s-%s", secretType, suffix)
+}

controllers/util/storageconsumer.go

@@ -13,7 +13,9 @@ import (
 
 const (
 	// Reserved RadosNamespaceName for internal use and their representation at different layes
-	ImplicitRbdRadosNamespaceName = "<implicit>"
+	ImplicitRbdRadosNamespaceName                  = "<implicit>"
+	StorageConsumer418ProcessedAnnotationKey       = "ocs.openshift.io/storageconsumer-4-18-processed"
+	StorageConsumer418ProcessedAnnotationProcessed = "processed"
 
 	// Constants for ConfigMap keys
 	rbdRadosNamespaceKey            = "rbd-rados-ns"

main.go

@@ -261,6 +261,14 @@ func main() {
 		os.Exit(1)
 	}
 
+	if err = (&controllers.StorageConsumerUpgradeReconciler{
+		Client: mgr.GetClient(),
+		Scheme: mgr.GetScheme(),
+	}).SetupWithManager(mgr); err != nil {
+		setupLog.Error(err, "unable to create controller", "controller", "StorageConsumerUpgrade")
+		os.Exit(1)
+	}
+
 	// shared event channel and sync map and scrapeInterval between the scraper and the reconciler
 	eventCh := make(chan event.GenericEvent)
 	syncMap := &sync.Map{}