Updated generated CRD code

Signed-off-by: Andy Goldstein <andy.goldstein@gmail.com>

pkg/apis/ark/v1/zz_generated.deepcopy.go

@@ -22,127 +22,9 @@ package v1
 
 import (
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	conversion "k8s.io/apimachinery/pkg/conversion"
 	runtime "k8s.io/apimachinery/pkg/runtime"
-	reflect "reflect"
 )
 
-// GetGeneratedDeepCopyFuncs returns the generated funcs, since we aren't registering them.
-//
-// Deprecated: deepcopy registration will go away when static deepcopy is fully implemented.
-func GetGeneratedDeepCopyFuncs() []conversion.GeneratedDeepCopyFunc {
-	return []conversion.GeneratedDeepCopyFunc{
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*Backup).DeepCopyInto(out.(*Backup))
-			return nil
-		}, InType: reflect.TypeOf(&Backup{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*BackupHooks).DeepCopyInto(out.(*BackupHooks))
-			return nil
-		}, InType: reflect.TypeOf(&BackupHooks{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*BackupList).DeepCopyInto(out.(*BackupList))
-			return nil
-		}, InType: reflect.TypeOf(&BackupList{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*BackupResourceHook).DeepCopyInto(out.(*BackupResourceHook))
-			return nil
-		}, InType: reflect.TypeOf(&BackupResourceHook{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*BackupResourceHookSpec).DeepCopyInto(out.(*BackupResourceHookSpec))
-			return nil
-		}, InType: reflect.TypeOf(&BackupResourceHookSpec{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*BackupSpec).DeepCopyInto(out.(*BackupSpec))
-			return nil
-		}, InType: reflect.TypeOf(&BackupSpec{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*BackupStatus).DeepCopyInto(out.(*BackupStatus))
-			return nil
-		}, InType: reflect.TypeOf(&BackupStatus{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*CloudProviderConfig).DeepCopyInto(out.(*CloudProviderConfig))
-			return nil
-		}, InType: reflect.TypeOf(&CloudProviderConfig{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*Config).DeepCopyInto(out.(*Config))
-			return nil
-		}, InType: reflect.TypeOf(&Config{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*ConfigList).DeepCopyInto(out.(*ConfigList))
-			return nil
-		}, InType: reflect.TypeOf(&ConfigList{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*DownloadRequest).DeepCopyInto(out.(*DownloadRequest))
-			return nil
-		}, InType: reflect.TypeOf(&DownloadRequest{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*DownloadRequestList).DeepCopyInto(out.(*DownloadRequestList))
-			return nil
-		}, InType: reflect.TypeOf(&DownloadRequestList{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*DownloadRequestSpec).DeepCopyInto(out.(*DownloadRequestSpec))
-			return nil
-		}, InType: reflect.TypeOf(&DownloadRequestSpec{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*DownloadRequestStatus).DeepCopyInto(out.(*DownloadRequestStatus))
-			return nil
-		}, InType: reflect.TypeOf(&DownloadRequestStatus{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*DownloadTarget).DeepCopyInto(out.(*DownloadTarget))
-			return nil
-		}, InType: reflect.TypeOf(&DownloadTarget{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*ExecHook).DeepCopyInto(out.(*ExecHook))
-			return nil
-		}, InType: reflect.TypeOf(&ExecHook{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*ObjectStorageProviderConfig).DeepCopyInto(out.(*ObjectStorageProviderConfig))
-			return nil
-		}, InType: reflect.TypeOf(&ObjectStorageProviderConfig{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*Restore).DeepCopyInto(out.(*Restore))
-			return nil
-		}, InType: reflect.TypeOf(&Restore{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*RestoreList).DeepCopyInto(out.(*RestoreList))
-			return nil
-		}, InType: reflect.TypeOf(&RestoreList{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*RestoreResult).DeepCopyInto(out.(*RestoreResult))
-			return nil
-		}, InType: reflect.TypeOf(&RestoreResult{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*RestoreSpec).DeepCopyInto(out.(*RestoreSpec))
-			return nil
-		}, InType: reflect.TypeOf(&RestoreSpec{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*RestoreStatus).DeepCopyInto(out.(*RestoreStatus))
-			return nil
-		}, InType: reflect.TypeOf(&RestoreStatus{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*Schedule).DeepCopyInto(out.(*Schedule))
-			return nil
-		}, InType: reflect.TypeOf(&Schedule{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*ScheduleList).DeepCopyInto(out.(*ScheduleList))
-			return nil
-		}, InType: reflect.TypeOf(&ScheduleList{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*ScheduleSpec).DeepCopyInto(out.(*ScheduleSpec))
-			return nil
-		}, InType: reflect.TypeOf(&ScheduleSpec{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*ScheduleStatus).DeepCopyInto(out.(*ScheduleStatus))
-			return nil
-		}, InType: reflect.TypeOf(&ScheduleStatus{})},
-		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
-			in.(*VolumeBackupInfo).DeepCopyInto(out.(*VolumeBackupInfo))
-			return nil
-		}, InType: reflect.TypeOf(&VolumeBackupInfo{})},
-	}
-}
-
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *Backup) DeepCopyInto(out *Backup) {
 	*out = *in

pkg/generated/clientset/versioned/doc.go

@@ -13,8 +13,5 @@ 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.
 */
-
-// This package is generated by client-gen with custom arguments.
-
 // This package has the automatically generated clientset.
 package versioned

pkg/generated/clientset/versioned/fake/doc.go

@@ -13,8 +13,5 @@ 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.
 */
-
-// This package is generated by client-gen with custom arguments.
-
 // This package has the automatically generated fake clientset.
 package fake

pkg/generated/clientset/versioned/scheme/doc.go

@@ -13,8 +13,5 @@ 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.
 */
-
-// This package is generated by client-gen with custom arguments.
-
 // This package contains the scheme of the automatically generated clientset.
 package scheme

pkg/generated/clientset/versioned/typed/ark/v1/doc.go

@@ -13,8 +13,5 @@ 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.
 */
-
-// This package is generated by client-gen with custom arguments.
-
 // This package has the automatically generated typed clients.
 package v1

pkg/generated/clientset/versioned/typed/ark/v1/fake/doc.go

@@ -13,8 +13,5 @@ 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.
 */
-
-// This package is generated by client-gen with custom arguments.
-
 // Package fake has the automatically generated clients.
 package fake

pkg/generated/informers/externalversions/ark/interface.go

@@ -30,15 +30,17 @@ type Interface interface {
 }
 
 type group struct {
-	internalinterfaces.SharedInformerFactory
+	factory          internalinterfaces.SharedInformerFactory
+	namespace        string
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
 }
 
 // New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &group{f}
+func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
+	return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
 }
 
 // V1 returns a new v1.Interface.
 func (g *group) V1() v1.Interface {
-	return v1.New(g.SharedInformerFactory)
+	return v1.New(g.factory, g.namespace, g.tweakListOptions)
 }

pkg/generated/informers/externalversions/ark/v1/backup.go

@@ -38,19 +38,34 @@ type BackupInformer interface {
 }
 
 type backupInformer struct {
-	factory internalinterfaces.SharedInformerFactory
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
 }
 
 // NewBackupInformer constructs a new informer for Backup 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 NewBackupInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredBackupInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredBackupInformer constructs a new informer for Backup 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 NewFilteredBackupInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
 	return cache.NewSharedIndexInformer(
 		&cache.ListWatch{
 			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
 				return client.ArkV1().Backups(namespace).List(options)
 			},
 			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
 				return client.ArkV1().Backups(namespace).Watch(options)
 			},
 		},
@@ -60,12 +75,12 @@ func NewBackupInformer(client versioned.Interface, namespace string, resyncPerio
 	)
 }
 
-func defaultBackupInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewBackupInformer(client, meta_v1.NamespaceAll, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+func (f *backupInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredBackupInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
 }
 
 func (f *backupInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&ark_v1.Backup{}, defaultBackupInformer)
+	return f.factory.InformerFor(&ark_v1.Backup{}, f.defaultInformer)
 }
 
 func (f *backupInformer) Lister() v1.BackupLister {

pkg/generated/informers/externalversions/ark/v1/config.go

@@ -38,19 +38,34 @@ type ConfigInformer interface {
 }
 
 type configInformer struct {
-	factory internalinterfaces.SharedInformerFactory
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
 }
 
 // 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 NewConfigInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredConfigInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// 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 NewFilteredConfigInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
 	return cache.NewSharedIndexInformer(
 		&cache.ListWatch{
 			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
 				return client.ArkV1().Configs(namespace).List(options)
 			},
 			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
 				return client.ArkV1().Configs(namespace).Watch(options)
 			},
 		},
@@ -60,12 +75,12 @@ func NewConfigInformer(client versioned.Interface, namespace string, resyncPerio
 	)
 }
 
-func defaultConfigInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewConfigInformer(client, meta_v1.NamespaceAll, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+func (f *configInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredConfigInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
 }
 
 func (f *configInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&ark_v1.Config{}, defaultConfigInformer)
+	return f.factory.InformerFor(&ark_v1.Config{}, f.defaultInformer)
 }
 
 func (f *configInformer) Lister() v1.ConfigLister {

pkg/generated/informers/externalversions/ark/v1/downloadrequest.go

@@ -38,19 +38,34 @@ type DownloadRequestInformer interface {
 }
 
 type downloadRequestInformer struct {
-	factory internalinterfaces.SharedInformerFactory
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
 }
 
 // NewDownloadRequestInformer constructs a new informer for DownloadRequest 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 NewDownloadRequestInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredDownloadRequestInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredDownloadRequestInformer constructs a new informer for DownloadRequest 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 NewFilteredDownloadRequestInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
 	return cache.NewSharedIndexInformer(
 		&cache.ListWatch{
 			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
 				return client.ArkV1().DownloadRequests(namespace).List(options)
 			},
 			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
 				return client.ArkV1().DownloadRequests(namespace).Watch(options)
 			},
 		},
@@ -60,12 +75,12 @@ func NewDownloadRequestInformer(client versioned.Interface, namespace string, re
 	)
 }
 
-func defaultDownloadRequestInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewDownloadRequestInformer(client, meta_v1.NamespaceAll, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+func (f *downloadRequestInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredDownloadRequestInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
 }
 
 func (f *downloadRequestInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&ark_v1.DownloadRequest{}, defaultDownloadRequestInformer)
+	return f.factory.InformerFor(&ark_v1.DownloadRequest{}, f.defaultInformer)
 }
 
 func (f *downloadRequestInformer) Lister() v1.DownloadRequestLister {

pkg/generated/informers/externalversions/ark/v1/interface.go

@@ -37,35 +37,37 @@ type Interface interface {
 }
 
 type version struct {
-	internalinterfaces.SharedInformerFactory
+	factory          internalinterfaces.SharedInformerFactory
+	namespace        string
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
 }
 
 // New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &version{f}
+func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
+	return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
 }
 
 // Backups returns a BackupInformer.
 func (v *version) Backups() BackupInformer {
-	return &backupInformer{factory: v.SharedInformerFactory}
+	return &backupInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
 }
 
 // Configs returns a ConfigInformer.
 func (v *version) Configs() ConfigInformer {
-	return &configInformer{factory: v.SharedInformerFactory}
+	return &configInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
 }
 
 // DownloadRequests returns a DownloadRequestInformer.
 func (v *version) DownloadRequests() DownloadRequestInformer {
-	return &downloadRequestInformer{factory: v.SharedInformerFactory}
+	return &downloadRequestInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
 }
 
 // Restores returns a RestoreInformer.
 func (v *version) Restores() RestoreInformer {
-	return &restoreInformer{factory: v.SharedInformerFactory}
+	return &restoreInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
 }
 
 // Schedules returns a ScheduleInformer.
 func (v *version) Schedules() ScheduleInformer {
-	return &scheduleInformer{factory: v.SharedInformerFactory}
+	return &scheduleInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
 }

pkg/generated/informers/externalversions/ark/v1/restore.go

@@ -38,19 +38,34 @@ type RestoreInformer interface {
 }
 
 type restoreInformer struct {
-	factory internalinterfaces.SharedInformerFactory
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
 }
 
 // NewRestoreInformer constructs a new informer for Restore 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 NewRestoreInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredRestoreInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredRestoreInformer constructs a new informer for Restore 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 NewFilteredRestoreInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
 	return cache.NewSharedIndexInformer(
 		&cache.ListWatch{
 			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
 				return client.ArkV1().Restores(namespace).List(options)
 			},
 			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
 				return client.ArkV1().Restores(namespace).Watch(options)
 			},
 		},
@@ -60,12 +75,12 @@ func NewRestoreInformer(client versioned.Interface, namespace string, resyncPeri
 	)
 }
 
-func defaultRestoreInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewRestoreInformer(client, meta_v1.NamespaceAll, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+func (f *restoreInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredRestoreInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
 }
 
 func (f *restoreInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&ark_v1.Restore{}, defaultRestoreInformer)
+	return f.factory.InformerFor(&ark_v1.Restore{}, f.defaultInformer)
 }
 
 func (f *restoreInformer) Lister() v1.RestoreLister {

pkg/generated/informers/externalversions/ark/v1/schedule.go

@@ -38,19 +38,34 @@ type ScheduleInformer interface {
 }
 
 type scheduleInformer struct {
-	factory internalinterfaces.SharedInformerFactory
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
 }
 
 // NewScheduleInformer constructs a new informer for Schedule 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 NewScheduleInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredScheduleInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredScheduleInformer constructs a new informer for Schedule 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 NewFilteredScheduleInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
 	return cache.NewSharedIndexInformer(
 		&cache.ListWatch{
 			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
 				return client.ArkV1().Schedules(namespace).List(options)
 			},
 			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
 				return client.ArkV1().Schedules(namespace).Watch(options)
 			},
 		},
@@ -60,12 +75,12 @@ func NewScheduleInformer(client versioned.Interface, namespace string, resyncPer
 	)
 }
 
-func defaultScheduleInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewScheduleInformer(client, meta_v1.NamespaceAll, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+func (f *scheduleInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredScheduleInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
 }
 
 func (f *scheduleInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&ark_v1.Schedule{}, defaultScheduleInformer)
+	return f.factory.InformerFor(&ark_v1.Schedule{}, f.defaultInformer)
 }
 
 func (f *scheduleInformer) Lister() v1.ScheduleLister {

pkg/generated/informers/externalversions/factory.go

@@ -22,6 +22,7 @@ import (
 	versioned "github.com/heptio/ark/pkg/generated/clientset/versioned"
 	ark "github.com/heptio/ark/pkg/generated/informers/externalversions/ark"
 	internalinterfaces "github.com/heptio/ark/pkg/generated/informers/externalversions/internalinterfaces"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	schema "k8s.io/apimachinery/pkg/runtime/schema"
 	cache "k8s.io/client-go/tools/cache"
@@ -31,9 +32,11 @@ import (
 )
 
 type sharedInformerFactory struct {
-	client        versioned.Interface
-	lock          sync.Mutex
-	defaultResync time.Duration
+	client           versioned.Interface
+	namespace        string
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	lock             sync.Mutex
+	defaultResync    time.Duration
 
 	informers map[reflect.Type]cache.SharedIndexInformer
 	// startedInformers is used for tracking which informers have been started.
@@ -43,8 +46,17 @@ type sharedInformerFactory struct {
 
 // NewSharedInformerFactory constructs a new instance of sharedInformerFactory
 func NewSharedInformerFactory(client versioned.Interface, defaultResync time.Duration) SharedInformerFactory {
+	return NewFilteredSharedInformerFactory(client, defaultResync, v1.NamespaceAll, nil)
+}
+
+// NewFilteredSharedInformerFactory constructs a new instance of sharedInformerFactory.
+// Listers obtained via this SharedInformerFactory will be subject to the same filters
+// as specified here.
+func NewFilteredSharedInformerFactory(client versioned.Interface, defaultResync time.Duration, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerFactory {
 	return &sharedInformerFactory{
 		client:           client,
+		namespace:        namespace,
+		tweakListOptions: tweakListOptions,
 		defaultResync:    defaultResync,
 		informers:        make(map[reflect.Type]cache.SharedIndexInformer),
 		startedInformers: make(map[reflect.Type]bool),
@@ -114,5 +126,5 @@ type SharedInformerFactory interface {
 }
 
 func (f *sharedInformerFactory) Ark() ark.Interface {
-	return ark.New(f)
+	return ark.New(f, f.namespace, f.tweakListOptions)
 }

pkg/generated/informers/externalversions/generic.go

@@ -51,7 +51,7 @@ func (f *genericInformer) Lister() cache.GenericLister {
 // TODO extend this to unknown resources with a client pool
 func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource) (GenericInformer, error) {
 	switch resource {
-	// Group=Ark, Version=V1
+	// Group=ark.heptio.com, Version=v1
 	case v1.SchemeGroupVersion.WithResource("backups"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Ark().V1().Backups().Informer()}, nil
 	case v1.SchemeGroupVersion.WithResource("configs"):

pkg/generated/informers/externalversions/internalinterfaces/factory_interfaces.go

@@ -20,6 +20,7 @@ package internalinterfaces
 
 import (
 	versioned "github.com/heptio/ark/pkg/generated/clientset/versioned"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	cache "k8s.io/client-go/tools/cache"
 	time "time"
@@ -32,3 +33,5 @@ type SharedInformerFactory interface {
 	Start(stopCh <-chan struct{})
 	InformerFor(obj runtime.Object, newFunc NewInformerFunc) cache.SharedIndexInformer
 }
+
+type TweakListOptionsFunc func(*v1.ListOptions)