Use generics for cleaning up all resources

Signed-off-by: Brendan Shephard <bshephar@fedora-g16.bne-home.net>

Author: Brendan Shephard

internal/controller/operator/openstack_controller.go

@@ -43,6 +43,7 @@ import (
 	"github.com/openstack-k8s-operators/openstack-operator/internal/operator"
 	"github.com/openstack-k8s-operators/openstack-operator/internal/operator/bindata"
 	"github.com/pkg/errors"
+	admissionv1 "k8s.io/api/admissionregistration/v1"
 	appsv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
 	discoveryv1 "k8s.io/api/discovery/v1"
@@ -349,85 +350,63 @@ func (r *OpenStackReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 
 }
 
-func (r *OpenStackReconciler) deleteAllOwnedResources(ctx context.Context, instance *operatorv1beta1.OpenStack) error {
-	Log := r.GetLogger(ctx)
-	Log.Info("Deleting all owned resources for release version upgrade")
+func deleteOwnedResources[L any, T any](
+	ctx context.Context,
+	r *OpenStackReconciler,
+	instance client.Object,
+	list L,
+	itemsGetter func(L) []T,
+) error {
+	log := r.GetLogger(ctx)
 
-	// Delete all owned deployments
-	deployments := &appsv1.DeploymentList{}
-	err := r.List(ctx, deployments, &client.ListOptions{Namespace: instance.Namespace})
+	err := r.List(ctx, any(list).(client.ObjectList), &client.ListOptions{Namespace: instance.GetNamespace()})
 	if err != nil {
-		return errors.Wrap(err, "failed to list deployments")
+		return errors.Wrap(err, "failed to list resources")
 	}
-	for _, deployment := range deployments.Items {
-		if metav1.IsControlledBy(&deployment, instance) {
-			Log.Info("Deleting deployment", "name", deployment.Name)
-			err := r.Delete(ctx, &deployment)
+
+	for _, item := range itemsGetter(list) {
+		obj := any(&item).(client.Object)
+		if metav1.IsControlledBy(obj, instance) {
+			log.Info("Deleting owned resource", "kind", obj.GetObjectKind().GroupVersionKind().Kind, "name", obj.GetName())
+			err := r.Delete(ctx, obj)
 			if err != nil && !apierrors.IsNotFound(err) {
-				return errors.Wrapf(err, "failed to delete deployment %s", deployment.Name)
+				return errors.Wrapf(err, "failed to delete %s", obj.GetName())
 			}
 		}
 	}
+	return nil
+}
+
+func (r *OpenStackReconciler) deleteAllOwnedResources(ctx context.Context, instance *operatorv1beta1.OpenStack) error {
+	Log := r.GetLogger(ctx)
+	Log.Info("Deleting all owned resources for release version upgrade")
 
-	// Delete all owned service accounts
-	serviceAccounts := &corev1.ServiceAccountList{}
-	err = r.List(ctx, serviceAccounts, &client.ListOptions{Namespace: instance.Namespace})
+	err := deleteOwnedResources(ctx, r, instance, &appsv1.DeploymentList{}, func(l *appsv1.DeploymentList) []appsv1.Deployment { return l.Items })
 	if err != nil {
-		return errors.Wrap(err, "failed to list service accounts")
-	}
-	for _, sa := range serviceAccounts.Items {
-		if metav1.IsControlledBy(&sa, instance) {
-			Log.Info("Deleting service account", "name", sa.Name)
-			err := r.Delete(ctx, &sa)
-			if err != nil && !apierrors.IsNotFound(err) {
-				return errors.Wrapf(err, "failed to delete service account %s", sa.Name)
-			}
-		}
+		return err
 	}
 
-	// Delete all owned services
-	services := &corev1.ServiceList{}
-	err = r.List(ctx, services, &client.ListOptions{Namespace: instance.Namespace})
+	err = deleteOwnedResources(ctx, r, instance, &corev1.ServiceAccountList{}, func(l *corev1.ServiceAccountList) []corev1.ServiceAccount { return l.Items })
 	if err != nil {
-		return errors.Wrap(err, "failed to list services")
-	}
-	for _, svc := range services.Items {
-		if metav1.IsControlledBy(&svc, instance) {
-			Log.Info("Deleting service", "name", svc.Name)
-			err := r.Delete(ctx, &svc)
-			if err != nil && !apierrors.IsNotFound(err) {
-				return errors.Wrapf(err, "failed to delete service %s", svc.Name)
-			}
-		}
+		return err
 	}
 
-	// Delete webhooks (these are cluster-scoped and not owned, but managed by label)
-	valWebhooks, err := r.Kclient.AdmissionregistrationV1().ValidatingWebhookConfigurations().List(ctx, metav1.ListOptions{
-		LabelSelector: "openstack.openstack.org/managed=true",
-	})
+	err = deleteOwnedResources(ctx, r, instance, &corev1.ServiceList{}, func(l *corev1.ServiceList) []corev1.Service { return l.Items })
 	if err != nil {
-		return errors.Wrap(err, "failed listing validating webhook configurations")
-	}
-	for _, webhook := range valWebhooks.Items {
-		Log.Info("Deleting validating webhook", "name", webhook.Name)
-		err := r.Kclient.AdmissionregistrationV1().ValidatingWebhookConfigurations().Delete(ctx, webhook.Name, metav1.DeleteOptions{})
-		if err != nil && !apierrors.IsNotFound(err) {
-			return errors.Wrapf(err, "failed to delete validating webhook %s", webhook.Name)
-		}
+		return err
 	}
 
-	mutWebhooks, err := r.Kclient.AdmissionregistrationV1().MutatingWebhookConfigurations().List(ctx, metav1.ListOptions{
-		LabelSelector: "openstack.openstack.org/managed=true",
+	labelSelector, _ := metav1.LabelSelectorAsSelector(&metav1.LabelSelector{
+		MatchLabels: map[string]string{"openstack.openstack.org/managed": "true"},
 	})
-	if err != nil {
-		return errors.Wrap(err, "failed listing mutating webhook configurations")
+
+	deleteOpts := client.DeleteAllOfOptions{
+		ListOptions: client.ListOptions{LabelSelector: labelSelector},
 	}
-	for _, webhook := range mutWebhooks.Items {
-		Log.Info("Deleting mutating webhook", "name", webhook.Name)
-		err := r.Kclient.AdmissionregistrationV1().MutatingWebhookConfigurations().Delete(ctx, webhook.Name, metav1.DeleteOptions{})
-		if err != nil && !apierrors.IsNotFound(err) {
-			return errors.Wrapf(err, "failed to delete mutating webhook %s", webhook.Name)
-		}
+
+	err = r.Client.DeleteAllOf(ctx, &admissionv1.ValidatingWebhookConfiguration{}, &deleteOpts)
+	if err != nil && !apierrors.IsNotFound(err) {
+		return errors.Wrap(err, "failed to delete validating webhooks")
 	}
 
 	Log.Info("All owned resources deleted successfully")
@@ -1105,7 +1084,7 @@ func (r *OpenStackReconciler) postCleanupObsoleteResources(ctx context.Context,
 				// The horizon-operator.openstack-operators has references to old roles/bindings
 				// the code below will delete those references before continuing
 				for _, ref := range refs {
-					refData := ref.(map[string]interface{})
+					refData := ref.(map[string]any)
 					Log.Info("Deleting operator reference", "Reference", ref)
 					obj := uns.Unstructured{}
 					obj.SetName(refData["name"].(string))