func()

in controllers/codebasebranch/codebasebranch_controller.go [104:195]

• 66 lines of code
• 18 McCabe index (conditional complexity)

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

	log.Info("Reconciling CodebaseBranch")

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

		return reconcile.Result{}, fmt.Errorf("failed to fetch CodebaseBranch resource %q: %w", request.NamespacedName, err)
	}

	c := &codebaseApi.Codebase{}
	if err := r.client.Get(ctx, types.NamespacedName{Name: cb.Spec.CodebaseName, Namespace: cb.Namespace}, c); err != nil {
		return reconcile.Result{}, fmt.Errorf("failed to get Codebase: %w", err)
	}

	updated, err := r.setDefaultValues(ctx, cb, c)
	if err != nil {
		return reconcile.Result{}, fmt.Errorf("failed to set default values: %w", err)
	}

	if updated {
		if err = r.client.Update(ctx, cb); err != nil {
			return reconcile.Result{}, fmt.Errorf("failed to update CodebaseBranch: %w", err)
		}

		return reconcile.Result{}, nil
	}

	if err = r.setOwnerRef(cb, c); err != nil {
		setErrorStatus(cb, err.Error())

		if err = r.updateStatus(ctx, cb); err != nil {
			log.Error(err, "error on codebase branch update status")
		}

		return reconcile.Result{}, fmt.Errorf("failed to set OwnerRef for codebasebranch %v: %w", cb.Name, err)
	}

	if err = codebasebranch.AddCodebaseLabel(ctx, r.client, cb, c.Name); err != nil {
		log.Error(err, "set labels failed")
	}

	result, err := r.tryToDeleteCodebaseBranch(ctx, cb, factory.GetDeletionChain())
	if err != nil {
		return reconcile.Result{}, fmt.Errorf("failed to remove codebasebranch %v: %w", cb.Name, err)
	}

	if result != nil {
		return *result, nil
	}

	// this is a case where we want to init build number
	// a default build number is a "0"
	// later will be incremented during CI/CD stages
	if c.Spec.Versioning.Type == codebaseApi.VersioningTypeEDP && cb.Status.Build == nil {
		buildNumber := "0"
		cb.Status.Build = &buildNumber
	}

	cbChain := factory.GetChain(r.client)
	if err := cbChain.ServeRequest(ctx, cb); err != nil {
		const defaultPostponeTime = 5 * time.Second

		log.Error(err, "an error has occurred while handling codebase branch", "name", cb.Name)

		reconcileErr := util.NewCodebaseBranchReconcileError("error")
		if errors.As(err, &reconcileErr) {
			return reconcile.Result{RequeueAfter: defaultPostponeTime}, nil
		}

		timeout := r.setFailureCount(cb)

		if statErr := r.updateStatus(ctx, cb); statErr != nil {
			ctrl.LoggerFrom(ctx).Error(statErr, "failed to update CodebaseBranch status with failure count")
		}

		return reconcile.Result{RequeueAfter: timeout}, fmt.Errorf("failed to process default chain: %w", err)
	}

	if err := r.setSuccessStatus(ctx, cb, codebaseApi.CIConfiguration); err != nil {
		return reconcile.Result{},
			fmt.Errorf("failed to update Codebase %v branch status: %w", cb.Name, err)
	}

	log.Info("Reconciling CodebaseBranch has been finished")

	return reconcile.Result{}, nil
}