112 lines
3.6 KiB
Go
112 lines
3.6 KiB
Go
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
|
|
}
|