func()

in pkg/controller/keyvault/event_mirror.go [67:153]
69 lines of code
12 McCabe index (conditional complexity)

func (e *EventMirror) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
	var err error
	result := ctrl.Result{}

	// do metrics
	defer func() {
		// placing this call inside a closure allows for result and err to be bound after Reconcile executes
		// this makes sure they have the proper value
		// just calling defer metrics.HandleControllerReconcileMetrics(controllerName, result, err) would bind
		// the values of result and err to their zero values, since they were just instantiated
		metrics.HandleControllerReconcileMetrics(eventMirrorControllerName, result, err)
	}()

	logger, err := logr.FromContext(ctx)
	if err != nil {
		return result, err
	}
	logger = eventMirrorControllerName.AddToLogger(logger)

	logger.Info("getting event", "name", req.Name, "namespace", req.Namespace)
	event := &corev1.Event{}
	err = e.client.Get(ctx, req.NamespacedName, event)
	if err != nil {
		return result, client.IgnoreNotFound(err)
	}
	logger = logger.WithValues("generation", event.Generation)

	// Filter to include only keyvault mounting errors
	if !isKeyVaultMountingError(event) {
		logger.Info("ignoring event, not keyvault mounting error")
		return result, nil
	}

	// Get the owner (pod)
	podName := event.InvolvedObject.Name
	podNamespace := event.InvolvedObject.Namespace
	logger.Info("getting owner placeholder pod", "name", podName, "namespace", podNamespace)
	pod := &corev1.Pod{}
	pod.Name = podName
	pod.Namespace = podNamespace
	err = e.client.Get(ctx, client.ObjectKeyFromObject(pod), pod)
	if err != nil {
		return result, client.IgnoreNotFound(err)
	}
	if pod.Annotations == nil {
		logger.Info("ignoring event, pod has no annotations")
		return result, nil
	}

	// Get the owner (ingress)
	ingressName := pod.Annotations["kubernetes.azure.com/ingress-owner"]
	if ingressName == "" {
		logger.Info("ignoring event, pod has no ingress owner")
		return result, nil
	}

	ingressNamespace := pod.Namespace
	logger.Info("getting owner ingress", "name", ingressName, "namespace", ingressNamespace)
	ingress := &netv1.Ingress{}
	ingress.Namespace = ingressNamespace
	ingress.Name = ingressName
	err = e.client.Get(ctx, client.ObjectKeyFromObject(ingress), ingress)
	if err != nil {
		return result, client.IgnoreNotFound(err)
	}

	// Publish to the service also if ingress is owned by a service
	if name := util.FindOwnerKind(ingress.OwnerReferences, "Service"); name != "" {
		logger.Info("getting owner service", "name", name, "namespace", pod.Namespace)
		svcNamespace := pod.Namespace
		svc := &corev1.Service{}
		svc.Namespace = svcNamespace
		svc.Name = name
		err = e.client.Get(ctx, client.ObjectKeyFromObject(svc), svc)
		if err == nil {
			logger.Info("publishing FailedMount warning event to service", "service", svc.Name, "namespace", svc.Namespace)
			e.events.Event(svc, corev1.EventTypeWarning, "FailedMount", event.Message)
		}
		if err != nil && !k8serrors.IsNotFound(err) {
			return result, fmt.Errorf("getting owner service: %w", err)
		}
	}

	logger.Info("publishing FailedMount warning event to ingress", "ingress", ingress.Name, "namespace", ingress.Namespace)
	e.events.Event(ingress, corev1.EventTypeWarning, "FailedMount", event.Message)
	return result, nil
}