admin/kubesphere
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Integrate all receivers into one crd, and all configs into another crd

Browse Source 
Signed-off-by: wanjunlei <wanjunlei@yunify.com>
This commit is contained in:
wanjunlei
2021-03-10 18:36:54 +08:00
parent d6d2cf002f
commit e3cf58e84b
130 changed files with 3980 additions and 13850 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
pkg/client/informers/externalversions/generic.go
View File

@@ -30,7 +30,7 @@ import (
v1alpha3 "kubesphere.io/kubesphere/pkg/apis/devops/v1alpha3"
v1alpha2 "kubesphere.io/kubesphere/pkg/apis/iam/v1alpha2"
networkv1alpha1 "kubesphere.io/kubesphere/pkg/apis/network/v1alpha1"
v2alpha1 "kubesphere.io/kubesphere/pkg/apis/notification/v2alpha1"
v2beta1 "kubesphere.io/kubesphere/pkg/apis/notification/v2beta1"
quotav1alpha2 "kubesphere.io/kubesphere/pkg/apis/quota/v1alpha2"
servicemeshv1alpha2 "kubesphere.io/kubesphere/pkg/apis/servicemesh/v1alpha2"
storagev1alpha1 "kubesphere.io/kubesphere/pkg/apis/storage/v1alpha1"
@@ -133,27 +133,11 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource
case networkv1alpha1.SchemeGroupVersion.WithResource("namespacenetworkpolicies"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Network().V1alpha1().NamespaceNetworkPolicies().Informer()}, nil
// Group=notification.kubesphere.io, Version=v2alpha1
case v2alpha1.SchemeGroupVersion.WithResource("dingtalkconfigs"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Notification().V2alpha1().DingTalkConfigs().Informer()}, nil
case v2alpha1.SchemeGroupVersion.WithResource("dingtalkreceivers"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Notification().V2alpha1().DingTalkReceivers().Informer()}, nil
case v2alpha1.SchemeGroupVersion.WithResource("emailconfigs"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Notification().V2alpha1().EmailConfigs().Informer()}, nil
case v2alpha1.SchemeGroupVersion.WithResource("emailreceivers"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Notification().V2alpha1().EmailReceivers().Informer()}, nil
case v2alpha1.SchemeGroupVersion.WithResource("slackconfigs"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Notification().V2alpha1().SlackConfigs().Informer()}, nil
case v2alpha1.SchemeGroupVersion.WithResource("slackreceivers"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Notification().V2alpha1().SlackReceivers().Informer()}, nil
case v2alpha1.SchemeGroupVersion.WithResource("webhookconfigs"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Notification().V2alpha1().WebhookConfigs().Informer()}, nil
case v2alpha1.SchemeGroupVersion.WithResource("webhookreceivers"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Notification().V2alpha1().WebhookReceivers().Informer()}, nil
case v2alpha1.SchemeGroupVersion.WithResource("wechatconfigs"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Notification().V2alpha1().WechatConfigs().Informer()}, nil
case v2alpha1.SchemeGroupVersion.WithResource("wechatreceivers"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Notification().V2alpha1().WechatReceivers().Informer()}, nil
// Group=notification.kubesphere.io, Version=v2beta1
case v2beta1.SchemeGroupVersion.WithResource("configs"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Notification().V2beta1().Configs().Informer()}, nil
case v2beta1.SchemeGroupVersion.WithResource("receivers"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Notification().V2beta1().Receivers().Informer()}, nil
// Group=quota.kubesphere.io, Version=v1alpha2
case quotav1alpha2.SchemeGroupVersion.WithResource("resourcequotas"):

12
pkg/client/informers/externalversions/notification/interface.go
View File

@@ -20,13 +20,13 @@ package notification
import (
internalinterfaces "kubesphere.io/kubesphere/pkg/client/informers/externalversions/internalinterfaces"
v2alpha1 "kubesphere.io/kubesphere/pkg/client/informers/externalversions/notification/v2alpha1"
v2beta1 "kubesphere.io/kubesphere/pkg/client/informers/externalversions/notification/v2beta1"
)
// Interface provides access to each of this group's versions.
type Interface interface {
// V2alpha1 provides access to shared informers for resources in V2alpha1.
V2alpha1() v2alpha1.Interface
// V2beta1 provides access to shared informers for resources in V2beta1.
V2beta1() v2beta1.Interface
}
type group struct {
@@ -40,7 +40,7 @@ func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakList
return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
}
// V2alpha1 returns a new v2alpha1.Interface.
func (g *group) V2alpha1() v2alpha1.Interface {
return v2alpha1.New(g.factory, g.namespace, g.tweakListOptions)
// V2beta1 returns a new v2beta1.Interface.
func (g *group) V2beta1() v2beta1.Interface {
return v2beta1.New(g.factory, g.namespace, g.tweakListOptions)
}

89
pkg/client/informers/externalversions/notification/v2alpha1/dingtalkconfig.go
View File

@@ -1,89 +0,0 @@
/*
Copyright 2020 The KubeSphere Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Code generated by informer-gen. DO NOT EDIT.
package v2alpha1
import (
"context"
time "time"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
notificationv2alpha1 "kubesphere.io/kubesphere/pkg/apis/notification/v2alpha1"
versioned "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
internalinterfaces "kubesphere.io/kubesphere/pkg/client/informers/externalversions/internalinterfaces"
v2alpha1 "kubesphere.io/kubesphere/pkg/client/listers/notification/v2alpha1"
)
// DingTalkConfigInformer provides access to a shared informer and lister for
// DingTalkConfigs.
type DingTalkConfigInformer interface {
Informer() cache.SharedIndexInformer
Lister() v2alpha1.DingTalkConfigLister
}
type dingTalkConfigInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
}
// NewDingTalkConfigInformer constructs a new informer for DingTalkConfig type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewDingTalkConfigInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredDingTalkConfigInformer(client, resyncPeriod, indexers, nil)
}
// NewFilteredDingTalkConfigInformer constructs a new informer for DingTalkConfig type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredDingTalkConfigInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().DingTalkConfigs().List(context.TODO(), options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().DingTalkConfigs().Watch(context.TODO(), options)
},
},
&notificationv2alpha1.DingTalkConfig{},
resyncPeriod,
indexers,
)
}
func (f *dingTalkConfigInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredDingTalkConfigInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *dingTalkConfigInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&notificationv2alpha1.DingTalkConfig{}, f.defaultInformer)
}
func (f *dingTalkConfigInformer) Lister() v2alpha1.DingTalkConfigLister {
return v2alpha1.NewDingTalkConfigLister(f.Informer().GetIndexer())
}

89
pkg/client/informers/externalversions/notification/v2alpha1/dingtalkreceiver.go
View File

@@ -1,89 +0,0 @@
/*
Copyright 2020 The KubeSphere Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Code generated by informer-gen. DO NOT EDIT.
package v2alpha1
import (
"context"
time "time"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
notificationv2alpha1 "kubesphere.io/kubesphere/pkg/apis/notification/v2alpha1"
versioned "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
internalinterfaces "kubesphere.io/kubesphere/pkg/client/informers/externalversions/internalinterfaces"
v2alpha1 "kubesphere.io/kubesphere/pkg/client/listers/notification/v2alpha1"
)
// DingTalkReceiverInformer provides access to a shared informer and lister for
// DingTalkReceivers.
type DingTalkReceiverInformer interface {
Informer() cache.SharedIndexInformer
Lister() v2alpha1.DingTalkReceiverLister
}
type dingTalkReceiverInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
}
// NewDingTalkReceiverInformer constructs a new informer for DingTalkReceiver type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewDingTalkReceiverInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredDingTalkReceiverInformer(client, resyncPeriod, indexers, nil)
}
// NewFilteredDingTalkReceiverInformer constructs a new informer for DingTalkReceiver type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredDingTalkReceiverInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().DingTalkReceivers().List(context.TODO(), options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().DingTalkReceivers().Watch(context.TODO(), options)
},
},
&notificationv2alpha1.DingTalkReceiver{},
resyncPeriod,
indexers,
)
}
func (f *dingTalkReceiverInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredDingTalkReceiverInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *dingTalkReceiverInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&notificationv2alpha1.DingTalkReceiver{}, f.defaultInformer)
}
func (f *dingTalkReceiverInformer) Lister() v2alpha1.DingTalkReceiverLister {
return v2alpha1.NewDingTalkReceiverLister(f.Informer().GetIndexer())
}

89
pkg/client/informers/externalversions/notification/v2alpha1/emailreceiver.go
View File

@@ -1,89 +0,0 @@
/*
Copyright 2020 The KubeSphere Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Code generated by informer-gen. DO NOT EDIT.
package v2alpha1
import (
"context"
time "time"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
notificationv2alpha1 "kubesphere.io/kubesphere/pkg/apis/notification/v2alpha1"
versioned "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
internalinterfaces "kubesphere.io/kubesphere/pkg/client/informers/externalversions/internalinterfaces"
v2alpha1 "kubesphere.io/kubesphere/pkg/client/listers/notification/v2alpha1"
)
// EmailReceiverInformer provides access to a shared informer and lister for
// EmailReceivers.
type EmailReceiverInformer interface {
Informer() cache.SharedIndexInformer
Lister() v2alpha1.EmailReceiverLister
}
type emailReceiverInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
}
// NewEmailReceiverInformer constructs a new informer for EmailReceiver type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewEmailReceiverInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredEmailReceiverInformer(client, resyncPeriod, indexers, nil)
}
// NewFilteredEmailReceiverInformer constructs a new informer for EmailReceiver type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredEmailReceiverInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().EmailReceivers().List(context.TODO(), options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().EmailReceivers().Watch(context.TODO(), options)
},
},
&notificationv2alpha1.EmailReceiver{},
resyncPeriod,
indexers,
)
}
func (f *emailReceiverInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredEmailReceiverInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *emailReceiverInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&notificationv2alpha1.EmailReceiver{}, f.defaultInformer)
}
func (f *emailReceiverInformer) Lister() v2alpha1.EmailReceiverLister {
return v2alpha1.NewEmailReceiverLister(f.Informer().GetIndexer())
}

108
pkg/client/informers/externalversions/notification/v2alpha1/interface.go
View File

@@ -1,108 +0,0 @@
/*
Copyright 2020 The KubeSphere Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Code generated by informer-gen. DO NOT EDIT.
package v2alpha1
import (
internalinterfaces "kubesphere.io/kubesphere/pkg/client/informers/externalversions/internalinterfaces"
)
// Interface provides access to all the informers in this group version.
type Interface interface {
// DingTalkConfigs returns a DingTalkConfigInformer.
DingTalkConfigs() DingTalkConfigInformer
// DingTalkReceivers returns a DingTalkReceiverInformer.
DingTalkReceivers() DingTalkReceiverInformer
// EmailConfigs returns a EmailConfigInformer.
EmailConfigs() EmailConfigInformer
// EmailReceivers returns a EmailReceiverInformer.
EmailReceivers() EmailReceiverInformer
// SlackConfigs returns a SlackConfigInformer.
SlackConfigs() SlackConfigInformer
// SlackReceivers returns a SlackReceiverInformer.
SlackReceivers() SlackReceiverInformer
// WebhookConfigs returns a WebhookConfigInformer.
WebhookConfigs() WebhookConfigInformer
// WebhookReceivers returns a WebhookReceiverInformer.
WebhookReceivers() WebhookReceiverInformer
// WechatConfigs returns a WechatConfigInformer.
WechatConfigs() WechatConfigInformer
// WechatReceivers returns a WechatReceiverInformer.
WechatReceivers() WechatReceiverInformer
}
type version struct {
factory internalinterfaces.SharedInformerFactory
namespace string
tweakListOptions internalinterfaces.TweakListOptionsFunc
}
// New returns a new Interface.
func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
}
// DingTalkConfigs returns a DingTalkConfigInformer.
func (v *version) DingTalkConfigs() DingTalkConfigInformer {
return &dingTalkConfigInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
}
// DingTalkReceivers returns a DingTalkReceiverInformer.
func (v *version) DingTalkReceivers() DingTalkReceiverInformer {
return &dingTalkReceiverInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
}
// EmailConfigs returns a EmailConfigInformer.
func (v *version) EmailConfigs() EmailConfigInformer {
return &emailConfigInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
}
// EmailReceivers returns a EmailReceiverInformer.
func (v *version) EmailReceivers() EmailReceiverInformer {
return &emailReceiverInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
}
// SlackConfigs returns a SlackConfigInformer.
func (v *version) SlackConfigs() SlackConfigInformer {
return &slackConfigInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
}
// SlackReceivers returns a SlackReceiverInformer.
func (v *version) SlackReceivers() SlackReceiverInformer {
return &slackReceiverInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
}
// WebhookConfigs returns a WebhookConfigInformer.
func (v *version) WebhookConfigs() WebhookConfigInformer {
return &webhookConfigInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
}
// WebhookReceivers returns a WebhookReceiverInformer.
func (v *version) WebhookReceivers() WebhookReceiverInformer {
return &webhookReceiverInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
}
// WechatConfigs returns a WechatConfigInformer.
func (v *version) WechatConfigs() WechatConfigInformer {
return &wechatConfigInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
}
// WechatReceivers returns a WechatReceiverInformer.
func (v *version) WechatReceivers() WechatReceiverInformer {
return &wechatReceiverInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
}

89
pkg/client/informers/externalversions/notification/v2alpha1/slackreceiver.go
View File

@@ -1,89 +0,0 @@
/*
Copyright 2020 The KubeSphere Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Code generated by informer-gen. DO NOT EDIT.
package v2alpha1
import (
"context"
time "time"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
notificationv2alpha1 "kubesphere.io/kubesphere/pkg/apis/notification/v2alpha1"
versioned "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
internalinterfaces "kubesphere.io/kubesphere/pkg/client/informers/externalversions/internalinterfaces"
v2alpha1 "kubesphere.io/kubesphere/pkg/client/listers/notification/v2alpha1"
)
// SlackReceiverInformer provides access to a shared informer and lister for
// SlackReceivers.
type SlackReceiverInformer interface {
Informer() cache.SharedIndexInformer
Lister() v2alpha1.SlackReceiverLister
}
type slackReceiverInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
}
// NewSlackReceiverInformer constructs a new informer for SlackReceiver type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewSlackReceiverInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredSlackReceiverInformer(client, resyncPeriod, indexers, nil)
}
// NewFilteredSlackReceiverInformer constructs a new informer for SlackReceiver type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredSlackReceiverInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().SlackReceivers().List(context.TODO(), options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().SlackReceivers().Watch(context.TODO(), options)
},
},
&notificationv2alpha1.SlackReceiver{},
resyncPeriod,
indexers,
)
}
func (f *slackReceiverInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredSlackReceiverInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *slackReceiverInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&notificationv2alpha1.SlackReceiver{}, f.defaultInformer)
}
func (f *slackReceiverInformer) Lister() v2alpha1.SlackReceiverLister {
return v2alpha1.NewSlackReceiverLister(f.Informer().GetIndexer())
}

89
pkg/client/informers/externalversions/notification/v2alpha1/webhookconfig.go
View File

@@ -1,89 +0,0 @@
/*
Copyright 2020 The KubeSphere Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Code generated by informer-gen. DO NOT EDIT.
package v2alpha1
import (
"context"
time "time"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
notificationv2alpha1 "kubesphere.io/kubesphere/pkg/apis/notification/v2alpha1"
versioned "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
internalinterfaces "kubesphere.io/kubesphere/pkg/client/informers/externalversions/internalinterfaces"
v2alpha1 "kubesphere.io/kubesphere/pkg/client/listers/notification/v2alpha1"
)
// WebhookConfigInformer provides access to a shared informer and lister for
// WebhookConfigs.
type WebhookConfigInformer interface {
Informer() cache.SharedIndexInformer
Lister() v2alpha1.WebhookConfigLister
}
type webhookConfigInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
}
// NewWebhookConfigInformer constructs a new informer for WebhookConfig type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewWebhookConfigInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredWebhookConfigInformer(client, resyncPeriod, indexers, nil)
}
// NewFilteredWebhookConfigInformer constructs a new informer for WebhookConfig type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredWebhookConfigInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().WebhookConfigs().List(context.TODO(), options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().WebhookConfigs().Watch(context.TODO(), options)
},
},
&notificationv2alpha1.WebhookConfig{},
resyncPeriod,
indexers,
)
}
func (f *webhookConfigInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredWebhookConfigInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *webhookConfigInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&notificationv2alpha1.WebhookConfig{}, f.defaultInformer)
}
func (f *webhookConfigInformer) Lister() v2alpha1.WebhookConfigLister {
return v2alpha1.NewWebhookConfigLister(f.Informer().GetIndexer())
}

89
pkg/client/informers/externalversions/notification/v2alpha1/webhookreceiver.go
View File

@@ -1,89 +0,0 @@
/*
Copyright 2020 The KubeSphere Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Code generated by informer-gen. DO NOT EDIT.
package v2alpha1
import (
"context"
time "time"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
notificationv2alpha1 "kubesphere.io/kubesphere/pkg/apis/notification/v2alpha1"
versioned "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
internalinterfaces "kubesphere.io/kubesphere/pkg/client/informers/externalversions/internalinterfaces"
v2alpha1 "kubesphere.io/kubesphere/pkg/client/listers/notification/v2alpha1"
)
// WebhookReceiverInformer provides access to a shared informer and lister for
// WebhookReceivers.
type WebhookReceiverInformer interface {
Informer() cache.SharedIndexInformer
Lister() v2alpha1.WebhookReceiverLister
}
type webhookReceiverInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
}
// NewWebhookReceiverInformer constructs a new informer for WebhookReceiver type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewWebhookReceiverInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredWebhookReceiverInformer(client, resyncPeriod, indexers, nil)
}
// NewFilteredWebhookReceiverInformer constructs a new informer for WebhookReceiver type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredWebhookReceiverInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().WebhookReceivers().List(context.TODO(), options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().WebhookReceivers().Watch(context.TODO(), options)
},
},
&notificationv2alpha1.WebhookReceiver{},
resyncPeriod,
indexers,
)
}
func (f *webhookReceiverInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredWebhookReceiverInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *webhookReceiverInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&notificationv2alpha1.WebhookReceiver{}, f.defaultInformer)
}
func (f *webhookReceiverInformer) Lister() v2alpha1.WebhookReceiverLister {
return v2alpha1.NewWebhookReceiverLister(f.Informer().GetIndexer())
}

89
pkg/client/informers/externalversions/notification/v2alpha1/wechatconfig.go
View File

@@ -1,89 +0,0 @@
/*
Copyright 2020 The KubeSphere Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Code generated by informer-gen. DO NOT EDIT.
package v2alpha1
import (
"context"
time "time"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
notificationv2alpha1 "kubesphere.io/kubesphere/pkg/apis/notification/v2alpha1"
versioned "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
internalinterfaces "kubesphere.io/kubesphere/pkg/client/informers/externalversions/internalinterfaces"
v2alpha1 "kubesphere.io/kubesphere/pkg/client/listers/notification/v2alpha1"
)
// WechatConfigInformer provides access to a shared informer and lister for
// WechatConfigs.
type WechatConfigInformer interface {
Informer() cache.SharedIndexInformer
Lister() v2alpha1.WechatConfigLister
}
type wechatConfigInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
}
// NewWechatConfigInformer constructs a new informer for WechatConfig type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewWechatConfigInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredWechatConfigInformer(client, resyncPeriod, indexers, nil)
}
// NewFilteredWechatConfigInformer constructs a new informer for WechatConfig type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredWechatConfigInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().WechatConfigs().List(context.TODO(), options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().WechatConfigs().Watch(context.TODO(), options)
},
},
&notificationv2alpha1.WechatConfig{},
resyncPeriod,
indexers,
)
}
func (f *wechatConfigInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredWechatConfigInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *wechatConfigInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&notificationv2alpha1.WechatConfig{}, f.defaultInformer)
}
func (f *wechatConfigInformer) Lister() v2alpha1.WechatConfigLister {
return v2alpha1.NewWechatConfigLister(f.Informer().GetIndexer())
}

89
pkg/client/informers/externalversions/notification/v2alpha1/wechatreceiver.go
View File

@@ -1,89 +0,0 @@
/*
Copyright 2020 The KubeSphere Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Code generated by informer-gen. DO NOT EDIT.
package v2alpha1
import (
"context"
time "time"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
notificationv2alpha1 "kubesphere.io/kubesphere/pkg/apis/notification/v2alpha1"
versioned "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
internalinterfaces "kubesphere.io/kubesphere/pkg/client/informers/externalversions/internalinterfaces"
v2alpha1 "kubesphere.io/kubesphere/pkg/client/listers/notification/v2alpha1"
)
// WechatReceiverInformer provides access to a shared informer and lister for
// WechatReceivers.
type WechatReceiverInformer interface {
Informer() cache.SharedIndexInformer
Lister() v2alpha1.WechatReceiverLister
}
type wechatReceiverInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
}
// NewWechatReceiverInformer constructs a new informer for WechatReceiver type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewWechatReceiverInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredWechatReceiverInformer(client, resyncPeriod, indexers, nil)
}
// NewFilteredWechatReceiverInformer constructs a new informer for WechatReceiver type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredWechatReceiverInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().WechatReceivers().List(context.TODO(), options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().WechatReceivers().Watch(context.TODO(), options)
},
},
&notificationv2alpha1.WechatReceiver{},
resyncPeriod,
indexers,
)
}
func (f *wechatReceiverInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredWechatReceiverInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *wechatReceiverInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&notificationv2alpha1.WechatReceiver{}, f.defaultInformer)
}
func (f *wechatReceiverInformer) Lister() v2alpha1.WechatReceiverLister {
return v2alpha1.NewWechatReceiverLister(f.Informer().GetIndexer())
}

44
pkg/client/informers/externalversions/notification/v2alpha1/slackconfig.go → pkg/client/informers/externalversions/notification/v2beta1/config.go
View File

@@ -16,7 +16,7 @@ limitations under the License.
// Code generated by informer-gen. DO NOT EDIT.
package v2alpha1
package v2beta1
import (
"context"
@@ -26,64 +26,64 @@ import (
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
notificationv2alpha1 "kubesphere.io/kubesphere/pkg/apis/notification/v2alpha1"
notificationv2beta1 "kubesphere.io/kubesphere/pkg/apis/notification/v2beta1"
versioned "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
internalinterfaces "kubesphere.io/kubesphere/pkg/client/informers/externalversions/internalinterfaces"
v2alpha1 "kubesphere.io/kubesphere/pkg/client/listers/notification/v2alpha1"
v2beta1 "kubesphere.io/kubesphere/pkg/client/listers/notification/v2beta1"
)
// SlackConfigInformer provides access to a shared informer and lister for
// SlackConfigs.
type SlackConfigInformer interface {
// ConfigInformer provides access to a shared informer and lister for
// Configs.
type ConfigInformer interface {
Informer() cache.SharedIndexInformer
Lister() v2alpha1.SlackConfigLister
Lister() v2beta1.ConfigLister
}
type slackConfigInformer struct {
type configInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
}
// NewSlackConfigInformer constructs a new informer for SlackConfig type.
// NewConfigInformer constructs a new informer for Config type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewSlackConfigInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredSlackConfigInformer(client, resyncPeriod, indexers, nil)
func NewConfigInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredConfigInformer(client, resyncPeriod, indexers, nil)
}
// NewFilteredSlackConfigInformer constructs a new informer for SlackConfig type.
// NewFilteredConfigInformer constructs a new informer for Config type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredSlackConfigInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
func NewFilteredConfigInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().SlackConfigs().List(context.TODO(), options)
return client.NotificationV2beta1().Configs().List(context.TODO(), options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().SlackConfigs().Watch(context.TODO(), options)
return client.NotificationV2beta1().Configs().Watch(context.TODO(), options)
},
},
&notificationv2alpha1.SlackConfig{},
&notificationv2beta1.Config{},
resyncPeriod,
indexers,
)
}
func (f *slackConfigInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredSlackConfigInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
func (f *configInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredConfigInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *slackConfigInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&notificationv2alpha1.SlackConfig{}, f.defaultInformer)
func (f *configInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&notificationv2beta1.Config{}, f.defaultInformer)
}
func (f *slackConfigInformer) Lister() v2alpha1.SlackConfigLister {
return v2alpha1.NewSlackConfigLister(f.Informer().GetIndexer())
func (f *configInformer) Lister() v2beta1.ConfigLister {
return v2beta1.NewConfigLister(f.Informer().GetIndexer())
}

52
pkg/client/informers/externalversions/notification/v2beta1/interface.go Normal file
View File

@@ -0,0 +1,52 @@
/*
Copyright 2020 The KubeSphere Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Code generated by informer-gen. DO NOT EDIT.
package v2beta1
import (
internalinterfaces "kubesphere.io/kubesphere/pkg/client/informers/externalversions/internalinterfaces"
)
// Interface provides access to all the informers in this group version.
type Interface interface {
// Configs returns a ConfigInformer.
Configs() ConfigInformer
// Receivers returns a ReceiverInformer.
Receivers() ReceiverInformer
}
type version struct {
factory internalinterfaces.SharedInformerFactory
namespace string
tweakListOptions internalinterfaces.TweakListOptionsFunc
}
// New returns a new Interface.
func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
}
// Configs returns a ConfigInformer.
func (v *version) Configs() ConfigInformer {
return &configInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
}
// Receivers returns a ReceiverInformer.
func (v *version) Receivers() ReceiverInformer {
return &receiverInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
}

44
pkg/client/informers/externalversions/notification/v2alpha1/emailconfig.go → pkg/client/informers/externalversions/notification/v2beta1/receiver.go
View File

@@ -16,7 +16,7 @@ limitations under the License.
// Code generated by informer-gen. DO NOT EDIT.
package v2alpha1
package v2beta1
import (
"context"
@@ -26,64 +26,64 @@ import (
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
notificationv2alpha1 "kubesphere.io/kubesphere/pkg/apis/notification/v2alpha1"
notificationv2beta1 "kubesphere.io/kubesphere/pkg/apis/notification/v2beta1"
versioned "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
internalinterfaces "kubesphere.io/kubesphere/pkg/client/informers/externalversions/internalinterfaces"
v2alpha1 "kubesphere.io/kubesphere/pkg/client/listers/notification/v2alpha1"
v2beta1 "kubesphere.io/kubesphere/pkg/client/listers/notification/v2beta1"
)
// EmailConfigInformer provides access to a shared informer and lister for
// EmailConfigs.
type EmailConfigInformer interface {
// ReceiverInformer provides access to a shared informer and lister for
// Receivers.
type ReceiverInformer interface {
Informer() cache.SharedIndexInformer
Lister() v2alpha1.EmailConfigLister
Lister() v2beta1.ReceiverLister
}
type emailConfigInformer struct {
type receiverInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
}
// NewEmailConfigInformer constructs a new informer for EmailConfig type.
// NewReceiverInformer constructs a new informer for Receiver type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewEmailConfigInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredEmailConfigInformer(client, resyncPeriod, indexers, nil)
func NewReceiverInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredReceiverInformer(client, resyncPeriod, indexers, nil)
}
// NewFilteredEmailConfigInformer constructs a new informer for EmailConfig type.
// NewFilteredReceiverInformer constructs a new informer for Receiver type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredEmailConfigInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
func NewFilteredReceiverInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().EmailConfigs().List(context.TODO(), options)
return client.NotificationV2beta1().Receivers().List(context.TODO(), options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.NotificationV2alpha1().EmailConfigs().Watch(context.TODO(), options)
return client.NotificationV2beta1().Receivers().Watch(context.TODO(), options)
},
},
&notificationv2alpha1.EmailConfig{},
&notificationv2beta1.Receiver{},
resyncPeriod,
indexers,
)
}
func (f *emailConfigInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredEmailConfigInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
func (f *receiverInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredReceiverInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *emailConfigInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&notificationv2alpha1.EmailConfig{}, f.defaultInformer)
func (f *receiverInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&notificationv2beta1.Receiver{}, f.defaultInformer)
}
func (f *emailConfigInformer) Lister() v2alpha1.EmailConfigLister {
return v2alpha1.NewEmailConfigLister(f.Informer().GetIndexer())
func (f *receiverInformer) Lister() v2beta1.ReceiverLister {
return v2beta1.NewReceiverLister(f.Informer().GetIndexer())
}