mirrors/kyverno
mirrors/kyverno
1
0
Fork 0
mirror of https://github.com/kyverno/kyverno.git synced 2025-03-28 02:18:15 +00:00
Code Activity

fix: propagate registration and error in controllerutils pkg (#8192)

Browse source 
Signed-off-by: Charles-Edouard Brétéché <charles.edouard@nirmata.com>
This commit is contained in:
Charles-Edouard Brétéché 2023-08-31 22:08:29 +02:00 • committed by GitHub
parent 941c1ae830
commit 7d74eb3ab0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
14 changed files with 141 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
pkg/controllers/certmanager/controller.go
View file

@ -50,13 +50,15 @@ func NewController(
namespace string,
) controllers.Controller {
queue := workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), ControllerName)
caEnqueue, _, _ := controllerutils.AddDefaultEventHandlers(logger, caInformer.Informer(), queue)
tlsEnqueue, _, _ := controllerutils.AddDefaultEventHandlers(logger, tlsInformer.Informer(), queue)
c := controller{
renewer: certRenewer,
caLister: caInformer.Lister(),
tlsLister: tlsInformer.Lister(),
queue: queue,
caEnqueue: controllerutils.AddDefaultEventHandlers(logger, caInformer.Informer(), queue),
tlsEnqueue: controllerutils.AddDefaultEventHandlers(logger, tlsInformer.Informer(), queue),
caEnqueue: caEnqueue,
tlsEnqueue: tlsEnqueue,
caSecretName: caSecretName,
tlsSecretName: tlsSecretName,
namespace: namespace,

18
pkg/controllers/cleanup/controller.go
View file

@ -85,24 +85,30 @@ func NewController(
cleanupService: cleanupService,
enqueue: baseEnqueueFunc,
}
controllerutils.AddEventHandlersT(
if _, err := controllerutils.AddEventHandlersT(
cpolInformer.Informer(),
controllerutils.AddFuncT(logger, enqueueFunc(logger, "added", "ClusterCleanupPolicy")),
controllerutils.UpdateFuncT(logger, enqueueFunc(logger, "updated", "ClusterCleanupPolicy")),
controllerutils.DeleteFuncT(logger, enqueueFunc(logger, "deleted", "ClusterCleanupPolicy")),
)
controllerutils.AddEventHandlersT(
); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, err := controllerutils.AddEventHandlersT(
polInformer.Informer(),
controllerutils.AddFuncT(logger, enqueueFunc(logger, "added", "CleanupPolicy")),
controllerutils.UpdateFuncT(logger, enqueueFunc(logger, "updated", "CleanupPolicy")),
controllerutils.DeleteFuncT(logger, enqueueFunc(logger, "deleted", "CleanupPolicy")),
)
controllerutils.AddEventHandlersT(
); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, err := controllerutils.AddEventHandlersT(
cjInformer.Informer(),
func(n *batchv1.CronJob) { c.enqueueCronJob(n) },
func(o *batchv1.CronJob, n *batchv1.CronJob) { c.enqueueCronJob(o) },
func(n *batchv1.CronJob) { c.enqueueCronJob(n) },
)
); err != nil {
logger.Error(err, "failed to register even handlers")
}
return c
}

4
pkg/controllers/generic/configmap/controller.go
View file

@ -63,7 +63,9 @@ func NewController(
name: name,
callback: callback,
}
controllerutils.AddDefaultEventHandlers(c.logger, informer.Informer(), c.queue)
if _, _, err := controllerutils.AddDefaultEventHandlers(c.logger, informer.Informer(), c.queue); err != nil {
logging.Error(err, "failed to register even handlers")
}
return &c
}

4
pkg/controllers/generic/logging/controller.go
View file

@ -31,7 +31,9 @@ func NewController(logger logr.Logger, objectType string, informer informer, pre
logger: logger.WithValues("type", objectType),
predicates: predicates,
}
controllerutils.AddEventHandlersT(informer.Informer(), c.add, c.update, c.delete)
if _, err := controllerutils.AddEventHandlersT(informer.Informer(), c.add, c.update, c.delete); err != nil {
logger.Error(err, "failed to register even handlers")
}
}
func (c *controller) add(obj metav1.Object) {

10
pkg/controllers/generic/webhook/controller.go
View file

@ -97,8 +97,10 @@ func NewController(
labelSelector: labelSelector,
caSecretName: caSecretName,
}
controllerutils.AddDefaultEventHandlers(c.logger, vwcInformer.Informer(), queue)
controllerutils.AddEventHandlersT(
if _, _, err := controllerutils.AddDefaultEventHandlers(c.logger, vwcInformer.Informer(), queue); err != nil {
c.logger.Error(err, "failed to register even handlers")
}
if _, err := controllerutils.AddEventHandlersT(
secretInformer.Informer(),
func(obj *corev1.Secret) {
if obj.GetNamespace() == config.KyvernoNamespace() && obj.GetName() == caSecretName {
@ -115,7 +117,9 @@ func NewController(
c.enqueue()
}
},
)
); err != nil {
c.logger.Error(err, "failed to register even handlers")
}
configuration.OnChanged(c.enqueue)
return &c
}

8
pkg/controllers/metrics/policy/controller.go
View file

@ -52,8 +52,12 @@ func NewController(
polLister: polInformer.Lister(),
waitGroup: waitGroup,
}
controllerutils.AddEventHandlers(cpolInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy)
controllerutils.AddEventHandlers(polInformer.Informer(), c.addNsPolicy, c.updateNsPolicy, c.deleteNsPolicy)
if _, err := controllerutils.AddEventHandlers(cpolInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, err := controllerutils.AddEventHandlers(polInformer.Informer(), c.addNsPolicy, c.updateNsPolicy, c.deleteNsPolicy); err != nil {
logger.Error(err, "failed to register even handlers")
}
if c.ruleInfo != nil {
_, err := meter.RegisterCallback(c.report, c.ruleInfo)
if err != nil {

8
pkg/controllers/policycache/controller.go
View file

@ -53,8 +53,12 @@ func NewController(client dclient.Interface, pcache pcache.Cache, cpolInformer k
queue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), ControllerName),
client: client,
}
controllerutils.AddDefaultEventHandlers(logger, cpolInformer.Informer(), c.queue)
controllerutils.AddDefaultEventHandlers(logger, polInformer.Informer(), c.queue)
if _, _, err := controllerutils.AddDefaultEventHandlers(logger, cpolInformer.Informer(), c.queue); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, _, err := controllerutils.AddDefaultEventHandlers(logger, polInformer.Informer(), c.queue); err != nil {
logger.Error(err, "failed to register even handlers")
}
return &c
}

12
pkg/controllers/report/admission/controller.go
View file

@ -62,18 +62,22 @@ func NewController(
cadmrLister: cadmrInformer.Lister(),
queue: queue,
}
controllerutils.AddEventHandlersT(
if _, err := controllerutils.AddEventHandlersT(
admrInformer.Informer(),
func(obj metav1.Object) { queue.Add(cache.ExplicitKey(reportutils.GetResourceUid(obj))) },
func(old, obj metav1.Object) { queue.Add(cache.ExplicitKey(reportutils.GetResourceUid(old))) },
func(obj metav1.Object) { queue.Add(cache.ExplicitKey(reportutils.GetResourceUid(obj))) },
)
controllerutils.AddEventHandlersT(
); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, err := controllerutils.AddEventHandlersT(
cadmrInformer.Informer(),
func(obj metav1.Object) { queue.Add(cache.ExplicitKey(reportutils.GetResourceUid(obj))) },
func(old, obj metav1.Object) { queue.Add(cache.ExplicitKey(reportutils.GetResourceUid(old))) },
func(obj metav1.Object) { queue.Add(cache.ExplicitKey(reportutils.GetResourceUid(obj))) },
)
); err != nil {
logger.Error(err, "failed to register even handlers")
}
return &c
}

28
pkg/controllers/report/aggregate/controller.go
View file

@ -95,28 +95,40 @@ func NewController(
metadataCache: metadataCache,
chunkSize: chunkSize,
}
controllerutils.AddDelayedExplicitEventHandlers(logger, polrInformer.Informer(), c.queue, enqueueDelay, keyFunc)
controllerutils.AddDelayedExplicitEventHandlers(logger, cpolrInformer.Informer(), c.queue, enqueueDelay, keyFunc)
controllerutils.AddDelayedExplicitEventHandlers(logger, bgscanrInformer.Informer(), c.queue, enqueueDelay, keyFunc)
controllerutils.AddDelayedExplicitEventHandlers(logger, cbgscanrInformer.Informer(), c.queue, enqueueDelay, keyFunc)
if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, polrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, cpolrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, bgscanrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, cbgscanrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil {
logger.Error(err, "failed to register even handlers")
}
enqueueFromAdmr := func(obj metav1.Object) {
// no need to consider non aggregated reports
if controllerutils.HasLabel(obj, reportutils.LabelAggregatedReport) {
c.queue.AddAfter(keyFunc(obj), enqueueDelay)
}
}
controllerutils.AddEventHandlersT(
if _, err := controllerutils.AddEventHandlersT(
admrInformer.Informer(),
func(obj metav1.Object) { enqueueFromAdmr(obj) },
func(_, obj metav1.Object) { enqueueFromAdmr(obj) },
func(obj metav1.Object) { enqueueFromAdmr(obj) },
)
controllerutils.AddEventHandlersT(
); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, err := controllerutils.AddEventHandlersT(
cadmrInformer.Informer(),
func(obj metav1.Object) { enqueueFromAdmr(obj) },
func(_, obj metav1.Object) { enqueueFromAdmr(obj) },
func(obj metav1.Object) { enqueueFromAdmr(obj) },
)
); err != nil {
logger.Error(err, "failed to register even handlers")
}
return &c
}

16
pkg/controllers/report/background/controller.go
View file

@ -104,10 +104,18 @@ func NewController(
eventGen: eventGen,
policyReports: policyReports,
}
controllerutils.AddDefaultEventHandlers(logger, bgscanr.Informer(), queue)
controllerutils.AddDefaultEventHandlers(logger, cbgscanr.Informer(), queue)
controllerutils.AddEventHandlersT(polInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy)
controllerutils.AddEventHandlersT(cpolInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy)
if _, _, err := controllerutils.AddDefaultEventHandlers(logger, bgscanr.Informer(), queue); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, _, err := controllerutils.AddDefaultEventHandlers(logger, cbgscanr.Informer(), queue); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, err := controllerutils.AddEventHandlersT(polInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, err := controllerutils.AddEventHandlersT(cpolInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy); err != nil {
logger.Error(err, "failed to register even handlers")
}
c.metadataCache.AddEventHandler(func(eventType resource.EventType, uid types.UID, _ schema.GroupVersionKind, res resource.Resource) {
// if it's a deletion, nothing to do
if eventType == resource.Deleted {

8
pkg/controllers/report/resource/controller.go
View file

@ -97,8 +97,12 @@ func NewController(
queue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), ControllerName),
dynamicWatchers: map[schema.GroupVersionResource]*watcher{},
}
controllerutils.AddDefaultEventHandlers(logger, polInformer.Informer(), c.queue)
controllerutils.AddDefaultEventHandlers(logger, cpolInformer.Informer(), c.queue)
if _, _, err := controllerutils.AddDefaultEventHandlers(logger, polInformer.Informer(), c.queue); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, _, err := controllerutils.AddDefaultEventHandlers(logger, cpolInformer.Informer(), c.queue); err != nil {
logger.Error(err, "failed to register even handlers")
}
return &c
}

12
pkg/controllers/validatingadmissionpolicy-generate/controller.go
View file

@ -68,13 +68,19 @@ func NewController(
}
// Set up an event handler for when Kyverno policies change
controllerutils.AddEventHandlersT(cpolInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy)
if _, err := controllerutils.AddEventHandlersT(cpolInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy); err != nil {
logger.Error(err, "failed to register even handlers")
}
// Set up an event handler for when validating admission policies change
controllerutils.AddEventHandlersT(vapInformer.Informer(), c.addVAP, c.updateVAP, c.deleteVAP)
if _, err := controllerutils.AddEventHandlersT(vapInformer.Informer(), c.addVAP, c.updateVAP, c.deleteVAP); err != nil {
logger.Error(err, "failed to register even handlers")
}
// Set up an event handler for when validating admission policy bindings change
controllerutils.AddEventHandlersT(vapbindingInformer.Informer(), c.addVAPbinding, c.updateVAPbinding, c.deleteVAPbinding)
if _, err := controllerutils.AddEventHandlersT(vapbindingInformer.Informer(), c.addVAPbinding, c.updateVAPbinding, c.deleteVAPbinding); err != nil {
logger.Error(err, "failed to register even handlers")
}
return c
}

26
pkg/controllers/webhook/controller.go
View file

@ -156,9 +156,13 @@ func NewController(
config.ValidatingWebhookConfigurationName: sets.New[string](),
},
}
controllerutils.AddDefaultEventHandlers(logger, mwcInformer.Informer(), queue)
controllerutils.AddDefaultEventHandlers(logger, vwcInformer.Informer(), queue)
controllerutils.AddEventHandlersT(
if _, _, err := controllerutils.AddDefaultEventHandlers(logger, mwcInformer.Informer(), queue); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, _, err := controllerutils.AddDefaultEventHandlers(logger, vwcInformer.Informer(), queue); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, err := controllerutils.AddEventHandlersT(
secretInformer.Informer(),
func(obj *corev1.Secret) {
if obj.GetNamespace() == config.KyvernoNamespace() && obj.GetName() == caSecretName {
@ -175,19 +179,25 @@ func NewController(
c.enqueueAll()
}
},
)
controllerutils.AddEventHandlers(
); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, err := controllerutils.AddEventHandlers(
cpolInformer.Informer(),
func(interface{}) { c.enqueueResourceWebhooks(0) },
func(interface{}, interface{}) { c.enqueueResourceWebhooks(0) },
func(interface{}) { c.enqueueResourceWebhooks(0) },
)
controllerutils.AddEventHandlers(
); err != nil {
logger.Error(err, "failed to register even handlers")
}
if _, err := controllerutils.AddEventHandlers(
polInformer.Informer(),
func(interface{}) { c.enqueueResourceWebhooks(0) },
func(interface{}, interface{}) { c.enqueueResourceWebhooks(0) },
func(interface{}) { c.enqueueResourceWebhooks(0) },
)
); err != nil {
logger.Error(err, "failed to register even handlers")
}
configuration.OnChanged(c.enqueueAll)
return &c
}

45
pkg/utils/controller/handlers.go
View file

@ -24,8 +24,8 @@ type (
EnqueueFuncT[T any] func(T) error
)
func AddEventHandlers(informer cache.SharedInformer, a addFunc, u updateFunc, d deleteFunc) {
_, _ = informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
func AddEventHandlers(informer cache.SharedInformer, a addFunc, u updateFunc, d deleteFunc) (cache.ResourceEventHandlerRegistration, error) {
return informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
AddFunc: a,
UpdateFunc: u,
DeleteFunc: func(obj interface{}) {
@ -34,8 +34,8 @@ func AddEventHandlers(informer cache.SharedInformer, a addFunc, u updateFunc, d
})
}
func AddEventHandlersT[T any](informer cache.SharedInformer, a addFuncT[T], u updateFuncT[T], d deleteFuncT[T]) {
AddEventHandlers(
func AddEventHandlersT[T any](informer cache.SharedInformer, a addFuncT[T], u updateFuncT[T], d deleteFuncT[T]) (cache.ResourceEventHandlerRegistration, error) {
return AddEventHandlers(
informer,
func(obj interface{}) { a(obj.(T)) },
func(old, obj interface{}) { u(old.(T), obj.(T)) },
@ -43,41 +43,50 @@ func AddEventHandlersT[T any](informer cache.SharedInformer, a addFuncT[T], u up
)
}
func AddKeyedEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, parseKey keyFunc) EnqueueFunc {
func AddKeyedEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, parseKey keyFunc) (EnqueueFunc, cache.ResourceEventHandlerRegistration, error) {
enqueueFunc := LogError(logger, Parse(parseKey, Queue(queue)))
AddEventHandlers(informer, AddFunc(logger, enqueueFunc), UpdateFunc(logger, enqueueFunc), DeleteFunc(logger, enqueueFunc))
return enqueueFunc
if registration, err := AddEventHandlers(informer, AddFunc(logger, enqueueFunc), UpdateFunc(logger, enqueueFunc), DeleteFunc(logger, enqueueFunc)); err != nil {
return nil, nil, err
} else {
return enqueueFunc, registration, nil
}
}
func AddKeyedEventHandlersT[K metav1.Object](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, parseKey keyFuncT[K, interface{}]) EnqueueFuncT[K] {
func AddKeyedEventHandlersT[K metav1.Object](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, parseKey keyFuncT[K, interface{}]) (EnqueueFuncT[K], cache.ResourceEventHandlerRegistration, error) {
enqueueFunc := LogError(logger, Parse(parseKey, Queue(queue)))
AddEventHandlersT(informer, AddFuncT(logger, enqueueFunc), UpdateFuncT(logger, enqueueFunc), DeleteFuncT(logger, enqueueFunc))
return enqueueFunc
if registration, err := AddEventHandlersT(informer, AddFuncT(logger, enqueueFunc), UpdateFuncT(logger, enqueueFunc), DeleteFuncT(logger, enqueueFunc)); err != nil {
return nil, nil, err
} else {
return enqueueFunc, registration, nil
}
}
func AddDelayedKeyedEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, delay time.Duration, parseKey keyFunc) EnqueueFunc {
func AddDelayedKeyedEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, delay time.Duration, parseKey keyFunc) (EnqueueFunc, cache.ResourceEventHandlerRegistration, error) {
enqueueFunc := LogError(logger, Parse(parseKey, QueueAfter(queue, delay)))
AddEventHandlers(informer, AddFunc(logger, enqueueFunc), UpdateFunc(logger, enqueueFunc), DeleteFunc(logger, enqueueFunc))
return enqueueFunc
if registration, err := AddEventHandlers(informer, AddFunc(logger, enqueueFunc), UpdateFunc(logger, enqueueFunc), DeleteFunc(logger, enqueueFunc)); err != nil {
return nil, nil, err
} else {
return enqueueFunc, registration, nil
}
}
func AddDefaultEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface) EnqueueFunc {
func AddDefaultEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface) (EnqueueFunc, cache.ResourceEventHandlerRegistration, error) {
return AddKeyedEventHandlers(logger, informer, queue, MetaNamespaceKey)
}
func AddDefaultEventHandlersT[K metav1.Object](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface) EnqueueFuncT[K] {
func AddDefaultEventHandlersT[K metav1.Object](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface) (EnqueueFuncT[K], cache.ResourceEventHandlerRegistration, error) {
return AddKeyedEventHandlersT(logger, informer, queue, MetaNamespaceKeyT[K])
}
func AddDelayedDefaultEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, delay time.Duration) EnqueueFunc {
func AddDelayedDefaultEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, delay time.Duration) (EnqueueFunc, cache.ResourceEventHandlerRegistration, error) {
return AddDelayedKeyedEventHandlers(logger, informer, queue, delay, MetaNamespaceKey)
}
func AddExplicitEventHandlers[K any](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, parseKey func(K) cache.ExplicitKey) EnqueueFunc {
func AddExplicitEventHandlers[K any](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, parseKey func(K) cache.ExplicitKey) (EnqueueFunc, cache.ResourceEventHandlerRegistration, error) {
return AddKeyedEventHandlers(logger, informer, queue, ExplicitKey(parseKey))
}
func AddDelayedExplicitEventHandlers[K any](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, delay time.Duration, parseKey func(K) cache.ExplicitKey) EnqueueFunc {
func AddDelayedExplicitEventHandlers[K any](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, delay time.Duration, parseKey func(K) cache.ExplicitKey) (EnqueueFunc, cache.ResourceEventHandlerRegistration, error) {
return AddDelayedKeyedEventHandlers(logger, informer, queue, delay, ExplicitKey(parseKey))
}