chore: Print additional error message, if CheCluster controller failed to reconcile

Signed-off-by: Anatolii Bazko <abazko@redhat.com>

Author: tolusha

controllers/che/checluster_controller.go

@@ -14,7 +14,10 @@ package che
 
 import (
 	"context"
+	"time"
 
+	"github.com/eclipse-che/che-operator/pkg/common/constants"
+	"github.com/eclipse-che/che-operator/pkg/common/reconciler"
 	"k8s.io/utils/pointer"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 
@@ -47,7 +50,6 @@ import (
 	chev2 "github.com/eclipse-che/che-operator/api/v2"
 	"github.com/go-logr/logr"
 	routev1 "github.com/openshift/api/route/v1"
-	"github.com/sirupsen/logrus"
 	appsv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
 	networking "k8s.io/api/networking/v1"
@@ -75,8 +77,8 @@ type CheClusterReconciler struct {
 	nonCachedClient client.Client
 	// A discovery client to check for the existence of certain APIs registered
 	// in the API Server
-	discoveryClient  discovery.DiscoveryInterface
-	reconcileManager *deploy.ReconcileManager
+	discoveryClient   discovery.DiscoveryInterface
+	reconcilerManager *reconciler.ReconcilerManager
 	// the namespace to which to limit the reconciliation. If empty, all namespaces are considered
 	namespace string
 }
@@ -89,49 +91,49 @@ func NewReconciler(
 	scheme *k8sruntime.Scheme,
 	namespace string) *CheClusterReconciler {
 
-	reconcileManager := deploy.NewReconcileManager()
+	reconcilerManager := reconciler.NewReconcilerManager()
 
 	// order does matter
 	if !test.IsTestMode() {
-		reconcileManager.RegisterReconciler(migration.NewMigrator())
-		reconcileManager.RegisterReconciler(migration.NewCheClusterDefaultsCleaner())
-		reconcileManager.RegisterReconciler(NewCheClusterValidator())
+		reconcilerManager.AddReconciler(migration.NewMigrator())
+		reconcilerManager.AddReconciler(migration.NewCheClusterDefaultsCleaner())
+		reconcilerManager.AddReconciler(NewCheClusterValidator())
 	}
 
-	reconcileManager.RegisterReconciler(tls.NewCertificatesReconciler())
-	reconcileManager.RegisterReconciler(tls.NewTlsSecretReconciler())
-	reconcileManager.RegisterReconciler(devworkspaceconfig.NewDevWorkspaceConfigReconciler())
-	reconcileManager.RegisterReconciler(rbac.NewGatewayPermissionsReconciler())
+	reconcilerManager.AddReconciler(tls.NewCertificatesReconciler())
+	reconcilerManager.AddReconciler(tls.NewTlsSecretReconciler())
+	reconcilerManager.AddReconciler(devworkspaceconfig.NewDevWorkspaceConfigReconciler())
+	reconcilerManager.AddReconciler(rbac.NewGatewayPermissionsReconciler())
 
 	// we have to expose che endpoint independently of syncing other server
 	// resources since che host is used for dashboard deployment and che config map
-	reconcileManager.RegisterReconciler(server.NewCheHostReconciler())
-	reconcileManager.RegisterReconciler(postgres.NewPostgresReconciler())
+	reconcilerManager.AddReconciler(server.NewCheHostReconciler())
+	reconcilerManager.AddReconciler(postgres.NewPostgresReconciler())
 	if infrastructure.IsOpenShift() {
-		reconcileManager.RegisterReconciler(identityprovider.NewIdentityProviderReconciler())
+		reconcilerManager.AddReconciler(identityprovider.NewIdentityProviderReconciler())
 	}
-	reconcileManager.RegisterReconciler(devfileregistry.NewDevfileRegistryReconciler())
-	reconcileManager.RegisterReconciler(pluginregistry.NewPluginRegistryReconciler())
-	reconcileManager.RegisterReconciler(editorsdefinitions.NewEditorsDefinitionsReconciler())
-	reconcileManager.RegisterReconciler(dashboard.NewDashboardReconciler())
-	reconcileManager.RegisterReconciler(gateway.NewGatewayReconciler())
-	reconcileManager.RegisterReconciler(server.NewCheServerReconciler())
-	reconcileManager.RegisterReconciler(imagepuller.NewImagePuller())
+	reconcilerManager.AddReconciler(devfileregistry.NewDevfileRegistryReconciler())
+	reconcilerManager.AddReconciler(pluginregistry.NewPluginRegistryReconciler())
+	reconcilerManager.AddReconciler(editorsdefinitions.NewEditorsDefinitionsReconciler())
+	reconcilerManager.AddReconciler(dashboard.NewDashboardReconciler())
+	reconcilerManager.AddReconciler(gateway.NewGatewayReconciler())
+	reconcilerManager.AddReconciler(server.NewCheServerReconciler())
+	reconcilerManager.AddReconciler(imagepuller.NewImagePuller())
 
 	if infrastructure.IsOpenShift() {
-		reconcileManager.RegisterReconciler(containerbuild.NewContainerBuildReconciler())
-		reconcileManager.RegisterReconciler(consolelink.NewConsoleLinkReconciler())
+		reconcilerManager.AddReconciler(containerbuild.NewContainerBuildReconciler())
+		reconcilerManager.AddReconciler(consolelink.NewConsoleLinkReconciler())
 	}
 
 	return &CheClusterReconciler{
 		Scheme: scheme,
 		Log:    ctrl.Log.WithName("controllers").WithName("CheCluster"),
 
-		client:           k8sclient,
-		nonCachedClient:  noncachedClient,
-		discoveryClient:  discoveryClient,
-		namespace:        namespace,
-		reconcileManager: reconcileManager,
+		client:            k8sclient,
+		nonCachedClient:   noncachedClient,
+		discoveryClient:   discoveryClient,
+		namespace:         namespace,
+		reconcilerManager: reconcilerManager,
 	}
 }
 
@@ -236,21 +238,42 @@ func (r *CheClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 	deployContext.IsSelfSignedCertificate = isSelfSignedCertificate
 
 	if deployContext.CheCluster.ObjectMeta.DeletionTimestamp.IsZero() {
-		result, done, err := r.reconcileManager.ReconcileAll(deployContext)
+		result, done, err := r.reconcilerManager.ReconcileAll(deployContext)
 		if !done {
+			if err != nil {
+				errMsg := "Error on reconciling resources. The installation is not completed."
+				r.Log.Error(err, errMsg)
+
+				if err := deploy.SetStatusDetails(deployContext, constants.InstallOrUpdateFailed, errMsg); err != nil {
+					return ctrl.Result{}, err
+				}
+			}
+
 			return result, err
 		} else {
+			// Clean up status if so
 			if err := deploy.SetStatusDetails(deployContext, "", ""); err != nil {
 				return ctrl.Result{}, err
 			}
-			logrus.Info("Successfully reconciled.")
+
+			r.Log.Info("Successfully reconciled.")
 			return ctrl.Result{}, nil
 		}
 	} else {
 		deployContext.CheCluster.Status.ChePhase = chev2.ClusterPhasePendingDeletion
-		_ = deploy.UpdateCheCRStatus(deployContext, "ChePhase", chev2.ClusterPhasePendingDeletion)
+		if err = deploy.UpdateCheCRStatus(deployContext, "ChePhase", chev2.ClusterPhasePendingDeletion); err != nil {
+			return ctrl.Result{}, err
+		}
 
-		done := r.reconcileManager.FinalizeAll(deployContext)
-		return ctrl.Result{Requeue: !done}, nil
+		done := r.reconcilerManager.FinalizeAll(deployContext)
+		if done {
+			// Removes remaining finalizers, which prevent CheCluster from deletion
+			if err := deploy.CleanUpAllFinalizers(deployContext); err != nil {
+				return ctrl.Result{}, err
+			}
+			return ctrl.Result{}, nil
+		} else {
+			return ctrl.Result{RequeueAfter: time.Second}, nil
+		}
 	}
 }

controllers/che/checluster_validator.go

@@ -17,15 +17,15 @@ import (
 
 	"github.com/devfile/devworkspace-operator/pkg/infrastructure"
 	"github.com/eclipse-che/che-operator/pkg/common/chetypes"
-	"github.com/eclipse-che/che-operator/pkg/deploy"
+	"github.com/eclipse-che/che-operator/pkg/common/reconciler"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 )
 
 // CheClusterValidator checks CheCluster CR configuration.
 // It detects:
 // - configurations which miss required field(s) to deploy Che
 type CheClusterValidator struct {
-	deploy.Reconcilable
+	reconciler.Reconcilable
 }
 
 func NewCheClusterValidator() *CheClusterValidator {

pkg/common/reconciler/reconcile_manager.go

@@ -0,0 +1,91 @@
+//
+// Copyright (c) 2019-2025 Red Hat, Inc.
+// This program and the accompanying materials are made
+// available under the terms of the Eclipse Public License 2.0
+// which is available at https://www.eclipse.org/legal/epl-2.0/
+//
+// SPDX-License-Identifier: EPL-2.0
+//
+// Contributors:
+//   Red Hat, Inc. - initial API and implementation
+//
+
+package reconciler
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/eclipse-che/che-operator/pkg/common/chetypes"
+	"github.com/pkg/errors"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+)
+
+// Reconcilable defines the interface for components that can be reconciled and finalized.
+type Reconcilable interface {
+	// Reconcile performs a reconciliation step to ensure the desired state matches the actual state.
+	// Returns:
+	// - result: reconcile.Result indicating when to requeue (if needed)
+	// - done: true if reconciliation completed successfully, false if it needs to be retried
+	// - err: any error encountered during reconciliation
+	Reconcile(ctx *chetypes.DeployContext) (result reconcile.Result, done bool, err error)
+
+	// Finalize performs cleanup operations before the resource is deleted.
+	// All created resources should be removed, including:
+	// - finalizers
+	// - cluster scoped resources
+	// Returns true if finalization completed successfully, false otherwise.
+	// TODO make Finalize return error as well
+	Finalize(ctx *chetypes.DeployContext) (done bool)
+}
+
+// ReconcilerManager manages a collection of Reconcilable objects and executes them in order.
+type ReconcilerManager struct {
+	reconcilers []Reconcilable
+}
+
+func NewReconcilerManager() *ReconcilerManager {
+	return &ReconcilerManager{
+		reconcilers: make([]Reconcilable, 0),
+	}
+}
+
+func (r *ReconcilerManager) AddReconciler(reconciler Reconcilable) {
+	r.reconcilers = append(r.reconcilers, reconciler)
+}
+
+// ReconcileAll reconciles all registered reconcilers in the order they were added.
+// The reconciliation process stops at the first reconciler that returns done=false,
+// ensuring dependencies between reconcilers are respected.
+func (r *ReconcilerManager) ReconcileAll(ctx *chetypes.DeployContext) (reconcile.Result, bool, error) {
+	for _, reconciler := range r.reconcilers {
+		result, done, err := reconciler.Reconcile(ctx)
+
+		// Stop reconciliation chain if current reconciler is not done
+		if !done {
+			if err != nil {
+				name := reflect.TypeOf(reconciler).String()
+				return result, false, errors.Wrap(err, fmt.Sprintf("%s reconciliation failed", name))
+			} else {
+				return result, false, nil
+			}
+		}
+	}
+
+	return reconcile.Result{}, true, nil
+}
+
+// FinalizeAll invokes the Finalize method on all registered reconcilers.
+// Unlike ReconcileAll, this method continues executing all finalizers even if one fails,
+// ensuring all cleanup operations have a chance to run.
+// Returns true if all finalizers completed successfully, false if any failed.
+func (r *ReconcilerManager) FinalizeAll(ctx *chetypes.DeployContext) (doneAll bool) {
+	doneAll = true
+
+	for _, reconciler := range r.reconcilers {
+		done := reconciler.Finalize(ctx)
+		doneAll = doneAll && done
+	}
+
+	return doneAll
+}