func()

in shardingsphere-operator/pkg/controllers/storage_node_controller.go [144:191]

• 39 lines of code
• 10 McCabe index (conditional complexity)

func (r *StorageNodeReconciler) finalize(ctx context.Context, node *v1alpha1.StorageNode, storageProvider *v1alpha1.StorageProvider) (ctrl.Result, error) {
	var err error
	var oldStatus = node.Status.DeepCopy()

	switch node.Status.Phase {
	case v1alpha1.StorageNodePhaseReady, v1alpha1.StorageNodePhaseNotReady:
		// set storage node status to deleting
		node.Status.Phase = v1alpha1.StorageNodePhaseDeleting
	case v1alpha1.StorageNodePhaseDeleting:
		break
	case v1alpha1.StorageNodePhaseDeleteComplete:
		node.ObjectMeta.Finalizers = slices.Filter([]string{}, node.ObjectMeta.Finalizers, func(f string) bool {
			return f != FinalizerName
		})
		if err = r.Update(ctx, node); err != nil {
			r.Log.Error(err, "failed to remove finalizer")
		}
		return ctrl.Result{}, nil
	}

	if storageProvider.Spec.Provisioner == v1alpha1.ProvisionerCloudNativePG {
		return r.finalizeCloudNativePG(ctx, node, storageProvider)
	}

	// Try to unregister storage unit in shardingsphere.
	if err = r.unregisterStorageUnit(ctx, node); err != nil {
		r.Log.Error(err, "failed to delete storage unit")
		return ctrl.Result{RequeueAfter: defaultRequeueTime}, err
	}

	if err = r.deleteDatabaseCluster(ctx, node, storageProvider); err != nil {
		r.Log.Error(err, "failed to delete database cluster")
		return ctrl.Result{RequeueAfter: defaultRequeueTime}, err
	}

	desiredState := computeDesiredState(node.Status)

	if !reflect.DeepEqual(oldStatus, desiredState) {
		node.Status = desiredState
		err := r.Status().Update(ctx, node)
		if err != nil {
			r.Log.Error(err, fmt.Sprintf("unable to update StorageNode %s/%s", node.GetNamespace(), node.GetName()))
			return ctrl.Result{Requeue: true}, err
		}
	}

	return ctrl.Result{RequeueAfter: defaultRequeueTime}, nil
}