Init commit

2026-03-25 16:44:42 -05:00
commit 25c940cfd3
101 changed files with 9907 additions and 0 deletions
--- a/src/pkg/controller/core/controller.go
+++ b/src/pkg/controller/core/controller.go
@@ -0,0 +1,111 @@
+package core
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	zitadelv1alpha1 "github.com/HaimKortovich/zitadel-resources-operator/api/v1alpha1"
+	condition "github.com/HaimKortovich/zitadel-resources-operator/pkg/condition"
+	zitadelClient "github.com/HaimKortovich/zitadel-resources-operator/pkg/zitadel"
+	"github.com/hashicorp/go-multierror"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/log"
+)
+
+type CoreReconciler struct {
+	Client         client.Client
+	RefResolver    *zitadelv1alpha1.RefResolver
+	ConditionReady *condition.Ready
+
+	WrappedReconciler WrappedCoreReconciler
+	Finalizer         Finalizer
+	RequeueInterval   time.Duration
+}
+
+func NewCoreReconciler(client client.Client, cr *condition.Ready, wr WrappedCoreReconciler, f Finalizer,
+	requeueInterval time.Duration) Reconciler {
+	return &CoreReconciler{
+		Client:            client,
+		RefResolver:       zitadelv1alpha1.NewRefResolver(client),
+		ConditionReady:    cr,
+		WrappedReconciler: wr,
+		Finalizer:         f,
+		RequeueInterval:   requeueInterval,
+	}
+}
+
+func (r *CoreReconciler) Reconcile(ctx context.Context, resource Resource) (ctrl.Result, error) {
+	if resource.IsBeingDeleted() {
+		if err := r.Finalizer.Finalize(ctx, resource); err != nil {
+			return ctrl.Result{}, fmt.Errorf("error finalizing %s: %v", resource.GetName(), err)
+		}
+		return ctrl.Result{}, nil
+	}
+	connectionRef, err := resource.ConnectionRef(ctx, r.RefResolver)
+	if err != nil {
+		return ctrl.Result{}, err
+	}
+	connection, err := r.RefResolver.ConnectionRef(ctx, connectionRef, resource.GetNamespace())
+
+	if err != nil {
+		var errBundle *multierror.Error
+		errBundle = multierror.Append(errBundle, err)
+
+		err = r.WrappedReconciler.PatchStatus(ctx, r.ConditionReady.PatcherRefResolver(err, connection))
+		errBundle = multierror.Append(errBundle, err)
+
+		return ctrl.Result{}, fmt.Errorf("error getting Connection: %v", errBundle)
+	}
+
+	ztdClient, err := zitadelClient.NewV2Client(ctx, connection, *r.RefResolver)
+	if err != nil {
+		var errBundle *multierror.Error
+		errBundle = multierror.Append(errBundle, err)
+
+		msg := fmt.Sprintf("Error connecting to Zitadel: %v", err)
+		err = r.WrappedReconciler.PatchStatus(ctx, r.ConditionReady.PatcherFailed(msg))
+		errBundle = multierror.Append(errBundle, err)
+
+		return r.retryResult(ctx, resource, errBundle)
+	}
+
+	defer ztdClient.Close()
+
+	err = r.WrappedReconciler.Reconcile(ctx, ztdClient)
+	var errBundle *multierror.Error
+	errBundle = multierror.Append(errBundle, err)
+
+	if err := errBundle.ErrorOrNil(); err != nil {
+		msg := fmt.Sprintf("Error creating %s: %v", resource.GetName(), err)
+		err = r.WrappedReconciler.PatchStatus(ctx, r.ConditionReady.PatcherFailed(msg))
+		errBundle = multierror.Append(errBundle, err)
+
+		return r.retryResult(ctx, resource, errBundle)
+	}
+
+	if err = r.Finalizer.AddFinalizer(ctx); err != nil {
+		errBundle = multierror.Append(errBundle, fmt.Errorf("error adding finalizer to %s: %v", resource.GetName(), err))
+	}
+
+	err = r.WrappedReconciler.PatchStatus(ctx, r.ConditionReady.PatcherWithError(errBundle.ErrorOrNil()))
+	errBundle = multierror.Append(errBundle, err)
+
+	if err := errBundle.ErrorOrNil(); err != nil {
+		return ctrl.Result{}, err
+	}
+	return r.requeueResult(ctx, resource)
+}
+
+func (r *CoreReconciler) retryResult(ctx context.Context, resource Resource, err error) (ctrl.Result, error) {
+	return ctrl.Result{}, err
+}
+
+func (r *CoreReconciler) requeueResult(ctx context.Context, resource Resource) (ctrl.Result, error) {
+	if r.RequeueInterval > 0 {
+		log.FromContext(ctx).V(1).Info("Requeuing CORE resource")
+		return ctrl.Result{RequeueAfter: r.RequeueInterval}, nil
+	}
+	return ctrl.Result{}, nil
+}