func()

in controllers/keycloakrealmcomponent/keycloakrealmcomponent_controller.go [103:180]

• 62 lines of code
• 15 McCabe index (conditional complexity)

func (r *Reconcile) Reconcile(ctx context.Context, request reconcile.Request) (reconcile.Result, error) {
	log := ctrl.LoggerFrom(ctx)
	log.Info("Reconciling KeycloakRealmComponent")

	keycloakRealmComponent := &keycloakApi.KeycloakRealmComponent{}
	if err := r.client.Get(ctx, request.NamespacedName, keycloakRealmComponent); err != nil {
		if k8sErrors.IsNotFound(err) {
			return reconcile.Result{}, nil
		}

		return ctrl.Result{}, fmt.Errorf("unable to get KeycloakRealmComponent: %w", err)
	}

	if updated, err := r.applyDefaults(ctx, keycloakRealmComponent); err != nil {
		return ctrl.Result{}, fmt.Errorf("unable to apply defaults: %w", err)
	} else if updated {
		return ctrl.Result{}, nil
	}

	err := r.helper.SetRealmOwnerRef(ctx, keycloakRealmComponent)
	if err != nil {
		return ctrl.Result{}, fmt.Errorf("unable to get realm owner ref: %w", err)
	}

	if err = r.setComponentOwnerReference(ctx, keycloakRealmComponent); err != nil {
		return reconcile.Result{}, err
	}

	kClient, err := r.helper.CreateKeycloakClientFromRealmRef(ctx, keycloakRealmComponent)
	if err != nil {
		if errors.Is(err, helper.ErrKeycloakIsNotAvailable) {
			return ctrl.Result{
				RequeueAfter: helper.RequeueOnKeycloakNotAvailablePeriod,
			}, nil
		}

		return ctrl.Result{}, fmt.Errorf("unable to create keycloak client: %w", err)
	}

	realm, err := r.helper.GetKeycloakRealmFromRef(ctx, keycloakRealmComponent, kClient)
	if err != nil {
		return ctrl.Result{}, fmt.Errorf("unable to get realm: %w", err)
	}

	term := makeTerminator(
		gocloak.PString(realm.Realm),
		keycloakRealmComponent.Spec.Name,
		kClient,
		objectmeta.PreserveResourcesOnDeletion(keycloakRealmComponent),
	)

	if deleted, err := r.helper.TryToDelete(ctx, keycloakRealmComponent, term, finalizerName); err != nil {
		return ctrl.Result{}, fmt.Errorf("unable to tryToDelete realm component %w", err)
	} else if deleted {
		return reconcile.Result{}, nil
	}

	if err := r.tryReconcile(ctx, keycloakRealmComponent, gocloak.PString(realm.Realm), kClient); err != nil {
		keycloakRealmComponent.Status.Value = err.Error()
		requeueAfter := r.helper.SetFailureCount(keycloakRealmComponent)

		if statusErr := r.client.Status().Update(ctx, keycloakRealmComponent); statusErr != nil {
			return ctrl.Result{}, fmt.Errorf("unable to update KeycloakRealmComponent status: %w", statusErr)
		}

		return ctrl.Result{
			RequeueAfter: requeueAfter,
		}, fmt.Errorf("unable to reconcile KeycloakRealmComponent: %w", err)
	}

	helper.SetSuccessStatus(keycloakRealmComponent)

	if err := r.client.Status().Update(ctx, keycloakRealmComponent); err != nil {
		return ctrl.Result{}, fmt.Errorf("unable to update KeycloakRealmComponent status: %w", err)
	}

	return reconcile.Result{}, nil
}