mirror of
https://github.com/kyverno/kyverno.git
synced 2025-03-06 16:06:56 +00:00
e0ab72bb9a
This PR refactors the reports generation code. It removes RCR and CRCR crds and replaces them with AdmissionReport, ClusterAdmissionReport, BackgroundScanReport and ClusterBackgroundScanReport crds. The new reports system is based on 4 controllers: Admission reports controller is responsible for cleaning up admission reports and attaching admission reports to their corresponding resource in case of a creation Background scan reports controller is responsible for creating background scan reports when a resource and/or policy changes Aggregation controller takes care of aggregation per resource reports into higher level reports (per namespace) Resources controller is responsible for watching reports that need background scan reports I added two new flags to disable admission reports and/or background scan reports, the whole reporting system can be disabled if something goes wrong. I also added a flag to split reports in chunks to avoid creating too large resources. Signed-off-by: Charles-Edouard Brétéché <charled.breteche@gmail.com> Signed-off-by: prateekpandey14 <prateek.pandey@nirmata.com> Signed-off-by: Charles-Edouard Brétéché <charled.breteche@gmail.com> Signed-off-by: prateekpandey14 <prateek.pandey@nirmata.com> Co-authored-by: prateekpandey14 <prateek.pandey@nirmata.com>
91 lines
2.7 KiB
Go
91 lines
2.7 KiB
Go
package controller
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/go-logr/logr"
|
|
"k8s.io/apimachinery/pkg/api/errors"
|
|
"k8s.io/apimachinery/pkg/util/runtime"
|
|
"k8s.io/apimachinery/pkg/util/wait"
|
|
"k8s.io/client-go/tools/cache"
|
|
"k8s.io/client-go/util/workqueue"
|
|
)
|
|
|
|
type reconcileFunc func(logger logr.Logger, key string, namespace string, name string) error
|
|
|
|
func Run(controllerName string, logger logr.Logger, queue workqueue.RateLimitingInterface, n, maxRetries int, r reconcileFunc, stopCh <-chan struct{}, cacheSyncs ...cache.InformerSynced) {
|
|
logger.Info("starting ...")
|
|
defer runtime.HandleCrash()
|
|
defer logger.Info("stopped")
|
|
var wg sync.WaitGroup
|
|
func() {
|
|
ctx, cancel := context.WithCancel(context.TODO())
|
|
defer cancel()
|
|
defer queue.ShutDown()
|
|
if !cache.WaitForNamedCacheSync(controllerName, stopCh, cacheSyncs...) {
|
|
return
|
|
}
|
|
for i := 0; i < n; i++ {
|
|
wg.Add(1)
|
|
go func(logger logr.Logger) {
|
|
logger.Info("starting worker")
|
|
defer wg.Done()
|
|
defer logger.Info("worker stopped")
|
|
wait.Until(func() { worker(logger, queue, maxRetries, r) }, time.Second, ctx.Done())
|
|
}(logger.WithValues("id", i))
|
|
}
|
|
<-stopCh
|
|
}()
|
|
logger.Info("waiting for workers to terminate ...")
|
|
wg.Wait()
|
|
}
|
|
|
|
func worker(logger logr.Logger, queue workqueue.RateLimitingInterface, maxRetries int, r reconcileFunc) {
|
|
for processNextWorkItem(logger, queue, maxRetries, r) {
|
|
}
|
|
}
|
|
|
|
func processNextWorkItem(logger logr.Logger, queue workqueue.RateLimitingInterface, maxRetries int, r reconcileFunc) bool {
|
|
if obj, quit := queue.Get(); !quit {
|
|
defer queue.Done(obj)
|
|
handleErr(logger, queue, maxRetries, reconcile(logger, obj, r), obj)
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func handleErr(logger logr.Logger, queue workqueue.RateLimitingInterface, maxRetries int, err error, obj interface{}) {
|
|
if err == nil {
|
|
queue.Forget(obj)
|
|
} else if errors.IsNotFound(err) {
|
|
logger.Info("Dropping request from the queue", "obj", obj, "error", err.Error())
|
|
queue.Forget(obj)
|
|
} else if queue.NumRequeues(obj) < maxRetries {
|
|
logger.Info("Retrying request", "obj", obj, "error", err.Error())
|
|
queue.AddRateLimited(obj)
|
|
} else {
|
|
logger.Error(err, "Failed to process request", "obj", obj)
|
|
queue.Forget(obj)
|
|
}
|
|
}
|
|
|
|
func reconcile(logger logr.Logger, obj interface{}, r reconcileFunc) error {
|
|
start := time.Now()
|
|
var k, ns, n string
|
|
if key, ok := obj.(cache.ExplicitKey); ok {
|
|
k = string(key)
|
|
} else {
|
|
k = obj.(string)
|
|
if namespace, name, err := cache.SplitMetaNamespaceKey(k); err != nil {
|
|
return err
|
|
} else {
|
|
ns, n = namespace, name
|
|
}
|
|
}
|
|
logger = logger.WithValues("key", k, "namespace", ns, "name", n)
|
|
logger.Info("reconciling ...")
|
|
defer logger.Info("done", time.Since(start))
|
|
return r(logger, k, ns, n)
|
|
}
|