func()

in internal/controller/teamcity_controller.go [75:144]
63 lines of code
15 McCabe index (conditional complexity)

func (r *TeamcityReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
	log := log.FromContext(ctx)

	var teamcity TeamCity
	var err error

	if teamcity, err = getTeamCityObjectE(r, ctx, req.NamespacedName); err != nil {
		if errors.IsNotFound(err) {
			return ctrl.Result{}, nil
		}
		return ctrl.Result{}, err
	}

	isMarkedForDeletion := teamcity.GetDeletionTimestamp() != nil
	if isMarkedForDeletion {
		log.V(1).Info("TeamCity object is marked for deletion")
		if err := r.finalizeTeamCity(ctx, &teamcity); err != nil {
			log.V(1).Error(err, "Failed to finalize TeamCity object")
			return ctrl.Result{}, err
		}
		log.V(1).Info("TeamCity object is finalized")
		controllerutil.RemoveFinalizer(&teamcity, teamcityFinalizer)
		log.V(1).Info("Finalizer is removed from TeamCity object")
		err := r.Update(ctx, &teamcity)
		if err != nil {
			log.V(1).Error(err, "Failed to update TeamCity object")
			return ctrl.Result{}, err
		}
		return ctrl.Result{}, nil
	}

	resourceBuilder := resource.TeamCityResourceBuilder{
		Instance: &teamcity,
		Scheme:   r.Scheme,
		Client:   r.Client,
	}
	isOngoingUpdate := ongoingZeroDowntimeUpgrade(r, ctx, &teamcity)
	if teamcity.UsesZeroDownTimeUpgradePolicy() || isOngoingUpdate {
		requeue, err := r.performZeroDowntimeUpgradeOrRequeue(ctx, &teamcity, isOngoingUpdate)
		if err != nil {
			return ctrl.Result{}, err
		}
		if requeue {
			log.V(1).Info("Update request will be re-queued")
			return ctrl.Result{Requeue: true, RequeueAfter: reconciliationRequeueInterval}, nil
		}
	}

	builders := resourceBuilder.ResourceBuilders()

	for _, builder := range builders {
		if _, err := r.reconcileDelete(ctx, builder); err != nil {
			return ctrl.Result{}, err
		}
		if preconditionSuccess := r.validatePreconditions(ctx, builder, teamcity); !preconditionSuccess {
			log.V(1).Info("Preconditions are not satisfied")
			return ctrl.Result{Requeue: true, RequeueAfter: time.Duration(reconciliationRequeueInterval)}, nil
		}

		if _, err := r.reconcileCreateOrUpdate(ctx, builder); err != nil {
			return ctrl.Result{}, err
		}
	}
	_ = updateTeamCityObjectStatusE(r, ctx, req.NamespacedName, TEAMCITY_CRD_OBJECT_SUCCESS_STATE, "Successfully reconciled TeamCity")
	if ongoingZeroDowntimeUpgrade(r, ctx, &teamcity) {
		log.V(1).Info("Detected an ongoing zero-downtime update. Update request will be re-queued")
		return ctrl.Result{Requeue: true, RequeueAfter: reconciliationRequeueInterval}, nil
	}
	return ctrl.Result{}, nil
}