1/* 2Copyright The Kubernetes Authors. 3 4Licensed under the Apache License, Version 2.0 (the "License"); 5you may not use this file except in compliance with the License. 6You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10Unless required by applicable law or agreed to in writing, software 11distributed under the License is distributed on an "AS IS" BASIS, 12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13See the License for the specific language governing permissions and 14limitations under the License. 15*/ 16 17// Code generated by informer-gen. DO NOT EDIT. 18 19package externalversions 20 21import ( 22 reflect "reflect" 23 sync "sync" 24 time "time" 25 26 v1 "k8s.io/apimachinery/pkg/apis/meta/v1" 27 runtime "k8s.io/apimachinery/pkg/runtime" 28 schema "k8s.io/apimachinery/pkg/runtime/schema" 29 cache "k8s.io/client-go/tools/cache" 30 versioned "k8s.io/code-generator/_examples/MixedCase/clientset/versioned" 31 example "k8s.io/code-generator/_examples/MixedCase/informers/externalversions/example" 32 internalinterfaces "k8s.io/code-generator/_examples/MixedCase/informers/externalversions/internalinterfaces" 33) 34 35// SharedInformerOption defines the functional option type for SharedInformerFactory. 36type SharedInformerOption func(*sharedInformerFactory) *sharedInformerFactory 37 38type sharedInformerFactory struct { 39 client versioned.Interface 40 namespace string 41 tweakListOptions internalinterfaces.TweakListOptionsFunc 42 lock sync.Mutex 43 defaultResync time.Duration 44 customResync map[reflect.Type]time.Duration 45 46 informers map[reflect.Type]cache.SharedIndexInformer 47 // startedInformers is used for tracking which informers have been started. 48 // This allows Start() to be called multiple times safely. 49 startedInformers map[reflect.Type]bool 50} 51 52// WithCustomResyncConfig sets a custom resync period for the specified informer types. 53func WithCustomResyncConfig(resyncConfig map[v1.Object]time.Duration) SharedInformerOption { 54 return func(factory *sharedInformerFactory) *sharedInformerFactory { 55 for k, v := range resyncConfig { 56 factory.customResync[reflect.TypeOf(k)] = v 57 } 58 return factory 59 } 60} 61 62// WithTweakListOptions sets a custom filter on all listers of the configured SharedInformerFactory. 63func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption { 64 return func(factory *sharedInformerFactory) *sharedInformerFactory { 65 factory.tweakListOptions = tweakListOptions 66 return factory 67 } 68} 69 70// WithNamespace limits the SharedInformerFactory to the specified namespace. 71func WithNamespace(namespace string) SharedInformerOption { 72 return func(factory *sharedInformerFactory) *sharedInformerFactory { 73 factory.namespace = namespace 74 return factory 75 } 76} 77 78// NewSharedInformerFactory constructs a new instance of sharedInformerFactory for all namespaces. 79func NewSharedInformerFactory(client versioned.Interface, defaultResync time.Duration) SharedInformerFactory { 80 return NewSharedInformerFactoryWithOptions(client, defaultResync) 81} 82 83// NewFilteredSharedInformerFactory constructs a new instance of sharedInformerFactory. 84// Listers obtained via this SharedInformerFactory will be subject to the same filters 85// as specified here. 86// Deprecated: Please use NewSharedInformerFactoryWithOptions instead 87func NewFilteredSharedInformerFactory(client versioned.Interface, defaultResync time.Duration, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerFactory { 88 return NewSharedInformerFactoryWithOptions(client, defaultResync, WithNamespace(namespace), WithTweakListOptions(tweakListOptions)) 89} 90 91// NewSharedInformerFactoryWithOptions constructs a new instance of a SharedInformerFactory with additional options. 92func NewSharedInformerFactoryWithOptions(client versioned.Interface, defaultResync time.Duration, options ...SharedInformerOption) SharedInformerFactory { 93 factory := &sharedInformerFactory{ 94 client: client, 95 namespace: v1.NamespaceAll, 96 defaultResync: defaultResync, 97 informers: make(map[reflect.Type]cache.SharedIndexInformer), 98 startedInformers: make(map[reflect.Type]bool), 99 customResync: make(map[reflect.Type]time.Duration), 100 } 101 102 // Apply all options 103 for _, opt := range options { 104 factory = opt(factory) 105 } 106 107 return factory 108} 109 110// Start initializes all requested informers. 111func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) { 112 f.lock.Lock() 113 defer f.lock.Unlock() 114 115 for informerType, informer := range f.informers { 116 if !f.startedInformers[informerType] { 117 go informer.Run(stopCh) 118 f.startedInformers[informerType] = true 119 } 120 } 121} 122 123// WaitForCacheSync waits for all started informers' cache were synced. 124func (f *sharedInformerFactory) WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool { 125 informers := func() map[reflect.Type]cache.SharedIndexInformer { 126 f.lock.Lock() 127 defer f.lock.Unlock() 128 129 informers := map[reflect.Type]cache.SharedIndexInformer{} 130 for informerType, informer := range f.informers { 131 if f.startedInformers[informerType] { 132 informers[informerType] = informer 133 } 134 } 135 return informers 136 }() 137 138 res := map[reflect.Type]bool{} 139 for informType, informer := range informers { 140 res[informType] = cache.WaitForCacheSync(stopCh, informer.HasSynced) 141 } 142 return res 143} 144 145// InternalInformerFor returns the SharedIndexInformer for obj using an internal 146// client. 147func (f *sharedInformerFactory) InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer { 148 f.lock.Lock() 149 defer f.lock.Unlock() 150 151 informerType := reflect.TypeOf(obj) 152 informer, exists := f.informers[informerType] 153 if exists { 154 return informer 155 } 156 157 resyncPeriod, exists := f.customResync[informerType] 158 if !exists { 159 resyncPeriod = f.defaultResync 160 } 161 162 informer = newFunc(f.client, resyncPeriod) 163 f.informers[informerType] = informer 164 165 return informer 166} 167 168// SharedInformerFactory provides shared informers for resources in all known 169// API group versions. 170type SharedInformerFactory interface { 171 internalinterfaces.SharedInformerFactory 172 ForResource(resource schema.GroupVersionResource) (GenericInformer, error) 173 WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool 174 175 Example() example.Interface 176} 177 178func (f *sharedInformerFactory) Example() example.Interface { 179 return example.New(f, f.namespace, f.tweakListOptions) 180} 181