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

     1  package eventsource
     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  	ctrl "sigs.k8s.io/controller-runtime"
    11  	"sigs.k8s.io/controller-runtime/pkg/client"
    12  	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
    13  	"sigs.k8s.io/controller-runtime/pkg/reconcile"
    14  
    15  	"github.com/argoproj/argo-events/common"
    16  	"github.com/argoproj/argo-events/common/logging"
    17  	"github.com/argoproj/argo-events/pkg/apis/eventsource/v1alpha1"
    18  )
    19  
    20  const (
    21  	// ControllerName is name of the controller
    22  	ControllerName = "eventsource-controller"
    23  
    24  	finalizerName = ControllerName
    25  )
    26  
    27  type reconciler struct {
    28  	client client.Client
    29  	scheme *runtime.Scheme
    30  
    31  	eventSourceImage string
    32  	logger           *zap.SugaredLogger
    33  }
    34  
    35  // NewReconciler returns a new reconciler
    36  func NewReconciler(client client.Client, scheme *runtime.Scheme, eventSourceImage string, logger *zap.SugaredLogger) reconcile.Reconciler {
    37  	return &reconciler{client: client, scheme: scheme, eventSourceImage: eventSourceImage, logger: logger}
    38  }
    39  
    40  func (r *reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    41  	eventSource := &v1alpha1.EventSource{}
    42  	if err := r.client.Get(ctx, req.NamespacedName, eventSource); err != nil {
    43  		if apierrors.IsNotFound(err) {
    44  			r.logger.Warnw("WARNING: eventsource not found", "request", req)
    45  			return reconcile.Result{}, nil
    46  		}
    47  		r.logger.Errorw("unable to get eventsource ctl", "request", req, "error", err)
    48  		return ctrl.Result{}, err
    49  	}
    50  	log := r.logger.With("namespace", eventSource.Namespace).With("eventSource", eventSource.Name)
    51  	ctx = logging.WithLogger(ctx, log)
    52  	esCopy := eventSource.DeepCopy()
    53  	reconcileErr := r.reconcile(ctx, esCopy)
    54  	if reconcileErr != nil {
    55  		log.Errorw("reconcile error", zap.Error(reconcileErr))
    56  	}
    57  	if r.needsUpdate(eventSource, esCopy) {
    58  		// Use a DeepCopy to update, because it will be mutated afterwards, with empty Status.
    59  		if err := r.client.Update(ctx, esCopy.DeepCopy()); err != nil {
    60  			return reconcile.Result{}, err
    61  		}
    62  	}
    63  	if err := r.client.Status().Update(ctx, esCopy); err != nil {
    64  		return reconcile.Result{}, err
    65  	}
    66  	return ctrl.Result{}, reconcileErr
    67  }
    68  
    69  // reconcile does the real logic
    70  func (r *reconciler) reconcile(ctx context.Context, eventSource *v1alpha1.EventSource) error {
    71  	log := logging.FromContext(ctx)
    72  	if !eventSource.DeletionTimestamp.IsZero() {
    73  		log.Info("deleting eventsource")
    74  		if controllerutil.ContainsFinalizer(eventSource, finalizerName) {
    75  			// Finalizer logic should be added here.
    76  			controllerutil.RemoveFinalizer(eventSource, finalizerName)
    77  		}
    78  		return nil
    79  	}
    80  	controllerutil.AddFinalizer(eventSource, finalizerName)
    81  
    82  	eventSource.Status.InitConditions()
    83  	if err := ValidateEventSource(eventSource); err != nil {
    84  		log.Errorw("validation error", zap.Error(err))
    85  		return err
    86  	}
    87  	args := &AdaptorArgs{
    88  		Image:       r.eventSourceImage,
    89  		EventSource: eventSource,
    90  		Labels: map[string]string{
    91  			"controller":                "eventsource-controller",
    92  			common.LabelEventSourceName: eventSource.Name,
    93  			common.LabelOwnerName:       eventSource.Name,
    94  		},
    95  	}
    96  	return Reconcile(r.client, args, log)
    97  }
    98  
    99  func (r *reconciler) needsUpdate(old, new *v1alpha1.EventSource) bool {
   100  	if old == nil {
   101  		return true
   102  	}
   103  	if !equality.Semantic.DeepEqual(old.Finalizers, new.Finalizers) {
   104  		return true
   105  	}
   106  	return false
   107  }