From e71638627a0709f99ae1716404eae30f19f7ca61 Mon Sep 17 00:00:00 2001
From: Paul Abel
Date: Tue, 27 Feb 2024 16:12:12 +0000
Subject: [PATCH] ExternalDNS controller should handle errors registering the
EventHandler
---
internal/externaldns/controller.go | 42 ++++++++++++++++++++----------
internal/k8s/controller.go | 9 +++++--
2 files changed, 35 insertions(+), 16 deletions(-)
diff --git a/internal/externaldns/controller.go b/internal/externaldns/controller.go
index ad289b3541..84b9b01af4 100644
--- a/internal/externaldns/controller.go
+++ b/internal/externaldns/controller.go
@@ -2,6 +2,7 @@ package externaldns
import (
"context"
+ "errors"
"fmt"
"sync"
"time"
@@ -58,7 +59,7 @@ type ExtDNSOpts struct {
}
// NewController takes external dns config and return a new External DNS Controller.
-func NewController(opts *ExtDNSOpts) *ExtDNSController {
+func NewController(opts *ExtDNSOpts) (*ExtDNSController, error) {
ig := make(map[string]*namespacedInformer)
c := &ExtDNSController{
ctx: opts.context,
@@ -74,35 +75,44 @@ func NewController(opts *ExtDNSOpts) *ExtDNSController {
// no initial namespaces with watched label - skip creating informers for now
break
}
- c.newNamespacedInformer(ns)
+ _, err := c.newNamespacedInformer(ns)
+ if err != nil {
+ return nil, err
+ }
}
c.sync = SyncFnFor(c.recorder, c.client, c.informerGroup)
- return c
+ return c, nil
}
-func (c *ExtDNSController) newNamespacedInformer(ns string) *namespacedInformer {
+func (c *ExtDNSController) newNamespacedInformer(ns string) (*namespacedInformer, error) {
nsi := &namespacedInformer{sharedInformerFactory: k8s_nginx_informers.NewSharedInformerFactoryWithOptions(c.client, c.resync, k8s_nginx_informers.WithNamespace(ns))}
nsi.stopCh = make(chan struct{})
nsi.vsLister = nsi.sharedInformerFactory.K8s().V1().VirtualServers().Lister()
nsi.extdnslister = nsi.sharedInformerFactory.Externaldns().V1().DNSEndpoints().Lister()
- nsi.sharedInformerFactory.K8s().V1().VirtualServers().Informer().AddEventHandler(
+ vsInformer := nsi.sharedInformerFactory.K8s().V1().VirtualServers().Informer()
+ vsHandlerReg, err := vsInformer.AddEventHandler(
&QueuingEventHandler{
Queue: c.queue,
},
)
-
- nsi.sharedInformerFactory.Externaldns().V1().DNSEndpoints().Informer().AddEventHandler(&BlockingEventHandler{
+ if err != nil {
+ return nil, err
+ }
+ dnsInformer := nsi.sharedInformerFactory.Externaldns().V1().DNSEndpoints().Informer()
+ dnsHandlerReg, err := dnsInformer.AddEventHandler(&BlockingEventHandler{
WorkFunc: externalDNSHandler(c.queue),
})
-
+ if err != nil {
+ return nil, err
+ }
nsi.mustSync = append(nsi.mustSync,
- nsi.sharedInformerFactory.K8s().V1().VirtualServers().Informer().HasSynced,
- nsi.sharedInformerFactory.Externaldns().V1().DNSEndpoints().Informer().HasSynced,
+ vsHandlerReg.HasSynced,
+ dnsHandlerReg.HasSynced,
)
c.informerGroup[ns] = nsi
- return nsi
+ return nsi, nil
}
// Run sets up the event handlers for types we are interested in, as well
@@ -254,16 +264,20 @@ func getNamespacedInformer(ns string, ig map[string]*namespacedInformer) *namesp
}
// AddNewNamespacedInformer adds watchers for a new namespace
-func (c *ExtDNSController) AddNewNamespacedInformer(ns string) {
+func (c *ExtDNSController) AddNewNamespacedInformer(ns string) error {
glog.V(3).Infof("Adding or Updating cert-manager Watchers for Namespace: %v", ns)
nsi := getNamespacedInformer(ns, c.informerGroup)
if nsi == nil {
- nsi = c.newNamespacedInformer(ns)
+ nsi, err := c.newNamespacedInformer(ns)
+ if err != nil {
+ return err
+ }
nsi.start()
}
if !cache.WaitForCacheSync(nsi.stopCh, nsi.mustSync...) {
- return
+ return errors.New("failed to sync the cache")
}
+ return nil
}
// RemoveNamespacedInformer removes watchers for a namespace we are no longer watching
diff --git a/internal/k8s/controller.go b/internal/k8s/controller.go
index b54cc855c5..124d3079af 100644
--- a/internal/k8s/controller.go
+++ b/internal/k8s/controller.go
@@ -274,7 +274,9 @@ func NewLoadBalancerController(input NewLoadBalancerControllerInput) *LoadBalanc
}
if input.ExternalDNSEnabled {
- lbc.externalDNSController = ed_controller.NewController(ed_controller.BuildOpts(context.TODO(), lbc.namespaceList, lbc.recorder, lbc.confClient, input.ResyncPeriod, isDynamicNs))
+ if lbc.externalDNSController, err = ed_controller.NewController(ed_controller.BuildOpts(context.TODO(), lbc.namespaceList, lbc.recorder, lbc.confClient, input.ResyncPeriod, isDynamicNs)); err != nil {
+ glog.Fatalf("failed to initialize ExternalDNS: %v", err)
+ }
}
glog.V(3).Infof("Nginx Ingress Controller has class: %v", input.IngressClass)
@@ -1142,7 +1144,10 @@ func (lbc *LoadBalancerController) syncNamespace(task task) {
lbc.certManagerController.AddNewNamespacedInformer(key)
}
if lbc.externalDNSController != nil {
- lbc.externalDNSController.AddNewNamespacedInformer(key)
+ if err := lbc.externalDNSController.AddNewNamespacedInformer(key); err != nil {
+ lbc.syncQueue.Requeue(task, err)
+ return
+ }
}
if !cache.WaitForCacheSync(nsi.stopCh, nsi.cacheSyncs...) {
return