1
0
Fork 0
mirror of https://github.com/kyverno/kyverno.git synced 2025-03-13 11:18:47 +00:00

chore: remove unused resourcecache package (#3762)

This commit is contained in:
Charles-Edouard Brétéché 2022-05-02 16:15:44 +02:00 committed by GitHub
parent 972be16ad3
commit 45e3bf452a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 0 additions and 228 deletions

View file

@ -1,65 +0,0 @@
package resourcecache
import (
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/client-go/dynamic/dynamiclister"
"k8s.io/client-go/informers"
"k8s.io/client-go/tools/cache"
)
// GenericCache - allows operation on a single resource
type GenericCache interface {
StopInformer()
IsNamespaced() bool
Lister() dynamiclister.Lister
NamespacedLister(namespace string) dynamiclister.NamespaceLister
GVR() schema.GroupVersionResource
GetInformer() cache.SharedIndexInformer
}
type genericCache struct {
// GVR Group Version Resource of a resource
gvr schema.GroupVersionResource
// Namespaced - identifies if a resource is namespaced or not
namespaced bool
// stopCh - channel to stop the informer when needed
stopCh chan struct{}
// genericInformer - contains instance of informers.GenericInformer for a specific resource
// which in turn contains Listers() which gives access to cached resources.
genericInformer informers.GenericInformer
}
// NewGVRCache ...
func NewGVRCache(gvr schema.GroupVersionResource, namespaced bool, stopCh chan struct{}, genericInformer informers.GenericInformer) GenericCache {
return &genericCache{gvr: gvr, namespaced: namespaced, stopCh: stopCh, genericInformer: genericInformer}
}
// GVR gets GroupVersionResource
func (gc *genericCache) GVR() schema.GroupVersionResource {
return gc.gvr
}
// StopInformer ...
func (gc *genericCache) StopInformer() {
close(gc.stopCh)
}
// IsNamespaced ...
func (gc *genericCache) IsNamespaced() bool {
return gc.namespaced
}
// Lister - get access to Lister() instance of a resource in GVRCache
func (gc *genericCache) Lister() dynamiclister.Lister {
return dynamiclister.New(gc.genericInformer.Informer().GetIndexer(), gc.GVR())
}
// NamespacedLister - get access to namespaced Lister() instance of a resource in GVRCache
func (gc *genericCache) NamespacedLister(namespace string) dynamiclister.NamespaceLister {
return dynamiclister.New(gc.genericInformer.Informer().GetIndexer(), gc.GVR()).Namespace(namespace)
}
// GetInformer gets SharedIndexInformer
func (gc *genericCache) GetInformer() cache.SharedIndexInformer {
return gc.genericInformer.Informer()
}

View file

@ -1,45 +0,0 @@
package resourcecache
import (
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/client-go/tools/cache"
)
// TODO :- Implementation for mocking
type TestGVRCache struct {
}
func NewTestGVRCache() GenericCache {
return &genericCache{}
}
func (tg *TestGVRCache) StopInformer() {
}
func (tg *TestGVRCache) IsNamespaced() bool {
return true
}
func (tg *TestGVRCache) GetLister() cache.GenericLister {
return &TestLister{}
}
func (tg *TestGVRCache) GetNamespacedLister(namespace string) cache.GenericNamespaceLister {
return &TestLister{}
}
type TestLister struct {
}
func (tl *TestLister) List(selector labels.Selector) ([]runtime.Object, error) {
return []runtime.Object{}, nil
}
func (tl *TestLister) Get(name string) (runtime.Object, error) {
return nil, nil
}
func (tl *TestLister) ByNamespace(namespace string) cache.GenericNamespaceLister {
return &TestLister{}
}

View file

@ -1,53 +0,0 @@
package resourcecache
import (
"fmt"
"github.com/go-logr/logr"
dclient "github.com/kyverno/kyverno/pkg/dclient"
cmap "github.com/orcaman/concurrent-map"
"k8s.io/client-go/dynamic/dynamicinformer"
)
// ResourceCache - allows the creation, deletion and saving the resource informers as a cache
// the resource cache can be registered by gvks as follows:
// - group/version/kind
// - group/kind
// - kind
type ResourceCache interface {
CreateInformers(gvks ...string) []error
CreateGVKInformer(gvk string) (GenericCache, error)
StopResourceInformer(gvk string)
GetGVRCache(gvk string) (GenericCache, bool)
}
type resourceCache struct {
dclient *dclient.Client
dinformer dynamicinformer.DynamicSharedInformerFactory
// gvrCache - stores the manipulate factory for a resource
// it uses resource name as key (i.e., namespaces for Namespace, pods for Pod, clusterpolicies for ClusterPolicy, etc)
gvrCache cmap.ConcurrentMap
log logr.Logger
}
var KyvernoDefaultInformer = []string{}
// NewResourceCache - initializes the ResourceCache
func NewResourceCache(dclient *dclient.Client, dInformer dynamicinformer.DynamicSharedInformerFactory, logger logr.Logger) (ResourceCache, error) {
rCache := &resourceCache{
dclient: dclient,
gvrCache: cmap.New(),
dinformer: dInformer,
log: logger,
}
errs := rCache.CreateInformers(KyvernoDefaultInformer...)
if len(errs) != 0 {
return rCache, fmt.Errorf("failed to register default informers %v", errs)
}
return rCache, nil
}

View file

@ -1,65 +0,0 @@
package resourcecache
import (
"fmt"
kubeutils "github.com/kyverno/kyverno/pkg/utils/kube"
)
// CreateInformers ...
func (resc *resourceCache) CreateInformers(resources ...string) []error {
var errs []error
for _, resource := range resources {
if _, err := resc.CreateGVKInformer(resource); err != nil {
errs = append(errs, fmt.Errorf("failed to create informer for %s: %v", resource, err))
}
}
return errs
}
// StopResourceInformer - delete the given resource information from ResourceCache and stop watching for the given resource
func (resc *resourceCache) StopResourceInformer(resource string) {
res, ok := resc.GetGVRCache(resource)
if ok {
resc.gvrCache.Remove(resource)
resc.log.V(4).Info("deleted resource from gvr cache", "name", resource)
res.StopInformer()
resc.log.V(4).Info("closed informer for resource", "name", resource)
}
}
// GetGVRCache - get the GVRCache for a given resource if available
func (resc *resourceCache) GetGVRCache(resource string) (GenericCache, bool) {
res, ok := resc.gvrCache.Get(resource)
if ok {
return res.(*genericCache), true
}
return nil, false
}
// CreateGVKInformer creates informer for the given gvk
func (resc *resourceCache) CreateGVKInformer(gvk string) (GenericCache, error) {
gc, ok := resc.GetGVRCache(gvk)
if ok {
return gc, nil
}
gv, k := kubeutils.GetKindFromGVK(gvk)
apiResource, gvr, err := resc.dclient.DiscoveryClient.FindResource(gv, k)
if err != nil {
return nil, fmt.Errorf("cannot find API resource %s", gvk)
}
stopCh := make(chan struct{})
genInformer := resc.dinformer.ForResource(gvr)
gvrIface := NewGVRCache(gvr, apiResource.Namespaced, stopCh, genInformer)
resc.gvrCache.Set(gvk, gvrIface)
resc.dinformer.Start(stopCh)
if synced := resc.dinformer.WaitForCacheSync(stopCh); !synced[gvr] {
return nil, fmt.Errorf("informer for %s hasn't synced", gvr)
}
return gvrIface, nil
}