github.com/argoproj/argo-events@v1.9.1/controllers/eventbus/controller.go (about)

     1  package eventbus
     2  
     3  import (
     4  	"context"
     5  
     6  	"go.uber.org/zap"
     7  	"k8s.io/apimachinery/pkg/api/equality"
     8  	apierrors "k8s.io/apimachinery/pkg/api/errors"
     9  	"k8s.io/apimachinery/pkg/runtime"
    10  	"k8s.io/client-go/kubernetes"
    11  	ctrl "sigs.k8s.io/controller-runtime"
    12  	"sigs.k8s.io/controller-runtime/pkg/client"
    13  	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
    14  	"sigs.k8s.io/controller-runtime/pkg/reconcile"
    15  
    16  	"github.com/argoproj/argo-events/common/logging"
    17  	"github.com/argoproj/argo-events/controllers"
    18  	"github.com/argoproj/argo-events/controllers/eventbus/installer"
    19  	"github.com/argoproj/argo-events/pkg/apis/eventbus/v1alpha1"
    20  )
    21  
    22  const (
    23  	// ControllerName is name of the controller
    24  	ControllerName = "eventbus-controller"
    25  
    26  	finalizerName = ControllerName
    27  )
    28  
    29  type reconciler struct {
    30  	client     client.Client
    31  	kubeClient kubernetes.Interface
    32  	scheme     *runtime.Scheme
    33  
    34  	config *controllers.GlobalConfig
    35  	logger *zap.SugaredLogger
    36  }
    37  
    38  // NewReconciler returns a new reconciler
    39  func NewReconciler(client client.Client, kubeClient kubernetes.Interface, scheme *runtime.Scheme, config *controllers.GlobalConfig, logger *zap.SugaredLogger) reconcile.Reconciler {
    40  	return &reconciler{client: client, scheme: scheme, config: config, kubeClient: kubeClient, logger: logger}
    41  }
    42  
    43  func (r *reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    44  	eventBus := &v1alpha1.EventBus{}
    45  	if err := r.client.Get(ctx, req.NamespacedName, eventBus); err != nil {
    46  		if apierrors.IsNotFound(err) {
    47  			r.logger.Warnw("WARNING: eventbus not found", "request", req)
    48  			return reconcile.Result{}, nil
    49  		}
    50  		r.logger.Errorw("unable to get eventbus ctl", zap.Any("request", req), zap.Error(err))
    51  		return ctrl.Result{}, err
    52  	}
    53  	log := r.logger.With("namespace", eventBus.Namespace).With("eventbus", eventBus.Name)
    54  	ctx = logging.WithLogger(ctx, log)
    55  	busCopy := eventBus.DeepCopy()
    56  	reconcileErr := r.reconcile(ctx, busCopy)
    57  	if reconcileErr != nil {
    58  		log.Errorw("reconcile error", zap.Error(reconcileErr))
    59  	}
    60  	if r.needsUpdate(eventBus, busCopy) {
    61  		// Use a DeepCopy to update, because it will be mutated afterwards, with empty Status.
    62  		if err := r.client.Update(ctx, busCopy.DeepCopy()); err != nil {
    63  			return reconcile.Result{}, err
    64  		}
    65  	}
    66  	if err := r.client.Status().Update(ctx, busCopy); err != nil {
    67  		return reconcile.Result{}, err
    68  	}
    69  	return ctrl.Result{}, reconcileErr
    70  }
    71  
    72  // reconcile does the real logic
    73  func (r *reconciler) reconcile(ctx context.Context, eventBus *v1alpha1.EventBus) error {
    74  	log := logging.FromContext(ctx)
    75  	if !eventBus.DeletionTimestamp.IsZero() {
    76  		log.Info("deleting eventbus")
    77  		if controllerutil.ContainsFinalizer(eventBus, finalizerName) {
    78  			// Finalizer logic should be added here.
    79  			if err := installer.Uninstall(ctx, eventBus, r.client, r.kubeClient, r.config, log); err != nil {
    80  				log.Errorw("failed to uninstall", zap.Error(err))
    81  				return err
    82  			}
    83  			controllerutil.RemoveFinalizer(eventBus, finalizerName)
    84  		}
    85  		return nil
    86  	}
    87  	controllerutil.AddFinalizer(eventBus, finalizerName)
    88  
    89  	eventBus.Status.InitConditions()
    90  	if err := ValidateEventBus(eventBus); err != nil {
    91  		log.Errorw("validation failed", zap.Error(err))
    92  		eventBus.Status.MarkNotConfigured("InvalidSpec", err.Error())
    93  		return err
    94  	} else {
    95  		eventBus.Status.MarkConfigured()
    96  	}
    97  	return installer.Install(ctx, eventBus, r.client, r.kubeClient, r.config, log)
    98  }
    99  
   100  func (r *reconciler) needsUpdate(old, new *v1alpha1.EventBus) bool {
   101  	if old == nil {
   102  		return true
   103  	}
   104  	if !equality.Semantic.DeepEqual(old.Finalizers, new.Finalizers) {
   105  		return true
   106  	}
   107  	return false
   108  }