mirrors/kyverno
mirrors/kyverno
1
0
Fork 0
mirror of https://github.com/kyverno/kyverno.git synced 2025-03-05 15:37:19 +00:00
Code Activity

fix typo (#8399)

Browse source 
Signed-off-by: Mariam Fahmy <mariam.fahmy@nirmata.com>
This commit is contained in:
Mariam Fahmy 2023-09-14 16:52:24 +03:00 • committed by GitHub
parent 714518fb22
commit d3dbd52f75
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 35 additions and 35 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -91,7 +91,7 @@ func NewController(
controllerutils.UpdateFuncT(logger, enqueueFunc(logger, "updated", "ClusterCleanupPolicy")), controllerutils.UpdateFuncT(logger, enqueueFunc(logger, "updated", "ClusterCleanupPolicy")),
controllerutils.DeleteFuncT(logger, enqueueFunc(logger, "deleted", "ClusterCleanupPolicy")), controllerutils.DeleteFuncT(logger, enqueueFunc(logger, "deleted", "ClusterCleanupPolicy")),
); err != nil { ); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
if _, err := controllerutils.AddEventHandlersT( if _, err := controllerutils.AddEventHandlersT(
polInformer.Informer(), polInformer.Informer(),
@ -99,7 +99,7 @@ func NewController(
controllerutils.UpdateFuncT(logger, enqueueFunc(logger, "updated", "CleanupPolicy")), controllerutils.UpdateFuncT(logger, enqueueFunc(logger, "updated", "CleanupPolicy")),
controllerutils.DeleteFuncT(logger, enqueueFunc(logger, "deleted", "CleanupPolicy")), controllerutils.DeleteFuncT(logger, enqueueFunc(logger, "deleted", "CleanupPolicy")),
); err != nil { ); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
if _, err := controllerutils.AddEventHandlersT( if _, err := controllerutils.AddEventHandlersT(
cjInformer.Informer(), cjInformer.Informer(),
@ -107,7 +107,7 @@ func NewController(
func(o *batchv1.CronJob, n *batchv1.CronJob) { c.enqueueCronJob(o) }, func(o *batchv1.CronJob, n *batchv1.CronJob) { c.enqueueCronJob(o) },
func(n *batchv1.CronJob) { c.enqueueCronJob(n) }, func(n *batchv1.CronJob) { c.enqueueCronJob(n) },
); err != nil { ); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
return c return c
} }

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

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

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

@ -32,7 +32,7 @@ func NewController(logger logr.Logger, objectType string, informer informer, pre
predicates: predicates, predicates: predicates,
} }
if _, err := controllerutils.AddEventHandlersT(informer.Informer(), c.add, c.update, c.delete); err != nil { if _, err := controllerutils.AddEventHandlersT(informer.Informer(), c.add, c.update, c.delete); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
} }

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

@ -98,7 +98,7 @@ func NewController(
caSecretName: caSecretName, caSecretName: caSecretName,
} }
if _, _, err := controllerutils.AddDefaultEventHandlers(c.logger, vwcInformer.Informer(), queue); err != nil { if _, _, err := controllerutils.AddDefaultEventHandlers(c.logger, vwcInformer.Informer(), queue); err != nil {
c.logger.Error(err, "failed to register even handlers") c.logger.Error(err, "failed to register event handlers")
} }
if _, err := controllerutils.AddEventHandlersT( if _, err := controllerutils.AddEventHandlersT(
secretInformer.Informer(), secretInformer.Informer(),
@ -118,7 +118,7 @@ func NewController(
} }
}, },
); err != nil { ); err != nil {
c.logger.Error(err, "failed to register even handlers") c.logger.Error(err, "failed to register event handlers")
} }
configuration.OnChanged(c.enqueue) configuration.OnChanged(c.enqueue)
return &c return &c

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

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

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

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

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

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

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

@ -97,16 +97,16 @@ func NewController(
chunkSize: chunkSize, chunkSize: chunkSize,
} }
if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, polrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil { if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, polrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, cpolrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil { if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, cpolrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, bgscanrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil { if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, bgscanrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, cbgscanrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil { if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, cbgscanrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
enqueueFromAdmr := func(obj metav1.Object) { enqueueFromAdmr := func(obj metav1.Object) {
// no need to consider non aggregated reports // no need to consider non aggregated reports
@ -120,7 +120,7 @@ func NewController(
func(_, obj metav1.Object) { enqueueFromAdmr(obj) }, func(_, obj metav1.Object) { enqueueFromAdmr(obj) },
func(obj metav1.Object) { enqueueFromAdmr(obj) }, func(obj metav1.Object) { enqueueFromAdmr(obj) },
); err != nil { ); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
if _, err := controllerutils.AddEventHandlersT( if _, err := controllerutils.AddEventHandlersT(
cadmrInformer.Informer(), cadmrInformer.Informer(),
@ -128,7 +128,7 @@ func NewController(
func(_, obj metav1.Object) { enqueueFromAdmr(obj) }, func(_, obj metav1.Object) { enqueueFromAdmr(obj) },
func(obj metav1.Object) { enqueueFromAdmr(obj) }, func(obj metav1.Object) { enqueueFromAdmr(obj) },
); err != nil { ); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
return &c return &c
} }

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

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

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

@ -106,15 +106,15 @@ func NewController(
if vapInformer != nil { if vapInformer != nil {
c.vapLister = vapInformer.Lister() c.vapLister = vapInformer.Lister()
if _, _, err := controllerutils.AddDefaultEventHandlers(logger, vapInformer.Informer(), c.queue); err != nil { if _, _, err := controllerutils.AddDefaultEventHandlers(logger, vapInformer.Informer(), c.queue); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
} }
if _, _, err := controllerutils.AddDefaultEventHandlers(logger, polInformer.Informer(), c.queue); err != nil { if _, _, err := controllerutils.AddDefaultEventHandlers(logger, polInformer.Informer(), c.queue); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
if _, _, err := controllerutils.AddDefaultEventHandlers(logger, cpolInformer.Informer(), c.queue); err != nil { if _, _, err := controllerutils.AddDefaultEventHandlers(logger, cpolInformer.Informer(), c.queue); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
return &c return &c
} }

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

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

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

@ -157,10 +157,10 @@ func NewController(
}, },
} }
if _, _, err := controllerutils.AddDefaultEventHandlers(logger, mwcInformer.Informer(), queue); err != nil { if _, _, err := controllerutils.AddDefaultEventHandlers(logger, mwcInformer.Informer(), queue); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
if _, _, err := controllerutils.AddDefaultEventHandlers(logger, vwcInformer.Informer(), queue); err != nil { if _, _, err := controllerutils.AddDefaultEventHandlers(logger, vwcInformer.Informer(), queue); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
if _, err := controllerutils.AddEventHandlersT( if _, err := controllerutils.AddEventHandlersT(
secretInformer.Informer(), secretInformer.Informer(),
@ -180,7 +180,7 @@ func NewController(
} }
}, },
); err != nil { ); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
if _, err := controllerutils.AddEventHandlers( if _, err := controllerutils.AddEventHandlers(
cpolInformer.Informer(), cpolInformer.Informer(),
@ -188,7 +188,7 @@ func NewController(
func(interface{}, interface{}) { c.enqueueResourceWebhooks(0) }, func(interface{}, interface{}) { c.enqueueResourceWebhooks(0) },
func(interface{}) { c.enqueueResourceWebhooks(0) }, func(interface{}) { c.enqueueResourceWebhooks(0) },
); err != nil { ); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
if _, err := controllerutils.AddEventHandlers( if _, err := controllerutils.AddEventHandlers(
polInformer.Informer(), polInformer.Informer(),
@ -196,7 +196,7 @@ func NewController(
func(interface{}, interface{}) { c.enqueueResourceWebhooks(0) }, func(interface{}, interface{}) { c.enqueueResourceWebhooks(0) },
func(interface{}) { c.enqueueResourceWebhooks(0) }, func(interface{}) { c.enqueueResourceWebhooks(0) },
); err != nil { ); err != nil {
logger.Error(err, "failed to register even handlers") logger.Error(err, "failed to register event handlers")
} }
configuration.OnChanged(c.enqueueAll) configuration.OnChanged(c.enqueueAll)
return &c return &c