package main import ( "fmt" "time" "k8s.io/apimachinery/pkg/api/meta" "k8s.io/apimachinery/pkg/labels" "k8s.io/client-go/informers" appslisters "k8s.io/client-go/listers/apps/v1" batchlisters "k8s.io/client-go/listers/batch/v1" corelisters "k8s.io/client-go/listers/core/v1" netlisters "k8s.io/client-go/listers/networking/v1" ) var ( nsLister corelisters.NamespaceLister podLister corelisters.PodLister svcLister corelisters.ServiceLister nodeLister corelisters.NodeLister deployLister appslisters.DeploymentLister stsLister appslisters.StatefulSetLister dsLister appslisters.DaemonSetLister cronLister batchlisters.CronJobLister ingLister netlisters.IngressLister ) func startInformers() error { f := informers.NewSharedInformerFactoryWithOptions(clientset, 0, // managedFields is most of a cached object's size and nothing here reads it informers.WithTransform(func(obj any) (any, error) { if a, err := meta.Accessor(obj); err == nil { a.SetManagedFields(nil) } return obj, nil })) nsLister = f.Core().V1().Namespaces().Lister() podLister = f.Core().V1().Pods().Lister() svcLister = f.Core().V1().Services().Lister() nodeLister = f.Core().V1().Nodes().Lister() deployLister = f.Apps().V1().Deployments().Lister() stsLister = f.Apps().V1().StatefulSets().Lister() dsLister = f.Apps().V1().DaemonSets().Lister() cronLister = f.Batch().V1().CronJobs().Lister() ingLister = f.Networking().V1().Ingresses().Lister() stop := make(chan struct{}) f.Start(stop) done := make(chan map[string]bool, 1) go func() { synced := map[string]bool{} for t, ok := range f.WaitForCacheSync(stop) { synced[fmt.Sprint(t)] = ok } done <- synced }() select { case synced := <-done: for t, ok := range synced { if !ok { return fmt.Errorf("cache for %s did not sync", t) } } return nil case <-time.After(90 * time.Second): return fmt.Errorf("caches did not sync in 90s") } } type listOf[T any] struct{ Items []T } // listAll reads a lister into the same shape a typed List() call returns, // so graph code iterates .Items unchanged. Items are copies: callers may not // mutate cached objects, and copying the top-level struct is cheap. func listAll[T any](l interface { List(labels.Selector) ([]*T, error) }) (*listOf[T], error) { ptrs, err := l.List(labels.Everything()) if err != nil { return nil, err } out := &listOf[T]{Items: make([]T, len(ptrs))} for i, p := range ptrs { out.Items[i] = *p } return out, nil }